State Machine Architecture (Nodes & Edges)

At the core of LangGraph is a directed graph. Nodes represent LLM calls, tool executions, or sub-agent invocations. Edges define the flow — conditional edges let you branch based on LLM output, tool results, or custom logic. This is fundamentally different from linear chain frameworks: instead of A → B → C, you can build A → (B or C depending on A's output) → (D and E in parallel) → F if approved otherwise back to A. This graph model maps precisely to how production agent systems actually need to behave [4].

Durable Execution & Checkpointing

LangGraph agents can survive server crashes, network failures, and process restarts. The framework persists the complete state of every graph execution to a checkpoint store (configurable: in-memory, SQLite, Postgres, or cloud databases). When an agent crashes mid-execution, restarting it resumes from the last checkpoint — not from scratch. This is critical for long-running workflows like customer support triage (hours), data processing pipelines (hours to days), or multi-step approval workflows [5].

Human-in-the-Loop (Interrupts & Approval Gates)

LangGraph's HITL support is best-in-class. You can place interrupt() calls at any point in the graph, pausing execution until a human inspects the agent's state, modifies it if needed, and approves continuation. This happens at the state level — you can see exactly what the agent has accumulated, edit values directly, and let it continue with corrected context. No other open-source framework offers this level of HITL granularity without custom engineering [4].

DeltaChannel — The 73,000x Storage Optimization

LangGraph 1.2 introduced DeltaChannel, a fold-reducer channel pattern that dramatically reduces checkpoint blob size. Instead of storing the full message list at every step (which grows linearly with conversation turns), DeltaChannel stores only a sentinel value and replays writes on restore. At 500 conversation turns, add_messages produces a 219MB blob — DeltaChannel with infinite snapshot frequency produces just 3KB. That's a 73,000x reduction in storage. With snapshot_frequency=10, you get a practical 5x storage reduction with no read latency penalty [2].

Multi-Agent & Subgraph Support

LangGraph natively supports multi-agent architectures through subgraphs — each agent is itself a graph node that can be composed hierarchically. You can build supervisor agents that delegate to specialist agents, parallel agent teams that collaborate on different aspects of a task, or cascading workflows where one agent's output feeds another's input. Subgraphs inherit their parent graph's checkpointing and HITL capabilities automatically [4].

First-Class Streaming

Every LangGraph execution streams token-by-token output natively. You get visibility into the agent's reasoning chain, tool calls, and intermediate outputs in real time. This is essential for building responsive UIs where users watch their agent work — and it's built into the core framework, not bolted on as an afterthought [1].