Elatify
Enterprise AI

Durable Is Not Continuous: What Agent State Actually Survives

We treat “durable” as one property. eve's documentation treats it as a contract between a checkpoint, a version and a deployment — and it is unusually explicit about what does not survive a restart.

Elatify Strategic Insights
10 min read

The claim to test

“Durable” is the word every agent framework reached for this quarter. The useful question is not whether a framework has it, but what exactly it promises to preserve, and at what granularity.

eve — Vercel's filesystem-first agent framework, at [email protected] — publishes the most specific answer I have found. Its execution model is documented down to the behaviour of a single interrupted tool call, and reading it end to end changes what “durable” should mean to anyone governing these systems.

What is actually checkpointed

Work nests three levels deep: a session is the whole conversation, a turn is one user message and everything it triggers, and a step is a saved checkpoint inside a turn — by default one model call plus the inline tool calls that follow it.

Every session runs as one workflow on the Workflow SDK, and progress is saved at those step boundaries. The design intent is that your code runs inside a managed step, so tools, sandbox and subagents feel synchronous even though the session can pause and resume underneath them.

So the unit of durability is a step, not a request and not a message. That choice sets everything else.

What crash recovery actually does

“Crash the process, hit a timeout, or redeploy mid-turn, and the run picks up from the last completed step rather than replaying the whole turn. Completed steps never re-run; eve replays the recorded result. An interrupted step runs again from the checkpoint before it, so model calls in that step can run again.”

The mechanics are careful. A step publishes its session events before it saves its checkpoint, so a retried step continues the stream after whatever the interrupted attempt wrote. A tool call whose start is already in the recovered stream does not run again — the model is shown the call's name, input and known status, and decides whether to repeat it. Whatever the interrupted attempt left open ends abandoned: its model run, unfinished calls, and the approvals or questions it asked. The model asks again if it still needs them.

That is a genuinely thoughtful design. It is also explicitly not exactly-once, and the documentation says so in a list:

  • a call's start record may not be saved before the call begins, so a call whose start hadn't reached the stream can run again;
  • a call reported as interrupted may have taken effect, and the model can call the tool again;
  • a world that redelivers a step while an earlier attempt is still running can run both.

The remedy is the one you would want: “Give tools with irreversible effects a stable operation ID, or have them check whether the action already happened.”

This is the first governance lesson, and most teams learn it the hard way. “Durable” does not mean “safe to retry”. If your audit trail assumes an action happened exactly once because the agent is durable, the audit trail is wrong. Idempotency is your responsibility; the framework will replay, and replay can duplicate.

There is a bound on the damage: a turn fails with STEP_INTERRUPTED after more than three interrupted steps, or TURN_FAILED when a step fails on every retry. The session stays open for the next message.

The version is part of the checkpoint

Here is the part I would put in front of any enterprise architecture review.

A session is stranded when a different eve version built the workflow run that holds it. Only the version that started a run can replay it. The conversation stays stored; the current deployment cannot process a new message.

On Vercel Workflow, eve does not check — each run keeps executing on the deployment that started it. On every other world, “eve treats every world other than Vercel Workflow as running one eve version at a time, so a stranded session there never runs again.”

Which produces this line in the documentation:

“On a world other than Vercel Workflow, pin the exact eve version in package.json so upgrades happen only when you choose.”

A package.json pin is not normally a governance artefact. In this architecture it is the difference between a deploy and silent data loss. Your release policy and your state-retention policy are the same policy, and most organisations have them owned by different people.

The failure semantics are precise, which is worth noting because precision is what makes them governable:

What a Stranded Session Does, Surface by Surface
Seven surfaces, seven defined behaviours.
SurfaceBehaviour for a stranded session
Channel address (Slack thread)Ends the stranded session, starts a fresh one at the same address; the message becomes its first turn
create() on the addressThrows SessionStrandedError; you must end() first
Session IDNever ended implicitly; HTTP returns 409 with code: "session_stranded" and the eveVersion that built it
StreamingSame 409; the client stops reconnecting
Reading historyStill works, bounded and read-only — so you can inspect before you decide
clear()Refused: 409 session_stranded. It would preserve a session that cannot run
EndingWorks by address or ID, and is irreversible

A stranded session ends on its next channel message, an explicit end, or its session timeout — thirty days by default — whichever comes first, and executes nothing while it waits. Each retirement logs a warning naming the previous session, both eve versions, and the trigger.

Deployment retention is data retention

The sharpest detail in the whole document concerns a deleted Vercel deployment.

On Vercel Workflow, a session's run executes only on the deployment that started it. If that deployment is deleted — for example by a deployment retention policy — the run cannot execute again. eve detects this when a channel address reaches the session and replaces it. But there is a further consequence:

“The replaced session's recorded history can be unreadable, because its encryption key belonged to the deleted deployment.”

And the guidance that follows: “keep deployments longer than the session timeout.”

