# LangGraph — Open-source, MIT-licensed framework for building stateful, multi-agent AI workflows on cyclical graphs.

> Source: The Agents Index — https://theagentsindex.com/langgraph (structured, researched, re-verified)
> Facts last verified: 2026-08-23

LangGraph is an open-source, MIT-licensed Python and JavaScript library for building stateful AI agents as cyclical graphs of nodes and edges. It is built and maintained by LangChain and is the same engine underneath LangChain's own quick-start `create_agent` harness. For production work, LangGraph pairs with LangSmith, which adds tracing, evaluation, deployment and a no-code builder called Fleet, on top of the open-source core.

| Fact | Value |
| --- | --- |
| Website | https://www.langchain.com/langgraph |
| Pricing | Developer is free for 1 seat with 5,000 traces/month. Plus is $39/seat/month with 10,000 traces and one free Serverless Small deployment. Enterprise is custom. Usage is metered separately in LCUs ($1.50 each) and LSUs ($1.00 each). |
| API | Yes |
| Best for | Engineering teams building production agents who need cyclical graphs, durable state and replayable runs |
| Not for | Teams that want to ship a first working agent in under an hour, do not need graph-level control over state and branching, or are building a lightweight TypeScript app on serverless infrastructure where a framework like Mastra fits the deploy target better. |

## Pricing

| Tier | Price |
| --- | --- |
| Developer | $0/seat/month |
| Plus | $39/seat/month |
| Enterprise | Custom |

## Verdict

LangGraph earns its place in the agent-framework category because its open-source core is genuinely free and it is the only mainstream framework built around cyclical, loopable graphs rather than one-way DAGs. Production deployment on LangSmith is metered in two explicit units, LCUs and LSUs, on top of seat fees, so a small production setup can run from tens of dollars a month into the low hundreds before LLM costs. It is code-first, not a visual builder, and LangSmith's no-code offering is a separate product called Fleet. Pick it when you need fine-grained control of state, branching, interrupts and replay. Reach for CrewAI, Mastra or a simpler framework when you do not.

## How it works

1. Install LangGraph via pip or npm, or use LangChain's `create_agent` harness on top of it. Define the agent as a graph of nodes (model calls, tools, sub-agents) connected by edges that control flow, including cycles.
2. Wire up checkpointed persistence with Postgres, SQLite or Redis, add a cross-thread memory store where needed, and insert human-in-the-loop interrupts at the points where a person should review or steer.
3. Deploy through LangSmith for one-click deployment, autoscaling and tracing. Use time-travel debugging to replay any checkpoint when something goes wrong in production.

## Who it's for

- Engineering teams building stateful or multi-agent systems who need loops, retries and durable execution.
- Teams already using LangChain who want more control over state, interrupts and replay than the quick-start harness exposes.
- Startups needing a path to production deployment, tracing and evaluation alongside the open-source framework.

## Strengths and weaknesses

- ✓ Checkpointed state at every node transition means a production agent can survive a restart, resume where it left off, and be replayed from any earlier checkpoint for debugging.
- ✓ Explicit graph structure makes every state transition visible and testable, rather than hidden inside a role-based or implicit abstraction.
- ✓ Native human-in-the-loop interrupts let a person inspect or edit an agent's state mid-run without losing progress.
- ✓ Named production adoption at scale on the vendor's own trusted-by strip, including Klarna, LinkedIn, Uber and Elastic.
- ✓ Actively maintained Python and JavaScript libraries, MIT-licensed, with public GitHub releases.
- ✗ Production costs add up through usage-based LCU and LSU units on top of seat fees. A small setup can run from tens of dollars into the low hundreds per month before any LLM API costs, depending on trace volume and deployment size.
- ✗ Independent reviewers consistently describe a steep learning curve, with documentation split across the LangGraph, LangChain and LangSmith sites.
- ✗ The explicit graph model means refactoring an agent often means redrawing the graph. Independent reviewers report longer onboarding onto a LangGraph codebase than most alternatives.
- ✗ Not a no-code tool. Non-technical teams need LangChain's separate Fleet product on LangSmith or another platform.
- ✗ Managed deployment is not designed for serverless platforms like Vercel or Cloudflare Workers, unlike TypeScript-native competitors such as Mastra.
- ⚠ No native token-budget or cost-limit management in the framework. Cost caps have to be handled at the model-integration level.
- ⚠ Managed deployment (LangSmith) is not designed to run on serverless platforms like Vercel or Cloudflare Workers.
- ⚠ Documentation is split across the LangGraph, LangChain and LangSmith sites, which independent reviewers cite as a real onboarding cost.

## Key features

- **Cyclical graph execution** — Agents are defined as nodes and edges with conditional branches and cycles. An agent can loop, retry and revisit earlier steps instead of only running as a straight-line chain.
- **Checkpointed persistence** — State is saved after every node transition under a thread_id, with Postgres, SQLite or Redis backends, so a run survives a restart and resumes exactly where it left off.
- **Time-travel debugging** — Any prior checkpoint can be replayed or resumed, letting a developer step back through an agent's execution history to find where it went wrong.
- **Human-in-the-loop interrupts** — A graph can pause mid-run so a person can inspect or edit its state before the agent continues, without losing progress.
- **Cross-thread memory (stores)** — A separate store layer persists application-defined data across conversations, distinct from the thread-scoped checkpoint state.
- **Native token-by-token streaming** — Agent reasoning and tool calls stream in real time rather than returning only a final answer.
- **Supervisor / subagent multi-agent pattern** — A supervisor node coordinates subagents by calling them as tools and combining their outputs, with each subagent able to run in its own subgraph with a private message history.
- **LangSmith deployment and tracing** — LangSmith adds an Assistants API with over 30 endpoints, one-click deployment, autoscaling, tracing, evaluation, an LLM Gateway, an Engine, Sandboxes and a no-code Fleet builder.

## Use cases

- **Production customer-support agent at scale** — A support team builds an agent that has to reliably handle millions of users, survive process restarts mid-conversation, and let a human step in on edge cases. Klarna is named on the LangGraph trusted-by strip for this kind of deployment.
- **Large-scale automated code migration** — An internal developer-platform team runs a network of agents that plan and execute code migrations and generate unit tests across a large codebase. Uber is named on the trusted-by strip for developer-platform work in this shape.
- **Multi-agent research or recruiting workflow** — A hierarchical system of agents, with a supervisor coordinating specialist subagents, handles conversational search and candidate matching. LinkedIn is named on the trusted-by strip for this kind of multi-agent system.
- **Customer support workflow with human approval** — A support team adds a human-in-the-loop checkpoint so an agent drafts a response but a person approves refunds or account changes before they execute.
- **Production agent with tracing and replay** — A startup ships an agent via LangSmith's one-click deployment and traces requests in production. Time-travel debugging lets the team replay any prior checkpoint to find where a run went wrong.

## Integrations

OpenAI · Anthropic · Google · AWS Bedrock · Groq · Ollama (local models) · Model Context Protocol via langchain-mcp-adapters · LangSmith (tracing, evaluation, deployment) · LangGraph Studio (visual debugger) · Postgres / SQLite / Redis (checkpoint backends)

## Sources

- https://www.langchain.com/langgraph
- https://www.langchain.com/pricing
- https://docs.langchain.com/oss/python/langgraph/overview
- https://github.com/langchain-ai/langgraph