LangGraph — Build Stateful AI Agents as Graphs

Why graphs beat chains for agents

LangChain's original Chain abstraction assumed linear sequences: step A → step B → step C. But real AI agents loop ("retry until valid"), branch ("if answer is long, summarize"), and wait ("ask human for approval"). LangGraph drops the linear assumption and models agents as directed graphs with state, borrowing from dataflow systems and actor models.

The hello world

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, List

class State(TypedDict):
    messages: List[str]

def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

graph = StateGraph(State)
graph.add_node("chatbot", chatbot)
graph.add_edge(START, "chatbot")
graph.add_edge("chatbot", END)
app = graph.compile()

The state flows through nodes. Each node mutates or enriches state. Edges route based on conditions you define.

Core features that make it production-ready

Persistence

State is automatically checkpointed. If a node crashes mid-execution, you resume from the last checkpoint. Supports PostgreSQL, SQLite, and Redis checkpointers.

Human-in-the-loop

interrupt_before and interrupt_after pause execution at any node, waiting for external input (approval, edit, rejection) before continuing.

Streaming

Stream state updates, tokens, or both. Built-in support for Server-Sent Events (SSE) means your UI updates in real time as the agent works.

Time travel

Replay past executions with different inputs. Critical for debugging complex multi-step agents.

LangGraph vs LangChain (the relationship)

LangChain is the library of building blocks (LLM wrappers, tool schemas, prompt templates). LangGraph is the orchestrator for connecting those blocks into a running agent. Since 2024 LangChain's official recommendation for agents has been "use LangGraph, not Chains."

Real-world patterns

Pattern 1: ReAct agent with validation loop

plan → execute tool → validate output → [loop back to plan if invalid]

Pattern 2: Multi-agent team with supervisor

supervisor → {researcher | coder | reviewer} → supervisor → END

Pattern 3: Human approval gate

research → draft → interrupt_before(publish) → publish | reject → END

Pattern 4: Parallel branch + merge

research → {search_google, search_docs, search_memory} → merge → synthesize

Deployment options

1. LangGraph Cloud (LangChain-hosted) — $39/mo starting, includes observability.
2. Self-hosted via Docker — single-command deploy, Postgres checkpointer recommended.
3. Inline in your app — just pip install langgraph, compile your graph, call .invoke() or .stream().

Observability via LangSmith

Every node execution is traced in LangSmith (LangChain's observability platform). Token usage, latency, tool calls — all visible in a timeline view. Costs $0 for small projects, scales with usage.

When LangGraph is overkill

If your agent is:

• 1 tool call and done — use the provider SDK directly
• A single LLM completion — use LangChain's simpler LLMChain
• Purely reactive (no state) — use an event queue

But once you need retries, branching, or human intervention, LangGraph pays off fast.