Sit with that. A routine cost-control setting — prune deployments after N days — can destroy the recoverability of agent conversations, because the key that protects their history lived with the deployment. Your CI retention policy is now a data-retention policy, and it interacts with a thirty-day default you probably never looked at.

That is the kind of second-order consequence a governance review exists to catch, and it is invisible from any feature list.

A replacement is not a continuation

When a session is replaced, what arrives is a new session: new ID, new stream, new auth, new channel binding, new state, and no history. eve exposes ctx.session.predecessor so your code can identify what it replaced.

Continuity, if you want it, is something you build. eve documents the pattern: read the stranded session's stream, convert it with transcriptOf(), and return it from a dynamic user-role instruction memoised by the predecessor's ID.

Three properties of that pattern matter for governance.

The transcript is narrow by design. It returns {role, text} messages oldest first. It leaves out reasoning, narration, tool calls and results, attachments, approvals and questions, and interrupted output. Tools, approvals, files, sandbox contents, authored state and interrupted work do not carry over.

The role choice is a security control. eve instructs: “Keep the instruction role 'user' and label the text as historical data, so text the earlier user wrote never reaches the model as system instructions.” The same principle as the superagent's authorization model — past content is data, never authority — applied to continuation.

You are responsible for the bounds. startIndex: -2000 requests the newest 2,000 stored lines, not events; the signal limits read time; the example returns null on failure so the turn continues rather than failing.

So “the agent remembers” is an application feature built on a read API, not a platform guarantee. If you cannot say which sessions read which predecessors, with what window and what timeout, you do not have a memory policy — you have a hope.

Approvals not surviving is correct, and must be stated

After a replacement, previous approvals are gone. An interrupted attempt's approvals and questions end abandoned, and the model must ask again.

That is the right default: consent given to one process should not silently authorise a different one. But it has an operational consequence that surprises people — a human approval granted before an upgrade does not cover work performed after it, and the agent will stop and re-ask. Teams that treat approvals as durable state will see their automation stall after every deploy and conclude the framework is unreliable, when in fact it is being careful.

What this means for an enterprise

Five controls, in the order they bite:

Five Controls, in the Order They Bite
  1. Pin the runtime version as a control, not as hygiene. On any non-Vercel workflow world, an unpinned upgrade strands live sessions permanently. Treat the pin as a state-compatibility statement.
  2. Align deployment retention with session timeout. Shorter than the timeout, and history can become unreadable. Make the two numbers owned by one person.
  3. Assume at-least-once for side effects. Give irreversible tools stable operation IDs or make them check. Durability is not a transaction manager.
  4. Write down your continuation policy. Which sessions reconstruct from a predecessor, how many messages, what timeout, and what is deliberately excluded. That document is your memory policy.
  5. Never let recovered text become instruction. Predecessor transcripts belong in a user-role, clearly labelled as historical data. This is the same content-is-not-authority rule that matters everywhere else.

What the other two designs actually are

It helps to see that these are not three implementations of one idea.

pi-durable makes durability a storage property: conversations, model turns, tool calls and your own state are committed before anything is shown, and a process that dies mid-turn resumes from what is on disk, with a bounded retry so a request that keeps killing the process ends. It is explicitly experimental.

dsh-superagent-prototype makes durability a social property: a work item opens, works in its own session and directory, and answers in the thread the team already reads. The durable object is the work item; the medium is the conversation.

eve makes durability an execution property, and pays for it in versions and deployments. None of the three is a superset of the others, and choosing one is choosing which failure mode you are prepared to operate.

Limits

I read eve's published documentation and the [email protected] release notes; I did not deploy it, and I make no claims about its operational behaviour under load. The quotes are from the framework's own docs, which are unusually specific — that specificity is the reason to take the design seriously, and also the reason to hold it to its own words.

The broader point is not about eve. It is that “durable” is a claim about a boundary, and the boundary is always narrower than the marketing. Ask what is inside it. Then ask which version is allowed to read it.

The Unit Is a Step

Not a request, not a message. What a checkpoint covers sets what replay can reuse and what a restart can duplicate.

The Version Is State

A run belongs to the eve version that built it. On any world but Vercel Workflow, an unpinned upgrade strands live sessions permanently.

Retention Is Retention

A deployment pruned on a cost-control schedule can take the encryption key for a session’s history with it.

Replay Is Not Exactly-Once

A durable agent will replay. Irreversible tools still need stable operation IDs or a check of their own.

Ask What Is Inside the Boundary

A durability claim is a claim about a boundary, and the boundary is narrower than the marketing. Elatify helps teams put governance around AI workforces — the state that survives, the version allowed to read it, and the record of what happened when it did not.

Related Insights

Content Is Never Authority: Reading dsh-superagent as an Architect
The model may propose but never grant itself permission.
Your AI Workforce Needs a Blast Radius
What an agent was permitted to do, on whose authority, and whether you can prove it.
When the Counterparty Says No: Agent Identity as the Real Blocker
An agent on a borrowed credential has no identity a counterparty can verify.