LangGraph DeltaChannel: Shrink Long-Thread Checkpoints

Long-running AI agents have a quiet storage problem. Every step you take, LangGraph serializes the entire message list back into your checkpoint store. Run 50 turns and you have written your conversation 50 times - the last write contains every prior turn. That is quadratic growth, and on a busy coding agent it explodes fast.

LangGraph 1.2 (released May 12, 2026) ships a new primitive called DeltaChannel that fixes this. Instead of full snapshots every step, it writes only the diff and saves a full snapshot every K steps. LangChain measured a 200-turn coding agent dropping from 5.3 GB to 129 MB - a 41x reduction with no code changes inside Deep Agents v0.6. This guide shows how to wire DeltaChannel into your own graph, tune the snapshot cadence, and avoid two gotchas that bite people on day one.

The O(N^2) checkpoint problem

Standard LangGraph reducers (add_messages, list operator.add, dict merge) produce a new full value every step. The checkpointer then writes that whole value. For a thread of length N steps and per-step payload size proportional to N, total bytes written is N x N = N^2.

Numbers are from LangChain's own benchmarks. If you have ever wondered why a long agent thread suddenly costs $$$ on Postgres or hits S3 rate limits, this is why.

Prerequisites

• Python 3.10+
• langgraph>=1.2 (DeltaChannel is in beta and gated on this version)
• Any checkpointer - MemorySaver, SqliteSaver, or PostgresSaver
• Optional: an LLM provider key if you want to run the agent end-to-end

Install

pip install -U "langgraph>=1.2" langgraph-checkpoint-sqlite langchain-anthropic

A graph with DeltaChannel

Below is a minimal chat agent. The only new line vs a normal LangGraph build is the Annotated[..., DeltaChannel(...)] hint on the messages field.

from typing import Annotated, TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.channels import DeltaChannel  # NEW in 1.2
from langgraph.checkpoint.sqlite import SqliteSaver
from langchain_anthropic import ChatAnthropic


class ChatState(TypedDict):
    # Same reducer (add_messages), wrapped in DeltaChannel.
    # snapshot_frequency=50 = one full snapshot per 50 steps,
    # diffs in between.
    messages: Annotated[
        list,
        DeltaChannel(reducer=add_messages, snapshot_frequency=50),
    ]


llm = ChatAnthropic(model="claude-opus-4-6")


def chat(state: ChatState):
    return {"messages": [llm.invoke(state["messages"])]}


g = StateGraph(ChatState)
g.add_node("chat", chat)
g.add_edge(START, "chat")
g.add_edge("chat", END)

saver = SqliteSaver.from_conn_string("agent.db")
app = g.compile(checkpointer=saver)

That is it. Resume, time-travel, and human-in-the-loop all work the same as before - LangGraph stitches diffs together on read.

Example I/O

cfg = {"configurable": {"thread_id": "u-42"}}

# Turn 1
app.invoke({"messages": [("user", "Hi, what is LangGraph?")]}, cfg)

# Turn 2 - state is loaded from a diff + last snapshot, not a full re-read
app.invoke({"messages": [("user", "Show me a tiny example.")]}, cfg)

# Inspect the channel
snap = app.get_state(cfg)
print(snap.values["messages"][-1].content[:60])
# -> "Here is a minimal chat graph that uses..."

How a delta step actually writes

On every step, DeltaChannel asks the reducer for the new contribution only and serializes that. On step k mod snapshot_frequency == 0, it folds everything back into a fresh full snapshot. Recovery cost is bounded: at worst you replay K-1 diffs onto the last snapshot.

• reducer: same callable you would pass without DeltaChannel (e.g. add_messages).
• snapshot_frequency: full snapshot every K steps. Default in Deep Agents v0.6 is 50.
• min_delta_bytes: optional - merge tiny deltas before write to cut row count.

Tuning snapshot_frequency

K is a trade-off between write cost (low K = more snapshots = more bytes) and resume cost (high K = more diffs to replay). Rule of thumb:

# Background agent that runs for days
messages: Annotated[
    list,
    DeltaChannel(reducer=add_messages, snapshot_frequency=200),
]

Common pitfalls

• Non-monotonic reducers. DeltaChannel assumes new values add to the channel. If your reducer can shrink state (e.g. it deletes messages), wrap it in your own snapshot logic or do not use DeltaChannel for that field.
• Migrating an existing thread. Threads written with the old format keep working, but the first delta write happens on the next step. Do not panic when the first checkpoint after upgrade is still large - that is the bridge snapshot.
• Custom serializers. If you replaced the default JsonPlusSerializer, make sure your serializer round-trips __add__-style merges. The built-in one does.
• Channel-level only. DeltaChannel reduces bytes per channel. If 90% of your state is a giant blob in a different field, wrap that field too - or, better, move it to object storage and keep a URL.

Quick reference

Next steps

• Wrap the messages field of your largest agent and replay 24 hours of traffic.
• Watch checkpoints row size in your DB - you should see new rows shrink dramatically.
• If you run deepagents>=0.6, DeltaChannel is on by default - measure before tuning K.
• Pair with LangGraph 1.2's new per-node timeout= and error_handler= to cap blast radius on the same long-running threads.

Storage was always the silent tax on long agent sessions. With DeltaChannel, that tax is gone for the cost of a one-line type hint.