Your onboarding agent sends the welcome pack on Monday and then has nothing to do until someone signs a contract. On Wednesday night the machine it was running on goes away — a deploy, a scale-down, a crash, pick whichever you like. On Thursday the signature arrives and the agent carries on from exactly the right place: documents signed, hardware next. Nothing was recovered, because there was nothing left to recover. The process that sent the welcome pack had been dead since Wednesday and never came back. What continued on Thursday was never a process in the first place.

Nobody stands at the lock all afternoon

Walk a canal and every so often you pass a lock: two sets of gates, a chamber between them, paddles that raise and drop the level between one side and the other. Everything you need to know about that lock is in the lock. Anyone arriving can read it off — which gates are shut, which paddles are raised, how full the chamber is. A barge turns up, somebody works it through, opens the far gates and walks off. Between barges the lock stands there and nobody watches it. If whoever was working it stopped halfway and went home, the next person reads the level and carries on. They do not need to be told about the morning.

A durable agent workflow has that shape. Its state is a short list of named checkpoints — welcome sent, documents signed, completed — and each tool writes the next one into a session store as it finishes, in a single atomic step. Because the checkpoint is on disk rather than in a transcript, the run that wrote it is allowed to end. When the signing webhook arrives, it loads the session, applies the change, and starts a runner again from cold. The prompt that runner builds carries the current checkpoint and the handful of fields the next step needs, not four days of chat.

One person can work a whole flight

A flight of locks does not get a person each, because for most of the day there is no barge, and paying someone to stand in the rain is a poor way to buy readiness. Run an agent as a container that stays up for the whole job and you have hired exactly that person, once per agent, for every hour of waiting.

Sandboxing is what usually gets the attention here, and it solves a different problem. Strong isolation makes it safe to run the agent’s code; it does nothing about the bill for the hours it idles, or about the sprawl of one long-lived container per agent. The split that helps is between the agent’s identity — its template, its stored state, its policy — which lives in a control plane and persists, and the isolated worker that gets handed the agent only when there is work. Six agents with different skills can sit dormant and share a single worker; when two of them are invoked at once, the pool grows to two, and the other four still do not need one of their own. Suspending a worker is not losing the agent, and an agent resumed on a different worker is the same agent, provided workers are never quietly recycled between tenants without isolation.

The event is the only thing joining them

The joint between the part that decides and the part that runs is the event, and getting it wrong is how the whole arrangement collapses back into what it replaced. Poll for the signature and you are holding a container open to ask a question whose answer is no. Keep the conversation as the source of truth and there is nothing typed to resume from, so the model reads a four-day silence and fills it in with plausible steps that never happened. Let a transition be written in two parts and a crash between them leaves a session nobody can safely restart — the ambiguity is the damage, not the crash.

Explicit checkpoints avoid all of that for the same reason an explicit handle beats a hidden session in State You Can Point At: something the next call can name outlives whatever was holding it. It also makes the process testable, because you can stage a pause and a resume in evaluation and watch which gate the agent tries to walk through. And it is the reason the interesting engineering keeps landing outside the model, as The Loop Is the Product argues from the other side.

An agent that survives a restart is one that was never the thing being restarted.