Published on julin.ai
A common way to build an AI agent is to treat it as a long-running process. A worker receives a request, enters an agent loop, calls models and tools, waits for results, and eventually returns an answer.
This works well until agents start doing real work.
An agent may spend twenty minutes researching a problem, wait ten minutes for a build, ask a user for approval, or come back hours later when an external job finishes. Keeping a worker alive for the whole run wastes resources and makes failures expensive. A deployment, crash, or machine restart can also destroy work that has already happened.
A better model is to separate the agent run from the process executing it.
The agent run is durable. Its state, messages, tool results, budget, and current position are stored outside the worker. The worker is temporary. It leases a runnable agent, performs useful work for a short period, checkpoints the new state, and disappears.
Conceptually:
A run loads, cycles through think and tool steps inside a durable session, checkpoints, and the worker exits.
Another worker can later continue from the checkpoint.
This does not mean every model or tool call needs its own process. That would create unnecessary scheduling and state-reconstruction overhead. A worker might instead receive a 30- or 60-second lease and execute several agent steps while progress is being made.
The important boundary is waiting.
If an agent needs to wait five minutes for CI, it should not sleep for five minutes. It records that it is waiting and exits. When CI finishes—or a timer fires—the run becomes runnable again.
The same pattern works for rate limits, human approval, scheduled actions, external callbacks, and communication between agents.
This changes how we think about an agent.
Instead of:
one agent = one process
we get:
one agent = durable state
+ a sequence of short compute leases
That model has an interesting scaling property. A system might contain one million active agent runs without needing one million running processes. Most agents will usually be waiting. Only the agents with something useful to do need compute.
There are costs. State must be cheap to reconstruct. Side effects must survive retries without being executed twice. Browsers, shells, and sandboxes may need their own longer-lived services. Streaming also needs to be independent from whichever worker currently owns the run.
But these are infrastructure problems we already know how to solve.
Large web systems stopped assigning a permanent server process to every user long ago. Agent systems may eventually make the same transition.
The useful abstraction is therefore not a short-lived agent.
It is a durable agent with a leased executor.
