OPEN SOURCE DEEP DIVE
LangGraph: agents as long-running processes that must persist, interrupt and resume
A low-level stateful-graph orchestration framework from LangChain, MIT licensed, with Python and JS/TS implementations, and Klarna, Replit and Elastic named as production users in the README. Its lineage is stated in the acknowledgements - inspired by Google Pregel and Apache Beam, interface borrowing from NetworkX - which means the BSP graph-computation model applied to agents: nodes are model calls or tool executions, edges are control flow, state is an explicit object. The value is not in the loop-the-model-with-tools layer but in four runtime capabilities: durable execution (resume exactly where it stopped after a crash), human-in-the-loop interrupts (approval can stay suspended for hours or days), separate short-term and long-term memory, and LangSmith execution-path tracing. Its actual claim is that agent reliability is a runtime problem, not a model problem. Usable without LangChain; any CompiledStateGraph can be handed to Deep Agents above it as a sub-agent. 42.1k stars. We have not run it and have not verified checkpoint-resume consistency, so it is graded as pending reproduction.
What it is
LangGraph describes itself as a "low-level orchestration framework for building stateful agents", MIT licensed, Python (with LangGraph.js for JS/TS), and the README names Klarna, Replit and Elastic among its production users. It is not another agent SDK; it is the layer that treats an agent as a long-running process that must be persisted, interrupted and resumed.
Its lineage is stated in the acknowledgements: inspired by Google's Pregel and Apache Beam, with a public interface borrowing from NetworkX. Those are not decorative citations - Pregel is the BSP (bulk synchronous parallel) model for graph computation, where vertices exchange messages between supersteps and state is managed explicitly. Applied to agents, that yields exactly the shape LangGraph has: nodes are model calls or tool executions, edges are control flow, state is an explicit object. Built by LangChain Inc, and usable without LangChain.
The problem it actually solves: long-running agents are a distributed-systems problem
Most agent frameworks stop at "loop the model with tools", which is enough for a demo and not enough for production. Three production failure modes cannot be fixed with prompts:
| Capability the README lists | The real failure it addresses | Why it must live in the runtime |
|---|---|---|
| Durable execution | A process crashes, a container is killed, a machine reboots, and forty minutes of work is gone | Every step must be checkpointed and the run must resume from exactly where it stopped rather than restart; that is a checkpoint mechanism, not a prompting trick |
| Human-in-the-loop (interrupts) | The agent wants to drop a table, move money or send email outward, and a human must approve | Approval can take hours or days, so the execution graph must be suspendable indefinitely and then woken - an in-memory call stack cannot do that |
| Short-term plus long-term memory | The context window cannot hold a whole session, yet project rules must survive across sessions | Working memory and persistent memory have different stores and different lifecycles, and the framework manages them separately |
| LangSmith observability | With branching and subgraphs, nobody knows which path was taken when something goes wrong | Execution-path tracing and state-transition snapshots require instrumentation, not log lines |
Taken together these four make LangGraph's actual claim explicit: agent reliability is a runtime problem, not a model problem. However strong the model, a workflow that runs for three hours, pauses once for human approval and must survive a crash depends on checkpoints, state machines and resumable execution - none of which has anything to do with LLMs, and all of which is decades of distributed-systems practice. That is also why it calls itself low-level: it does not decide for you, it makes the decision process durable, interruptible and replayable.
Where it sits in the LangChain stack
The official three-layer breakdown is worth recording verbatim, because teams routinely pick the wrong layer:
- LangGraph is the graph runtime. Drop to it when the agent loop itself is the wrong shape and you need custom control flow - branching, subgraphs, parallelism, fallbacks.
- LangChain's
create_agentis a minimal agent harness on top of it, without the bundled middleware. - Deep Agents (a separate entry on this site) is a more opinionated harness that bundles filesystem, sub-agents, context management and skills.
The layers compose: any LangGraph CompiledStateGraph can be passed in as a sub-agent to a Deep Agent. So choosing a layer is not either/or - start high, sink to the graph layer for the part that does not fit, then plug that rewrite back into the high-level harness.
Boundaries and tradeoffs
- The abstraction costs learning: graph, node, edge, state and checkpoint are five concepts you must hold, and a trivial agent feels heavy. What you get back is control over complex flows, not speed of onboarding.
- Ecosystem pull is soft but real: it works without LangChain, yet the full tracing, evaluation and deployment experience points naturally toward LangSmith (a commercial product). Teams with their own observability stack have to wire that up themselves.
- State design is still yours: the framework gives you persistence, but the shape of the state object, which fields enter a checkpoint and how you version-migrate them are your decisions. State-schema changes that make old checkpoints unreadable are the classic incident in this class of system.
- It does not fix model-level nondeterminism: resumable execution is not correct output. Retry and resume save you from "it died", not from "it went the wrong way".
Position on agientry
Our harness and orchestration coverage also includes Orca, herdr, multica and paperclip, and they do not sit on the same plane as LangGraph: those orchestrate agent processes and working directories that are already running (whose branch, whose terminal, whose board), while LangGraph orchestrates the execution graph inside one agent. The first is multi-agent scheduling, the second is single-agent runtime, and they stack. Listing LangGraph here is correct - it is the highest-starred, most production-adopted line at this layer.
Facts on this page come from the project README (read in full) and official documentation links; stars, licence and language come from the GitHub API. We have not run LangGraph and have done no benchmarking or reproduction, so real durable-execution behaviour (state consistency after a crash, checkpoint migration) is unverified by us, and this entry is graded as needing reproduction.