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
LangChain ↗
Open-source framework (Python + TypeScript) for building LLM applications. 700+ integrations, chains, retrievers, embeddings, vector stores, the original AgentExecutor agent pattern.
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.
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 |
When to choose which
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.
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.