LangGraph

What it is

LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents. It is published by LangChain under the MIT license, with a Python package and an equivalent JavaScript and TypeScript library. It integrates with other LangChain products and can be used without them.

The loop as a graph

In LangGraph the agent loop is a graph you define. A StateGraph holds a state schema; nodes are functions that do work and return state updates; edges decide which node runs next. Conditional edges route based on the current state, which is how a graph expresses the decisions a hand-written loop would bury in if-statements. A graph is compiled before it runs.

Making the loop explicit is the main architectural benefit. The control flow, the stopping conditions, and the places a person can intervene are all visible in the graph definition rather than implied by prompt wording.

State and checkpoints

State is shared across nodes, with reducer functions deciding how updates merge. When a graph is compiled with a checkpointer, LangGraph saves state at each step boundary, so a thread can be resumed later. The project describes this as durable execution: agents persist through failures and resume where they stopped.

Saved state per step is also a record. It is what makes it possible to answer what the agent knew at the point it made a decision, which is the core of the inspectable and auditable tests.

Human-in-the-loop interrupts

A node can call interrupt() to pause the run and wait for a person. The run resumes with a value supplied by the caller, which becomes the result of the interrupt inside the node. Because state is checkpointed, the pause can last as long as the approval takes.

This is approval enforced by the program, not requested in a prompt: the graph cannot proceed past the interrupt until someone resumes it.

Fan-out and multi-agent patterns

Conditional edges can return Send objects, each targeting a node with its own state, so the number of parallel branches can be decided at run time. Map-reduce style work and supervisor-and-worker multi-agent designs are built from this and from subgraphs.

LangChain, LangSmith, and deployment

LangChain's LangSmith is the recommended tool for tracing, evaluation, and observability, and LangSmith Deployment is the managed option for running long-running workflows. The project also points to Deep Agents, a higher-level package built on LangGraph, for teams that want a ready-made agent rather than a graph from scratch. The library itself does not require any of these.

Framework or harness

The harnesses on this site are mostly finished agents. LangGraph is what you use when none of them fit and you need to build one: a support agent with a specific approval step, a data pipeline agent with fixed stages, a supervisor that delegates to specialized workers. You take on the harness responsibilities the harness layer article lists, and you get exact control over each one.

Where it fits in an open stack

LangGraph sits in the execution layer as a toolkit for building harnesses and simple brokers. It is model-agnostic through its integrations, can call tools including MCP servers through adapters, and leaves storage of checkpoints to backends you choose.

Gotchas worth knowing

• You own the harness work. Context selection, retries, tool design, and stopping rules are yours to build.
• Checkpoint storage is a data store. It holds prompts, tool results, and user data. Govern and retain it accordingly.
• Graphs grow. A graph with many conditional edges becomes hard to reason about; subgraphs keep it manageable.
• Managed services are separate choices. Tracing and deployment products are optional; decide on them as you would any vendor.

How it scores on openness

• Replaceable. Strong. Model-agnostic through integrations, and checkpoint backends are pluggable.
• Inspectable. Strong. MIT source, an explicit graph, and per-step saved state.
• Portable. Moderate. Graph definitions are code tied to the library; the state and tools they use can be portable.
• Bounded. Strong where you build it: interrupts and explicit edges enforce approvals in code.
• Grounded. Depends on the tools and data you connect.
• Auditable. Strong when checkpoints are kept in storage you own and retained long enough.

What it is not

LangGraph is not a ready-made agent or a model. It is not a protocol; graphs built with it do not interoperate with other frameworks unless you expose them through one, such as MCP or A2A.