Durable execution is the feature LangGraph sells hardest, and rightly: checkpoint the graph's state after every super-step, and a process that dies mid-run — OOM, spot reclaim, a 3 a.m. deploy — resumes from the last committed step instead of restarting the whole agent. It is the difference between a toy and something you'd run against a customer's money.
The part nobody puts on the landing page is what that durability costs, and the cost is not linear.
A checkpoint stores the whole thing, every time#
A LangGraph checkpoint captures the full value of every channel at a super-step boundary. For most channels that's cheap and bounded. But the channel you actually care about in an agent — the one accumulated by a reducer, the message list — only grows. Each step appends a tool call, an observation, a model turn. Nothing is removed.
So walk the arithmetic. On step 2 the checkpoint serializes 2 messages. On step 50 it serializes 50. On step 200, all 200 — again — even though 199 of them were already written into the previous checkpoint, and the one before that. A thread that runs for N steps writes on the order of N² bytes to persist a conversation that only ever contained N messages worth of information.
Durability doesn't fail loudly. It just gets quadratically more expensive per step, until the checkpoint store — not the model, not the context window — is the thing that falls over.
For a five-turn support bot this is invisible. For the long-horizon agents everyone now wants — a research run that grinds for hours, a coding agent chewing through a repo, an ambient assistant that never really ends its thread — it is a real wall, and it shows up as checkpoint latency and storage bills long before the model does anything wrong.
DeltaChannel is the runtime conceding the point#
DeltaChannel, shipped in beta across the LangGraph 1.1–1.2 line during Q2 2026, changes what a checkpoint records. Instead of re-serializing a channel's entire accumulated value, it stores only the incremental delta each step contributes. LangChain describes the target case exactly: "channels that grow large over time — for example, a message list in a long-running thread." Without it, the full list lands in every checkpoint; with it, only the new messages from each step are persisted.
That single change collapses the write cost from roughly O(N²) to O(N). The state is reconstructed by replaying deltas rather than reading one fat snapshot — the classic event-sourcing trade you already know from durable-execution engines like Temporal, now offered as a channel type inside the graph instead of a runtime you bolt on beside it.
Read the rest of 1.1–1.2 in this light#
Once you see the write-amplification problem, the other reliability features in the same releases stop looking like a grab-bag and start looking like a coherent answer to "what breaks when agents run long":
- Per-node timeouts. Pass a
timeouttoadd_nodeand aTimeoutPolicycaps a single attempt — hard wall-clock, an idle timeout that resets on progress, or both. On expiry LangGraph raisesNodeTimeoutError, clears that attempt's writes, and hands off to the retry policy. The write-clearing is the tell: half-finished state is the enemy of a clean checkpoint. - Node-level error handlers. Failure containment at the node, not the graph — so one flaky tool call doesn't poison the whole resumable thread.
- The v2 typed streaming API. Passing
version="v2"tostream()/astream()returns unifiedStreamPartchunks, each carryingtype,ns, anddatawith a concrete typed shape. This is the observability half of the same story: if your agent runs for an hour, you need to see inside it with types you can trust, not guess at loosely-shaped events.
None of these are features you'd prioritize for a chatbot. All of them are table stakes for something that stays alive.
The non-obvious lesson#
The durable-agent pitch quietly assumes persistence is a solved, flat-cost primitive — turn it on, get resumability. It isn't. Persistence has a shape, and for the accumulating channels that define an agent, that shape is superlinear in how long the thing runs. DeltaChannel is worth understanding not because you'll always need it, but because it names the failure mode: your scaling ceiling may be the checkpoint store, and the fix is architectural, not a bigger disk.
If you're standing up long-lived LangGraph threads, measure checkpoint size against step count before you measure anything else. If that curve bends upward faster than your conversation grows, you've found your quadratic — and now you know which lever moves it. For the broader arc of what landed in the 1.0 line first, our rundown of LangChain 1.0 and LangGraph 1.0 is the companion to this one; for the failure side, the replay trap in durable execution is the other half of the durability story.
