LangGraph: A Python Agent Framework for Stateful AI
langchain-ai/langgraph
LangGraph is a low-level Python framework from LangChain Inc for orchestrating stateful, long-running AI agents, and the README says it's used internally at Klarna, Replit, and Elastic. Reach for it if you need real control over agent state and a point where a human approves a step before the agent continues. Skip it if you want a working agent in an afternoon — you wire up state transitions yourself, not call a one-line "run agent" function.
What is LangGraph?
LangGraph is a Python framework built by LangChain Inc that hands you the plumbing for agents that need to keep running, and keep their place, over long stretches of time. You model an agent as a graph of nodes and edges instead of a single prompt chain: each node updates a shared state object, and LangGraph checkpoints that state so a run can pick up again after a crash instead of starting over. It works standalone or alongside LangChain. A separate JS/TS port, LangGraph.js, covers the same model outside Python.
Building Resilient, Stateful Agents
An agent that calls tools in a loop for minutes or hours has nowhere to store its place if the process restarts partway through, and most agent code has no built-in point to pause and let a person check a step before it fires. LangGraph's graph model gives every step a checkpointed state, so a long-running agent can pick back up where it stopped rather than replaying the whole run, and it gives you interrupts as an explicit pause point for human review — not just a callback bolted onto a chat loop.
Core Capabilities for Agent Orchestration
- ✓Durable execution checkpoints graph state at each step, so a crashed or interrupted run resumes where it stopped instead of restarting from the first node.
- ✓Human-in-the-loop interrupts pause a graph mid-run so a person can inspect or edit agent state before execution continues.
- ✓Two memory scopes: one holds context for the current run only, and one persists so an agent remembers a user or task across separate conversations.
- ✓Plug in LangSmith and you get a visual record of each run — which node fired, what the state looked like at each step, and where a run went wrong.
- ✓Deployment through LangSmith Deployment targets infrastructure built for long-running, stateful workflows instead of stateless request/response.
- ✓Works standalone — the orchestration layer doesn't require adopting the rest of the LangChain stack.
Integrating LangGraph into Your Agent Stack
- •Pairing LangGraph with Deep Agents, the higher-level package the README points to, when you want planning and subagents without building the graph by hand.
- •Adding LangChain's integrations and composable components on top when you need pre-built connectors instead of writing every tool call yourself.
- •Wiring in LangSmith to evaluate agent trajectories and debug a run that produced a bad output before it ships.
- •Deploying through LangSmith Deployment when a graph needs to stay alive longer than a stateless serverless function allows.
- •Building the same architecture in JavaScript or TypeScript with LangGraph.js when the rest of the app isn't in Python.
Getting Started with LangGraph
Install with `pip install -U langgraph` — that's the entire Python setup, since LangGraph is a library you import, not a hosted service. Teams outside Python get the same orchestration model through LangGraph.js, a separate package. Running a graph beyond your own process, for genuinely long-running workflows, is where LangSmith Deployment comes in, but that's a distinct product from the open-source library itself.
Learning and Resources
The main docs sit at docs.langchain.com, with a quickstart and conceptual guides, plus an API reference at reference.langchain.com. LangChain Academy runs a free, structured course specifically on LangGraph basics. Chat LangChain lets you ask the documentation directly when a guide doesn't answer your question, and the LangChain Forum is where to post if that still doesn't help. The README also links short, task-focused guides — streaming, adding memory, branching, subgraphs — as code snippets rather than long tutorials.
Strengths
- ✓Checkpointed state means a crashed or interrupted run doesn't have to restart from the first node.
- ✓Interrupts give you an actual point to pause for human review mid-run, not just at the start or end of a chain.
- ✓MIT license, so you can vendor or modify the code without copyleft obligations.
- ✓Works standalone — you're not forced onto the rest of the LangChain stack just to get the orchestration layer.
Considerations for Using LangGraph
- △The graph-and-node model is lower-level than a lot of agent tooling — you wire state transitions and edges yourself instead of calling a single 'run agent' function.
- △The adopter list in the README (Klarna, Replit, Elastic) is LangChain's own claim, not independently verified, so treat it as a signal rather than proof it fits your use case.
- △Out of the box, LangGraph doesn't show you what an agent actually did during a run; that visibility is a separate LangSmith integration, not something built into the library itself.
- △Scaling a graph in production routes you toward LangSmith Deployment, a distinct product from the open-source library.
Related Frameworks and Inspirations
Frequently Asked Questions
LangGraph is released under the MIT license, so you can use, modify, and vendor it in commercial projects without copyleft restrictions.
LangGraph's core library is written in Python and installed with `pip install -U langgraph`; a separate package, LangGraph.js, covers the same orchestration model for JavaScript and TypeScript.
LangGraph is the low-level orchestration layer for stateful agent execution, while LangChain provides integrations and composable components built on top of it. LangChain Inc builds both, and LangGraph works standalone without requiring LangChain.
LangGraph supports human-in-the-loop workflows through interrupts that pause a graph mid-execution, letting a person inspect or edit agent state before execution continues.
LangGraph is built with production use in mind, and a companion product, LangSmith Deployment, targets scaling stateful, long-running graphs beyond a single process — though that deployment layer is a separate product from the open-source library.
LangGraph doesn't ship its own debugger, but pairing it with LangSmith gives you a visual record of each run — which node ran, how the state changed, and where a run broke.
Who should try it — and who should skip
Reach for LangGraph if you're a Python developer building an agent that has to survive process restarts, pause for a person to approve a step, or hold memory across sessions — the checkpointing and interrupt model earns its complexity there. Skip it if you want to prototype an agent in an afternoon; the graph-and-node setup is overhead a single-shot chatbot doesn't need, and a higher-level package like Deep Agents or a visual builder like Dify gets you there faster.