AX’s standout feature is ax suspend and ax resume — stopping a running agent mid-task and picking it back up later, exactly where it stopped, without losing progress or paying to keep idle compute spinning the whole time. Worth explaining why that’s a genuinely harder problem than it sounds, and not just a fancy pause button.
Pausing an ordinary program is comparatively simple because most programs are stateless or trivially resumable — a web server handling one request at a time doesn’t need to remember anything once that request finishes, and a batch job that gets interrupted usually just restarts from the beginning, since re-running it produces the same result. Neither of those shapes fits an agent mid-task.
An agent’s actual state, at the moment you’d want to pause it, is genuinely large and specific: the full accumulated context — everything I described in the context piece — every file it’s read, every tool result, the entire reasoning trail that got it to its current step. It might also have an open shell session, files it’s midway through editing, a sandbox environment with specific running processes. A real checkpoint has to capture all of that faithfully enough that resuming feels seamless to the agent, not like starting over with a summary of what happened before — the same distinction I drew between full context and a compressed version of it, just applied to pausing execution rather than pausing a conversation.
Why this matters practically, beyond just being a neat engineering trick: it directly targets a specific kind of expensive waste in agentic workloads. Agents spend real stretches of time idle — waiting on a slow external API, waiting on a human to approve a step, waiting on a long-running build. Without real checkpointing, keeping an agent “alive” through that wait means either paying to keep its full compute environment running the whole time doing nothing, or losing all its accumulated context and restarting from scratch once the wait is over. Genuine suspend-and-resume means the agent can be checkpointed to storage, its compute released entirely, and picked back up later exactly where it stopped — cost paid only for the actual working time, not the waiting.
Where this connects to sandboxing specifically: a proper sandbox already needs to track an agent’s full state to contain it safely in the first place — filesystem, process state, what it’s currently allowed to touch. Checkpointing is close to a natural extension of that same tracking, just serialized to disk instead of held live in memory. It’s not a coincidence that AX’s suspend-and-resume claim comes bundled with a sandboxed execution layer underneath it — the infrastructure doing containment and the infrastructure doing checkpointing are solving adjacent problems with a lot of the same state to keep track of either way.
The honest limit worth naming: a checkpoint is only as good as how completely it captures everything that actually mattered about the agent’s state. Miss something — an open network connection, a background process, a piece of context that didn’t make it into the snapshot — and “resume exactly where it left off” quietly becomes “resume from an approximation of where it left off,” which is a much harder failure to notice than an agent that visibly restarted from zero.
