LangGraph: a low-level orchestration framework for stateful agents

The problem LangGraph solves: state that outlives a single LLM call

A single prompt and response is easy. The difficulty starts when an agent has to run for minutes or hours, survive a process restart, pause for a human decision, and remember what happened in an earlier session. Most LLM libraries model a call, not a run. LangGraph is positioned as a low-level orchestration framework for exactly that second case: long-running, stateful agents and workflows.

The README lists four capabilities that map onto that problem. Durable execution persists through failures and resumes from where it left off. Human-in-the-loop lets you inspect and modify agent state at any point during execution. Memory is split into short-term working memory for ongoing reasoning and long-term persistent memory across sessions. Debugging and deployment are handled through LangSmith, which is a separate product.

That framing tells you who it is for. It is for engineers building agent systems where the control flow matters: retries, branches, subgraphs, approval gates. It is not a prompt wrapper, and the README does not present it as one.

How LangGraph works: a graph of nodes over a shared state

The name is literal. You define a graph: nodes that do work, edges that decide what runs next, and a state object that flows between them. The README says the public interface draws inspiration from NetworkX, and the execution model from Pregel and Apache Beam. Pregel is the bulk-synchronous graph processing model, which is where the idea of running a graph in supersteps comes from.

State is the centre of the design. Nodes read from it and return updates to it rather than passing return values down a call stack. That is what makes interruption possible: if state is the only thing that carries information forward, an execution can be stopped between nodes and resumed later from the persisted state. The docs call the persistence layer a checkpointer, and the repository's examples folder includes a delta-channel-dump example, which suggests the channel-level state model is something users inspect directly.

Human-in-the-loop follows from the same mechanism. Because state is inspectable between steps, a run can be halted, the state edited, and execution continued. The README points to a dedicated interrupts page in the docs rather than describing the API inline, so the exact call surface is something to read there.

The trade-off is visible in the architecture. Nothing is implicit. You choose the state schema, the nodes, the edges and the checkpointer. That is the point of a low-level framework, and it is also the reason a first graph takes longer to write than a first call to a chat model.

Installing LangGraph and running a first stateful graph in Python

The README gives a single install command. It upgrades an existing install, so it works whether or not you already have the package.

pip install -U langgraph

After that, the README points to the Quickstart at docs.langchain.com for the first graph. The repository also ships runnable material under examples/, including a react-agent-from-scratch.ipynb notebook and directories for human_in_the_loop, multi_agent and plan-and-execute. Those are the concrete starting points the project offers; the README itself does not inline a graph definition.

If you want to work from the repository rather than from a release, the top-level Makefile shows how the maintainers set up a development environment. It creates a virtual environment with uv and installs every project under libs/ in editable mode.

make install

That target runs uv venv and then uv pip install -e on each libs/* directory containing a pyproject.toml. The other targets are lint, format, lock, lock-upgrade and test, each of which walks the same libs/* directories and delegates to a per-project Makefile. For a first real use, the notebook examples are the shortest path: they run end to end without you having to design a state schema before you have seen one.

Where LangGraph is the wrong tool

The README is unusually direct about this. A callout tells readers that if they want to quickly build agents, they should look at Deep Agents, described as a higher-level package built on LangGraph for agents that can plan, use subagents, and work with file systems. That is the project itself saying the low-level layer is not the fastest route to a working agent.

The second limitation is operational. Durable execution and cross-session memory are only as good as the persistence behind them. The README links to a checkpointer concept in the docs but does not describe the backends, their consistency behaviour, or what happens when a checkpoint write fails mid-run. If your agent's resumption guarantee matters, that is documentation you have to read before you rely on it, not something the README settles.

The third is deployment. The production deployment path in the README is LangSmith Deployment, and debugging is LangSmith. LangGraph can be used standalone and without LangChain, but the observability and hosting story the README describes is LangChain's own platform. If you are not willing to run that platform or to build the equivalent yourself, you are using a subset of what the README advertises.

LangGraph vs LangChain, and what CrewAI does differently

The LangChain comparison is the one people ask about most, and the repository answers it structurally. LangChain is described in the README as providing integrations and composable components; LangGraph is the orchestration layer underneath. They are not competing implementations of the same thing. LangGraph can be used without LangChain, and the README says so explicitly. In practice that means LangChain gives you the model and tool integrations, and LangGraph gives you the control flow and state around them.

CrewAI takes a different starting point. It is built around roles and tasks assigned to agents, so the framework decides much of the coordination for you. LangGraph makes you write the coordination: the nodes, the edges, the state schema. For a small team that wants a multi-agent system running this week, the CrewAI shape is less work. For a system where the exact order of steps, the retry behaviour and the resumption point have to be controlled, the explicit graph is the reason to pick LangGraph. The repository's multi_agent example is the place to see how much of that coordination the project expects you to write yourself.

Maintenance, releases and the cost of upgrading

The repository is not archived, and the last push was on 2026-08-27. Releases are split across two packages: langgraph itself, at 1.2.11 on 2026-08-11, and langgraph-sdk, at 0.4.4 on 2026-08-27, with 0.4.3 on 2026-08-19. The SDK is on a 0.x line while the core package is on 1.x, which is worth noting when you pin versions: a 0.x package can change in ways a 1.x package should not.

The upgrade cost is mostly in the state schema and the persistence layer. Because the graph, the state and the checkpointer are all things you define, a change to how state is serialised or how checkpoints are read is a change to your code, not just to a dependency. The Makefile's lock and lock-upgrade targets show the maintainers treat dependency locking as a per-project concern under libs/, which is a reasonable model to copy for your own application.

The licence is MIT, which permits commercial use, modification and redistribution with the licence and copyright notice retained. That is a permissive licence and is not a copyleft one; it does not impose source disclosure on your own code. This is a description of the licence text, not legal advice, and the binding terms are in the LICENSE file at the repository root.

Editorial conclusion

Adopt LangGraph if you need explicit control over state, branching and resumption in a long-running agent, and you are willing to define that state yourself. Do not adopt it if you want a batteries-included agent that plans and manages subagents out of the box; the README points that audience at Deep Agents instead. Before committing, verify two things in the docs: which checkpointer backend your deployment will use for persistence, and whether the deployment path you want runs on LangSmith Deployment or on your own infrastructure.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes