LangGraph: Stateful Graphs and Durable Execution

Agents and workflows share a failure mode: a 40-step run dies at step 38, and you want to resume from the last completed step (37) and redo only step 38, not start over. Libraries that treat state as an afterthought assume every run is fresh, which leaves operators bolting retries on from the outside.

LangGraph's design answer is to make state a first-class typed object, make mutations explicit, and persist a checkpoint after every node. Resuming means loading the latest checkpoint for the session and continuing from there.

A LangGraph agent is a state machine: a typed state object, functions that update it, and edges that decide which function runs next. The runtime saves the state after every step, and durable execution, human review, and the rest of this lesson follow from that one decision.

The graph

A graph is defined by:

• State type. A typed dict (or Pydantic model) that every node reads. Nodes never modify it in place; they return updates, and the runtime builds the next state.
• Nodes. Functions (state) -> state_update that do not touch the input state. A reducer (the merge rule that combines the current state with a node's update into a new state) applies each update after the node returns. The default reducer overwrites the updated keys; custom reducers can append to a list or add numbers instead. This is why state counts as immutable: every step produces a new state object rather than editing the old one.
• Edges. Conditional or direct transitions between nodes.
• Entry and exit. START and END sentinel nodes mark the boundary.

Take an agent with classify, refund, bug, sales, and done nodes. That is a routing workflow written as a graph.

Durable execution

After each node returns, the runtime serializes the state and writes it to a checkpointer (SQLite, Postgres, Redis, custom). When a run fails at step N, the runtime loads the last checkpoint (the state after step N-1) and re-runs from step N with exact state. When a run pauses after a node has finished, as at a human gate, the checkpoint already includes that node, so resume continues from the next one. The exact calls differ by library; the idea is always load latest checkpoint, then continue.

The LangGraph docs point to Klarna, Uber, and J.P. Morgan as production users where this matters. The graph shape alone isn't the claim. The graph shape plus checkpointing is, because together they make recovery cheap.

Streaming

Every node can yield partial output, and the graph streams per-node-delta events to the caller. UIs update while the graph is still running.

Human-in-the-loop

You can inspect and modify state between nodes. The usual implementation: pause before a critical node, surface the state to a human, accept their modifications, then resume. The checkpointer makes this easy because the state is already serialized.

Memory

Short-term memory lives within a run, as conversation history in state. Long-term memory spans runs, persisted through the checkpointer plus a separate long-term store. LangGraph connects to external memory systems (Mem0, custom) via tools.

Three topologies

1. Supervisor. A central router LLM dispatches to specialist subagents. create_supervisor() in langgraph-supervisor does this, though in 2026 the LangChain team recommends going through tool calls directly for more control over context.
2. Swarm / peer-to-peer. Agents hand off directly to each other through a shared tool surface. There is no central router.
3. Hierarchical. Supervisors manage sub-supervisors, implemented as nested subgraphs.

Where this pattern goes wrong

• Checkpoints too small. If you only checkpoint conversation turns, tool state and memory writes can't be recovered. Serialize the full state.
• Non-deterministic nodes. Resume assumes a node's inputs produce the same state update. Random seeds, wall-clock time, and external API results have to be captured.
• Over-use of conditional edges. When every edge is conditional, the graph is a state machine nobody can reason about. Prefer linear chains with occasional branches.

code/main.py implements a stateful graph with the standard library only:

• State is a typed dict with messages, step, route, output, human_approval.
• Node is a callable that takes state and returns an update dict.
• StateGraph holds nodes, edges, and conditional edges. Runner.run executes it, and passing resume_from plus a saved state resumes a run.
• InMemoryCheckpointer stands in for a real backend such as SQLite. It deep-copies state after every node with save, and load_latest(session_id) returns the most recent snapshot. A real checkpointer would expose the same operations against a database.
• The demo graph runs classify -> branch(refund / bug / sales) -> human gate -> send.

Run it:

python3 code/main.py

The trace shows the first run pausing at the human gate (after that node's checkpoint is saved), then a resume from the next node, send, with the approved state, which produces the final output.

• LangGraph is the production-ready reference. Use create_react_agent, create_supervisor, or build your own graph.
• AutoGen v0.4 (Lesson 14) is the actor-model alternative for high-concurrency scenarios.
• Claude Agent SDK (Lesson 17) is a managed harness with a built-in session store.
• Custom is the choice when you need exact control over state shape or checkpointer backend.

outputs/skill-state-graph.md generates a LangGraph-shaped state graph in any target runtime, with checkpointing and resume already wired in.

1. Add a conditional edge from classify to end when classification confidence is below a threshold. Resume the run after a human sets route manually.
2. Swap the in-memory checkpointer for a real SQLite one. Measure the per-step serialization overhead.
3. Implement parallel edges: two nodes run concurrently and merge through a custom reducer. What does immutable state buy you here?
4. Read the langgraph-supervisor reference and port the toy to create_supervisor. Compare the trace shapes.
5. Add streaming so each node yields partial state while it runs. Print the deltas as they arrive.

• LangGraph overview: the reference docs
• langgraph-supervisor reference: supervisor pattern API
• AutoGen v0.4, Microsoft Research: actor-model alternative
• Claude Agent SDK overview: session store and subagents