LangGraph is LangChain's StateGraph library for explicit agent control flow. You declare nodes (units of work), edges (forward transitions), conditional edges (routing functions that read state), a typed shared state object with reducers, and a checkpointer for persistence. It's built on top of LCEL Runnables but exposes the loop that AgentExecutor hid behind a black-box while loop. What you get over AgentExecutor: explicit cycles and branches, pause / resume via checkpointers, human in the loop interrupts, time-travel debugging, and trace-friendly per-node observability. Picking LangGraph over AgentExecutor is the standard graduation when an agent goes from prototype to production.
**LangGraph** is a library inside the LangChain ecosystem for building agents and complex workflows as explicit state machines. It is built on LangChain's Runnable interface, so any LCEL component (prompts, models, tools, parsers) drops in as a node.
The core abstraction is the `StateGraph`. You define a typed shared state object, then declare nodes (units of work that read state and return updates), edges (forward transitions from one node to the next), and conditional edges (routing functions that read state and pick which node to go to). You compile the graph into a Runnable and invoke it like any other LangChain component.
The contrast with LangChain's older `AgentExecutor` is the point. `AgentExecutor` ran the tool-using loop inside a hidden `while` loop, you could not easily pause it, branch on intermediate state, or resume after a crash. `StateGraph` makes that loop an inspectable, persistable object.
What you get on top: **checkpointers** persist state to a backend (in-memory, SQLite, Postgres) so the graph can pause and resume, **human in the loop interrupts** let a human step in mid-flow, and **time-travel debugging** lets you rewind to any prior checkpoint and replay from there.
**LangGraph** is LangChain's StateGraph library for building agent control flow as an inspectable, persistable graph instead of a hidden `while` loop. It is layered on top of LangChain LCEL Runnables, not a separate framework, and any LCEL component drops in as a node.
The primitives are five. **Nodes** are units of work (a model call, a tool call, a custom function) that read the shared state and return an update. **Edges** are forward transitions between nodes. **Conditional edges** are routing functions that read state and return the name of the next node, this is how branching and cycles get expressed. **State** is a typed object (often a `TypedDict`) shared across nodes, with **reducers** that say how to merge updates (append to a message list, overwrite a scalar). **Checkpointers** persist the full state at each step to a backend (in-memory, SQLite, Postgres, Redis).
What LangGraph exposes that `AgentExecutor` hid: explicit cycles you can reason about, pause/resume via checkpointers, **human in the loop interrupts** via `interrupt_before` / `interrupt_after`, time-travel debugging (replay from any prior checkpoint), and per-node observability that traces cleanly into LangSmith or Langfuse.
The standard graduation path is from `AgentExecutor` (great for prototypes) to LangGraph (the production answer when you need debuggability, durable state, or human approval steps).
Quick reference
TL;DR
LangGraph is LangChain's StateGraph library; it exposes the agent loop as an inspectable graph of nodes, edges, and shared state, with checkpointers for pause/resume and human in the loop interrupts.
Picture two flowcharts taped to a wall. The first one is a single black box labeled "run the agent" with an arrow looping back to itself, you have no idea what happens inside. That is LangChain's AgentExecutor. The second flowchart has labeled boxes for each step, arrows showing which box leads to which, save points where you can pause the whole thing, and a way for a human to step in mid-process. That is LangGraph. Same agent behavior, but every step is visible, pausable, and resumable instead of buried inside a hidden loop.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
A 50-line prototype agent that calls one tool and returns an answer. The graph machinery is overkill for a single linear pipeline. AgentExecutor or even a raw LCEL chain is simpler and shorter.
A stateless single-turn classification or extraction call. LangGraph's value is in stateful, multi-step loops. A single inference has no loop to make explicit.
An ecosystem that has already standardized on a different orchestration framework (e.g. OpenAI Agents SDK, AutoGen, CrewAI). Mixing orchestration frameworks fragments observability and complicates the deployment surface. Pick one and commit unless the workload genuinely demands two.
Quick scan · 2–4 min
Everything important, quickly.
Define LangGraph as LangChain's StateGraph library, name the five primitives (nodes, edges, conditional edges, state with reducers, checkpointer), contrast with AgentExecutor's hidden loop, list the production wins (pause/resume, HITL, time-travel), and close with the graduation trigger from AgentExecutor to LangGraph.
Real-world examples
Real products, models, and research that use this idea.
1LangGraph's official template repo includes a customer-support agent that uses `interrupt_before` to gate refund actions on a human's approval before the agent executes them.
2Replit's Agent product uses LangGraph for its multi-step coding agent because checkpointing lets sessions resume after IDE reconnects.
3Norway's tax authority piloted a LangGraph supervisor pattern (a manager node routing to specialist sub-graphs) for complex citizen inquiries that needed structured handoffs.
4LangChain's own docs explicitly recommend LangGraph as the migration target for `AgentExecutor`-based agents going to production.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does a LangGraph checkpointer differ from logging? Why isn't "log the agent state to a database" equivalent?
Sign in or go Pro to see the approach for this follow-up.
QWhy does a state reducer matter? What goes wrong without one?
Sign in or go Pro to see the approach for this follow-up.
QWalk through how `interrupt_before("send_email")` would gate an action on human approval in production.
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Describing LangGraph as "a different framework from LangChain". It is built on LangChain's LCEL Runnables, the relationship is one of layering, not competition.