LangChain vs LangGraph: Which to Choose in 2026
Since the joint 1.0 releases on October 22, 2025, this stopped being a framework rivalry: LangChain's create_agent now executes on the LangGraph runtime, so you are choosing an abstraction level within one stack, not picking a side. Use LangChain (1.3.11 as of July 2026) when a standard tool-calling agent loop plus middleware (human approval, summarization, PII redaction) covers the job. Drop to LangGraph (1.2.8) directly when you need explicit control: custom state schemas, durable execution that survives restarts, human-in-the-loop interrupts at arbitrary points, or multi-agent topologies. Both are MIT-licensed with a stated commitment of no breaking changes until 2.0. Our production default: start with create_agent, and because it is LangGraph underneath, dropping down later is a refactor, not a rewrite.
Side-by-side comparison
| Dimension | LangChain | LangGraph |
|---|---|---|
| What it is | High-level agent framework: create_agent, middleware, integrations | Low-level orchestration runtime for stateful agents |
| Current version (July 2026) | 1.3.11 (released June 22, 2026) | 1.2.8 (released July 6, 2026) |
| 1.0 GA date | October 22, 2025 | October 22, 2025 |
| Relationship | create_agent executes on the LangGraph runtime | Standalone; works with or without LangChain |
| Abstraction level | Prebuilt agent loop, customized via middleware hooks | You define nodes, edges, and typed state explicitly |
| State and persistence | Managed by the runtime; middleware for summarization | First-class checkpointers; durable execution across crashes and deploys |
| Human-in-the-loop | Built-in middleware for approving tool calls | Interrupts pause anywhere in the graph; resume from checkpoint |
| Multi-agent systems | Possible, but you outgrow the single loop quickly | Subgraphs compose naturally into multi-agent topologies |
| Streaming | Tokens and messages | Tokens plus per-step state updates |
| Debugging | Trace through middleware or LangSmith | Inspect state at any node; time-travel replay from checkpoints |
| Learning curve | Hours: one function call to a working agent | Steeper: state schema and graph design before first run |
| License | MIT, open source | MIT, open source |
| Managed deployment | Same stack: LangSmith Deployment | LangSmith Deployment (renamed from LangGraph Platform, October 2025) |
| Stability policy | No breaking changes until 2.0 | No breaking changes until 2.0 |
| Legacy surface | Old chains and AgentExecutor moved to langchain-classic | None: 1.0 formalized the existing graph APIs |
LangChain
High-level agent framework: create_agent, middleware, and the largest integration catalog.
LangChain 1.0 shipped on October 22, 2025 and refocused the framework around one thing: building agents fast. The old AgentExecutor era is over; legacy chains and agents moved to a separate langchain-classic package, and the core library now centers on create_agent, a model-agnostic agent loop that runs on the LangGraph runtime underneath. A middleware system handles the add-ons every production agent eventually needs: human approval before tool execution, conversation summarization to manage context limits, and PII redaction. Standard content blocks normalize reasoning traces, citations, and tool calls across providers, so swapping models does not mean reparsing outputs. As of July 2026 the current release is 1.3.11 (June 22, 2026), requiring Python 3.10+, with a parallel JavaScript package on npm. The 1.0 line carries a no-breaking-changes-until-2.0 commitment, which ended the v0.x churn that gave LangChain its reputation for instability. It remains the broadest integration layer in the ecosystem: hundreds of model providers, vector stores, and tools behind consistent interfaces.
Pros
- create_agent gets a production-capable tool-calling agent running in an afternoon, and it executes on the LangGraph runtime underneath, so you are not building on a dead end
- Middleware covers the usual production add-ons out of the box: human approval for tool calls, summarization for context limits, PII redaction
- Standard content blocks normalize reasoning traces, citations, and tool calls across providers, so switching models does not break your output parsing
- Largest integration catalog in the LLM ecosystem: hundreds of model providers, vector stores, and tools
- Stability commitment since 1.0 (October 2025): no breaking changes until 2.0, which closed out years of v0.x API churn
- Legacy chains and AgentExecutor were moved out to langchain-classic, leaving a smaller, cleaner core package
Cons
- The prebuilt agent loop is a fixed shape: when you need custom control flow beyond what middleware hooks allow, you drop down to LangGraph anyway
- Abstractions still sit between you and the exact prompt sent to the model; serious debugging means tracing through the framework or leaning on LangSmith
- Years of pre-1.0 tutorials, Stack Overflow answers, and LLM training data are now wrong for 1.x, which taxes onboarding and code review
- Codebases that leaned on legacy chains need the langchain-classic dependency and eventually a real migration
- The JavaScript/TypeScript package trails the Python package on newer features
Best for
- → Standard tool-calling agents (support bots, RAG agents with a few tools) where the built-in loop plus middleware covers requirements
- → Prototyping when requirements are still unclear: fastest path to a working agent, with a clean drop-down to LangGraph later
- → Teams that want provider portability: swap OpenAI, Anthropic, or open-source models without rewriting integration or parsing code
Worst for
- → Workflows with custom control flow: branching approvals, retries with escalation, cyclic reasoning that does not fit one agent loop
- → Long-running processes that must survive crashes and deploys mid-run: you need LangGraph's checkpointers, not an in-memory loop
- → Complex multi-agent systems: composing specialist agents through one create_agent loop gets awkward fast
Open source (MIT). Observability via LangSmith is optional and paid: the free Developer tier includes up to 5k base traces per month, Plus is $39 per seat per month with 10k base traces included, then $2.50 per 1k base traces (extended 400-day retention traces are $5.00 per 1k).
Hours to a working create_agent prototype; days to a production-ready agent with middleware, evals, and tracing.
LangGraph
Low-level orchestration runtime for stateful, durable agents.
LangGraph is LangChain Inc.'s low-level orchestration framework for stateful agents, and since October 22, 2025 it is a stable 1.0 product; the current release is 1.2.8 (July 6, 2026), Python 3.10+, with a JavaScript counterpart. You model a workflow as a graph: nodes do work (LLM calls, tools, plain functions), edges route between them, and a typed shared state flows through everything. That explicitness is the point. Checkpointers persist state at every step, so runs survive crashes and redeploys and resume where they stopped. Interrupts pause execution anywhere for human review and resume from the checkpoint, which is how approval workflows actually get built. Time-travel debugging replays a run from any checkpoint. LangGraph is standalone: it works without LangChain, so you can call the Anthropic or OpenAI SDKs directly inside nodes. LangChain Inc. cites Uber, LinkedIn, and Klarna running production agents on it. You can self-host anywhere Python or Node runs, or use the managed service, which was renamed from LangGraph Platform to LangSmith Deployment in October 2025.
Pros
- Explicit typed state, inspectable at every node: when an agent misbehaves you can see exactly what it knew and when
- Durable execution via checkpointers: runs survive crashes and deploys and resume from the last checkpoint
- Interrupts give human-in-the-loop control at arbitrary points in the graph, not just before tool calls
- Time-travel debugging: replay a run from any checkpoint to reproduce and fix failures
- Streams per-step state updates as well as tokens, so users see agent progress, not a spinner
- Subgraphs compose cleanly into multi-agent systems without framework gymnastics
- Standalone by design: no LangChain dependency required; call any LLM SDK directly inside nodes
- Production credibility: LangChain Inc. cites Uber, LinkedIn, and Klarna running agents on LangGraph
Cons
- Steeper learning curve: you design a state schema and graph topology before anything runs
- Noticeably more boilerplate than create_agent for jobs a standard agent loop handles fine
- The graph mental model is overkill for linear pipelines and single-shot LLM calls
- The JavaScript/TypeScript package trails the Python package on newer features
- Naming churn around the managed offering (LangGraph Platform became LangSmith Deployment, LangGraph Studio became LangSmith Studio) makes pre-October-2025 docs and tutorials confusing
Best for
- → Production agents with real control-flow requirements: conditional routing, retries, escalation paths, cycles
- → Long-running or high-stakes workflows that need durable state, resumability, and audit-friendly checkpoints
- → Multi-agent systems where specialist agents (research, analysis, writing, review) compose as subgraphs
Worst for
- → Simple single-shot LLM calls or linear RAG pipelines: direct SDK calls or create_agent are less code
- → Quick prototypes where the requirements are not yet worth a state schema
- → Teams brand new to LLM development: start with create_agent, drop down when the loop stops fitting
Open source (MIT), free to self-host anywhere Python or Node runs. Managed hosting via LangSmith Deployment (formerly LangGraph Platform): one free dev deployment on the $39/seat Plus plan, then usage-based pricing at $0.005 per deployment run plus uptime charges ($0.0036 per minute for production deployments, $0.0007 per minute for dev).
Days to a first stateful agent with checkpointing; weeks for a production multi-agent system with human-in-the-loop and an eval harness.
Decision scenarios
Support or documentation agent that answers over a knowledge base with a handful of tools
This is exactly the shape create_agent is built for: a tool-calling loop with retrieval, plus summarization middleware for long conversations. LangGraph would add state-schema ceremony without buying you anything here.
Tier-1 support agent that resolves routine tickets autonomously and escalates edge cases to a human for approval mid-flow
Escalation with approval gates is interrupt territory. LangGraph pauses the run at the escalation node, a human reviews, and execution resumes from the checkpoint. LangChain's approval middleware only gates tool calls; it does not model an escalation branch.
Long-running back-office workflow (claims processing, order orchestration) that must survive deploys and crashes mid-run
Durable execution is the deciding feature. LangGraph checkpointers persist state at every step, so a redeploy resumes the run instead of losing it. An in-memory agent loop cannot make that guarantee.
Prototype where you are still discovering what the agent needs to do
Start with create_agent and iterate fast. Because it runs on the LangGraph runtime, graduating to an explicit graph later is a refactor of the orchestration layer, not a platform migration.
Multi-agent research system where specialist agents (web research, analysis, writing, review) collaborate
Each specialist becomes a subgraph and the supervisor routes between them. This composes cleanly in LangGraph and gets awkward fast when forced through a single high-level agent loop.
You expect to switch model providers (or A/B test them) without rewriting integration code
Provider abstraction is LangChain's home turf, and 1.0's standard content blocks mean reasoning traces, citations, and tool calls parse the same way across providers. Pair it with LangGraph if the orchestration is complex: they are not mutually exclusive.
Regulated-industry workflow that needs an audit trail and the ability to reproduce exactly what the agent did
Checkpoint history gives you an inspectable record of state at every step, and time-travel replay lets you reproduce a failure or contested decision. That is a much stronger compliance story than log scraping.
A typical production agent stack in 2026
This is not either-or. The standard pattern we ship: LangChain integrations (models, retrievers, tools) inside LangGraph nodes, or create_agent for the simple agents and explicit graphs for the complex ones, all on the same runtime and observable in the same LangSmith project.
Common questions
No. The 1.0 releases (both GA on October 22, 2025) settled the roles: LangChain is the fast path for standard agents, LangGraph is the control layer for everything the standard loop cannot express. LangChain's own agent abstraction is built on LangGraph, and LangChain Inc. maintains both with a shared no-breaking-changes-until-2.0 commitment. What did get replaced is LangChain's old AgentExecutor, which moved to the langchain-classic legacy package.
No. LangGraph is standalone by design: the official docs state it can be used without LangChain, and its nodes can call the Anthropic SDK, OpenAI SDK, or any custom client directly. Plenty of production teams use LangGraph purely for orchestration with raw SDK calls inside nodes for maximum control over prompts. Most teams still pull in LangChain components (chat models, retrievers, tools) inside nodes because the integrations save time, but it is a choice, not a requirement.
Learn LangChain's create_agent first: it is one function call to a working agent, and everything you learn transfers because it runs on the LangGraph runtime. Then learn LangGraph when you hit a wall the middleware hooks cannot express: custom branching, durable state, interrupts, or multi-agent composition. If you already know you are building complex stateful workflows, skipping straight to LangGraph is reasonable; it just front-loads the state-schema and graph-design learning curve.
For agents with real control-flow and state requirements, yes: explicit state, durable execution, and interrupts are things a high-level loop cannot fully deliver. For standard tool-calling agents, no: create_agent ships faster, carries less code, and executes on the same runtime anyway. The honest answer is that since the 1.0 releases they are complementary layers, and the strongest production systems we build use LangChain components inside LangGraph orchestration.
Yes. LangGraph is MIT-licensed open source, and you can self-host it anywhere Python or Node runs at no license cost. Paid products are optional and sit around it: LangSmith observability ($0 Developer tier with 5k base traces per month, $39 per seat per month Plus with 10k) and LangSmith Deployment for managed agent hosting, which bills per deployment run ($0.005) plus uptime per minute. LangChain itself is also MIT-licensed.
Both went GA on October 22, 2025. LangChain 1.0 rebuilt the framework around create_agent (running on the LangGraph runtime), added the middleware system (human-in-the-loop approval, summarization, PII redaction), introduced standard content blocks that normalize reasoning traces, citations, and tool calls across providers, and moved legacy chains and AgentExecutor to a langchain-classic package. LangGraph 1.0 formalized the graph APIs that were already running in production at companies like Uber, LinkedIn, and Klarna. Both dropped Python 3.9 and committed to no breaking changes until 2.0. As of July 2026 the lines have matured to langchain 1.3.11 and langgraph 1.2.8 without breaking changes.
Not immediately. Legacy chains and agents live on in the langchain-classic package, so pinning that dependency keeps old code running while you migrate. But treat it as a bridge, not a destination: new features land in the 1.x core, and the old AgentExecutor pattern is a dead end. In migrations we have run, the real work is rethinking implicit conversation state as explicit LangGraph state; the tool and prompt mapping is mostly mechanical. Budget one to two weeks of engineering for a moderately complex agent.
It was renamed. In October 2025, LangChain Inc. consolidated naming under LangSmith: LangGraph Platform became LangSmith Deployment and LangGraph Studio became LangSmith Studio. The open-source LangGraph framework kept its name. So in 2026: LangGraph is the library you code against, and LangSmith spans observability, evaluation, and deployment as the managed layer around it. Docs and tutorials written before October 2025 use the old names, which trips people up.
Yes. LangGraph is one of our most-used frameworks for production agent engagements, and the pattern above (LangChain integrations inside LangGraph orchestration, LangSmith for tracing and evals) is our standard build. A typical first production agent engagement runs 8-16 weeks covering design, implementation, an eval harness, deployment, and a 30-day handover. We also handle 0.x to 1.x migrations and AgentExecutor to LangGraph rewrites.
Related comparisons
Related services
Featured case studies
Get a recommendation tailored to your situation
BearPlex builds production AI systems using both approaches. We'll tell you which fits your case in a 30-minute scoping call.