If you last looked at this question in 2024, almost everything you remember is now wrong. On 22 October 2025, LangChain 1.0 and LangGraph 1.0 shipped together, and LangChain formally repositioned itself: it is no longer a sprawling chain library but a high-level agent harness built on the LangGraph runtime, centred on a single create_agent API. The old chains and the rest of the pre-1.0 surface were moved out to a separate langchain-classic package (1.0 announcement). Meanwhile LlamaIndex pulled its orchestration layer out into a standalone Workflows package that is now on a 2.x line, and formally deprecated QueryPipeline and the whole AgentRunner/AgentWorker family. Any comparison that says "LangChain = chains, LlamaIndex = RAG, LangGraph = the new agent thing" is describing software that no longer exists.
The short answer, up front: use LangChain if you want to ship agents quickly with standard patterns; use LangGraph if you need low-level control over long-running, stateful workflows; use LlamaIndex if the hard part of your problem is your data. That is not our invention — it is close to what the vendors themselves now say, and the rest of this guide is the evidence, checked against official docs in July 2026.
One structural fact makes this a strange three-way fight: LangChain and LangGraph come from the same company and are explicitly designed as layers of one stack, while LlamaIndex is the independent alternative whose Workflows engine now competes directly with LangGraph for the "agent runtime" slot.
LangChain in 2026: the agent harness
LangChain's own docs now describe it as a minimal, highly configurable agent harness — the equation the docs use is Agent = Model + Harness, meaning a model plus tools, prompt, and middleware (docs.langchain.com overview). The primary API is create_agent, which replaced LangGraph's create_react_agent prebuilt — that older function is now deprecated. The 1.0 release added a middleware system for fine-grained control at each agent step (built-ins include human-in-the-loop approval, conversation summarization, and PII redaction) and standard content blocks that normalise reasoning traces, citations, and tool calls across model providers.
Two things matter for anyone carrying 2024 knowledge. First, LangChain agents literally run on LangGraph — the docs state agents are built on top of it, which is where durable execution, persistence, and human-in-the-loop come from. Second, the churn that made LangChain infamous has been addressed head-on: the 1.0 release cut the package surface down to core abstractions, shipped migration guides, and committed to no breaking changes until 2.0. The very existence of langchain-classic is the company's own admission that the old surface was too broad. Note also that 1.x dropped Python 3.9; you need Python 3.10 or later.
Current versions as of July 2026: Python langchain 1.3.13, JS langchain 1.5.3. And despite the agent-first framing, RAG has not left the building — the 1.x docs still carry a catalogue of 40+ retriever integrations.
LlamaIndex in 2026: agents over your data
LlamaIndex still owns the data-framework identity, but the 2026 framing leads with agents: the docs position it as the leading framework for building LLM-powered agents over your data, with context augmentation — making your data available to the LLM — as the core concept and RAG as its most popular expression (developers.llamaindex.ai). The docs organise the framework around four pillars: Agents, Workflows, Context Augmentation, and RAG.
The big architectural change: orchestration moved out of the monolith into a standalone package, llama-index-workflows in Python and @llamaindex/workflow-core in TypeScript. Workflows 1.0 landed on 30 June 2025 with an async-first, event-driven architecture, and the Python package sits at 2.22.2 as of July 2026. The flip side is a long official deprecation trail: ServiceContext (replaced by Settings), LLMPredictor, QueryPipeline, and the entire AgentRunner/AgentWorker family — FunctionCallingAgent, ReActAgentWorker, and friends — are all listed on the project's own Deprecated Terms page. By the project's own accounting, most 2023–2025 LlamaIndex tutorials are substantially out of date.
One caution flag: the flagship llama-index package is still versioned 0.14.x, with no formal stability pledge equivalent to LangChain's no-breaking-changes-until-2.0 commitment. Comparing maturity by version number across these three is misleading in both directions — but the absence of a stability promise is real. On the TypeScript side, the actively published surface is the scoped @llamaindex/* packages; the monolithic llamaindex npm package last published in December 2025.
LangGraph in 2026: the low-level runtime
LangGraph is officially a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents (LangGraph overview). Its selling points are durable execution — agents that resume from failures — persistence, streaming, memory, and human-in-the-loop APIs that let you inspect and modify agent state at any point. The 1.0 GA on 22 October 2025 made durable state persistence and human-in-the-loop first-class, under the same no-breaking-changes-until-2.0 pledge as LangChain.
Two clarifications the vendor makes itself. LangGraph is standalone: the docs state you do not need LangChain to use it. And it is not for beginners: the same docs steer newcomers toward LangChain's prebuilt agent architectures and tell you to reach for LangGraph when you need durable execution, streaming, and human-in-the-loop control. Translation: more control, more code, steeper learning curve — per the vendor, not per us. Current versions: Python langgraph 1.2.9, JS @langchain/langgraph 1.4.7.
Adoption, in numbers
The most honest common metric would be PyPI weekly downloads for all three, but our traction snapshot does not carry a PyPI figure for any of them, and it holds no GitHub-star or registry-download figure for LlamaIndex at all — partly a measurement artefact, since LlamaIndex's active JS surface is spread across scoped @llamaindex/* packages rather than one countable monolith. So we chart the two figures we can stand behind and say so plainly.
LangChain sits at 141.8k GitHub stars to LangGraph's 37.2k, but the star gap overstates the usage gap. On npm, langchain pulls 2,624,144 weekly downloads against 2,344,977 for @langchain/langgraph — near parity, which is exactly what you would expect now that LangChain agents run on the LangGraph runtime: installing one increasingly means installing both. Stars measure a project's history; downloads measure its present.
When to use which
| LangChain | LlamaIndex | LangGraph | |
|---|---|---|---|
| Primary job (2026) | High-level agent harness (create_agent) | Agents over your data; parsing, indexing, retrieval | Low-level runtime for stateful, long-running agents |
| RAG story | 40+ retriever integrations | The flagship use-case | DIY — nodes are plain code |
| Agent story | Prebuilt loop + middleware | Event-driven Workflows 2.x | Durable, human-in-the-loop graphs |
| Commercial layer | LangSmith | LlamaCloud | LangSmith Deployment |
| Learning curve | Gentlest — the official on-ramp | Fine now, but a long deprecation trail | Steepest — "low-level" by its own docs |
LangChain's docs publish their own decision ladder, and it is worth taking at face value because it steers traffic between the company's own products rather than at a competitor. Use create_agent when you want a customizable harness and standard agent patterns — teams that prefer higher-level abstractions over low-level control. Drop down to LangGraph for workflows mixing deterministic and agentic components, and for long-running business process automation. Above create_agent sits Deep Agents, LangChain's batteries-included starting point.
LlamaIndex is the pick when the problem is document-shaped: parsing messy PDFs, structured extraction, building and querying indexes, and running agents whose main job is answering over that corpus. Its Workflows engine handles multi-step processes that combine agents, data connectors, and tools — a genuine, independent alternative to LangGraph's graph-and-checkpoint model, event-driven rather than graph-based.
The honest overlap: RAG is contested territory (LangChain still ships a large retriever catalogue; LlamaIndex's entire positioning is data), and the LangGraph-vs-Workflows contest for the runtime slot is real. But only one framework makes data its whole identity, and only one makes durable low-level state its whole identity. Pick by your bottleneck.
The commercial layer
All three frameworks are MIT open source; the money is in adjacent SaaS. LangChain Inc. monetises through LangSmith, which since October 2025 spans observability, evaluation, and deployment — the product formerly called LangGraph Platform is now LangSmith Deployment, and LangGraph Studio became LangSmith Studio; pricing and APIs were unchanged by the rename. Tiers: Developer is free for one seat with 5k base traces a month; Plus is $39 per seat per month with 10k traces and one free dev-sized deployment; Enterprise is custom with self-hosted and hybrid options. Usage pricing: base traces at $2.50 per 1k ($5.00 per 1k for 400-day retention), deployment runs at $0.005 per run, and uptime at $0.0036 per minute for production deployments.
LlamaIndex Inc. monetises through LlamaCloud — managed parsing (LlamaParse), structured extraction (LlamaExtract), and hosted indexing pipelines — on a credit system where 1,000 credits cost $1.25 and a basic parse starts around one credit per page. Tiers: Free (10K credits, 5 indexes), Starter at $50 a month (40K credits), Pro at $500 a month (400K credits), Enterprise custom. The pattern is identical on both sides: the framework is free, but durable deployment at scale or industrial-grade document parsing is where the invoice arrives. Self-hosting the equivalents is on you.
Mixing them
Interop is more constrained than 2024-era blog posts suggest, so here is only what the vendors document. Within the LangChain stack, mixing is the design: LangChain agents are LangGraph graphs under the hood, so embedding create_agent nodes inside a larger LangGraph app is the officially blessed pattern. LangGraph also works with no LangChain at all.
Across the company line, the documented direction is LlamaIndex wrapping LangChain: LlamaIndex's integrations catalogue lists LangChain LLM and LangChain Embeddings wrappers, so you can drive LlamaIndex with LangChain-provided models. The reverse direction has quietly eroded — LangChain 1.x's retriever integrations page no longer lists a LlamaIndex retriever, so treat the old LlamaIndexRetriever path as de-emphasised rather than supported. In practice, the reliable cross-stack pattern is plain library composition: LangGraph nodes are arbitrary Python or JS functions, so calling a LlamaIndex query engine inside one is ordinary code, not a blessed integration.
What this comparison doesn't cover
No performance numbers: neither vendor publishes primary-sourced latency or overhead figures for their abstraction layers, and we will not launder third-party guesses into a chart. No code-level walkthroughs, no evaluation of the hosted platforms' reliability, and no verdict on the LlamaIndex TypeScript mono-package's formal deprecation status, which we could not confirm from official docs. This is also a framework comparison, not a coding-assistant one — for tools that write code rather than orchestrate it, see our coding-agents roundup.
All product claims were verified in July 2026 against official documentation and registries; note that every doc site involved moved in the past year (python.langchain.com and the old LangGraph GitHub Pages now redirect to docs.langchain.com, and docs.llamaindex.ai redirects to developers.llamaindex.ai), so older deep links will rot. Traction figures come from our own snapshot dated 15 July 2026. None of the three vendors sponsored, reviewed, or influenced this guide, and inclusion in our AI directory is editorial, not an endorsement.
View author profile → · Editorial policy
