Vendor head-to-head · 1 May 2026

LangChain vs LangGraph: when to use which

LangChain and LangGraph are not competitors — they are the same vendor's products solving adjacent problems. LangChain is the older, broader framework: integrations, chains, retrievers, agents (the original AgentExecutor pattern). LangGraph is the newer, narrower runtime: a state-graph primitive built specifically for production agent loops with persistence, time-travel, and multi-agent supervisor patterns. Most procurement confusion happens because LangChain (the framework) gets recommended in 2024-era tutorials and LangGraph (the runtime) is what most production deployments actually want in 2026. This comparison maps the two onto the decisions a platform team needs to make.

Who this is for

· Platform engineers selecting an agent runtime in 2026
· Architecture leads migrating from 2024-era LangChain agents to a production-grade runtime
· Engineering managers evaluating the LangChain ecosystem for enterprise deployment

Side A

LangChain ↗

Open-source framework (Python + TypeScript) for building LLM applications. 700+ integrations, chains, retrievers, embeddings, vector stores, the original AgentExecutor agent pattern.

PricingFree open-source (MIT)· as of 1 May 2026source ↗

Side B

LangGraph ↗

Open-source state-graph runtime for production agent loops. Built on top of LangChain primitives but separate runtime; supervisor / multi-agent patterns native; persistent checkpointer; time-travel debugging.

PricingFree open-source; LangGraph Cloud / Server from $39/seat/month· as of 1 May 2026source ↗

Feature matrix

Dimension	LangChain	LangGraph
Primary use casesource ↗	Building LLM applications generally — chains, retrievers, RAG, single-shot agents, batch pipelines	Production agent loops — multi-step reasoning, tool use, human-in-the-loop, multi-agent supervisor patterns
Mental modelsource ↗	Pipeline: input → chain → output (with branches via LCEL composition)	State graph: nodes + edges + conditional transitions; the graph is the agent
Persistencesource ↗	Per-call (no built-in run-state persistence; sessions are application-managed)	Native checkpointer (Postgres, Redis, SQLite, in-memory); thread-aware; resumable across restarts
Multi-agent / supervisor patternssource ↗	Possible but requires manual chain composition; not a native primitive	Native — supervisor + worker patterns ship as templates; subgraphs as agent abstractions
Human-in-the-loopsource ↗	Possible via callbacks; not a first-class primitive	Native interrupt + resume primitive; agent pauses on configured nodes for human approval
Observabilitysource ↗	LangSmith integration (logs every LLM call, chain run, retriever query)	LangSmith integration with deeper graph-trace view; OpenTelemetry export
Production deployment shapesource ↗	Self-hosted; bring your own runtime (FastAPI, Lambda, container)	Self-hosted (LangGraph Server) or managed (LangGraph Cloud); built-in queueing, persistence, scheduling
Best forsource ↗	Document Q&A, single-step extraction, RAG pipelines, batch enrichment, simple chatbots	Customer-service agents, research agents, code-writing agents, multi-step approval workflows, anything with state across calls
Migration path 2024 → 2026source ↗	Original AgentExecutor pattern; LangChain team now recommends LangGraph for new agent work	The recommended 2026 production agent runtime in the LangChain ecosystem
When to use bothsource ↗	LangChain for the document-loading + retrieval + tool primitives the agent uses	LangGraph for the agent loop that consumes those primitives

What our claim ledger says about each

AM-137· Holding · last review 5 May 2026 · next +58dAgent evaluation in production resolves on three operational components that determine whether the chosen evaluation platform produces useful signal: eval-set design across three layers (50-200 calibration prompts, 30-100 edge-case prompts, 10-50 production-sampled prompts per week), drift detection across three signal classes (output-distribution, score-distribution, tool-use distribution), and a regression-budget framework that forces binary ship/hold decisions (defensible default 5% absolute decline on calibration set, 10% on edge-case set, per release window). The procurement decision (which platform to buy, covered at AM-122) is the easier half; the operational discipline is what most enterprises under-invest in even after buying a platform.

When to choose which

Choose LangChain

Pick LangChain alone when the deployment is not actually an agent — it's a chain (RAG Q&A, single-shot extraction, batch enrichment). LangChain's 700+ integrations and retriever / vector-store primitives are the right tools. The agent patterns inside LangChain (AgentExecutor) are now legacy; new agent work should use LangGraph.

Choose LangGraph

Pick LangGraph when the deployment is a real agent — multi-step, stateful, with tool use and conditional branching. The persistence layer alone is worth the migration: production agents need to resume from interruptions, branch on conditions, and pause for human approval. LangChain's primitives still get used inside LangGraph nodes; LangGraph is the runtime around them.

Related decisions

Adjacent procurement decisions in the same cluster. Use the buyer's-guide structure: pick the deployment shape first, then walk the comparison matrix.

n8n vs LangGraph: agent orchestration runtimes compared
Open-source agent orchestration: n8n (workflow-first) vs LangGraph (LLM-first). Deployment posture and production-readiness for 2026 enterprise stacks.
MCP vs A2A: agent-protocol comparison
Model Context Protocol (MCP) vs Agent-to-Agent (A2A) protocol. What each standardises, who maintains them, how they fit in 2026 agent stacks.
Cursor vs GitHub Copilot: AI coding tools compared
AI-paired developer tooling: Cursor (agentic editor) vs GitHub Copilot (suggest + agent). Feature matrix, pricing, governance for 2026 procurement.