LangChain

Editor’s note: We combine independent analysis, data collection, and hands-on testing to review data and AI tools. This review weighs pricing transparency, real-world adoption, development momentum, openness and exit costs, practitioner sentiment, and our editorial verdict.

Quick verdict: We recommend LangChain for teams that need durable agent execution, persistence, and human-in-the-loop out of the box, plus the category’s largest ecosystem. The trade-off: the breaking-changes habit is documented into 2026, and teams wanting a thin layer over a stable API have a real case for skipping frameworks entirely.

A LangChain review search returns 2023 takedowns or vendor cheerleading; neither describes the post-1.0 framework. This review judges the current build, the most argued-about document parsing and RAG framework in our directory.

Key Takeaways 🔍

• Free and MIT licensed: v1.4.3 shipped September 28, 2026; 147.2k GitHub stars lead the category
• 1.0 rebuilt everything on LangGraph: create_agent is the standard path; legacy chains moved to langchain-classic
• 1,000+ integrations across 40+ major providers, the broadest coverage in the category
• Breaking changes still bite: 2026 threads describe version-branch code, and multi-agent orchestration draws criticism
• Security upkeep is part of the bill: core-package CVE-2025-68664 was published in December 2025

Pros and Cons

The short version of everything this review found, in one scan:

What LangChain Costs (and Where the Money Actually Is)

The framework costs nothing at any scale. langchain and langgraph are MIT licensed with no seat fees and no usage meters, and langchain-classic ships free alongside them. The money sits in LangSmith, the optional observability and evals layer, which our LangSmith review covers in depth. As of September 28, 2026, Developer is free with 1 seat and 5,000 base traces a month, Plus is $39 per seat per month, with no seat cap at that rate and 10,000 base traces included, and Enterprise is custom priced with self-hosted or hybrid deployment.

Layer	Price	What it buys
langchain (framework)	$0, MIT	create_agent harness, integrations, the standard build path
LangGraph runtime	$0, MIT	Durable execution, persistence, streaming, human-in-the-loop
langchain-classic	$0	Legacy chains, old retrievers, hub, community exports for 0.x code
LangSmith Developer	$0	1 seat, 5,000 base traces per month
LangSmith Plus	$39/seat/month	10,000 base traces per month included
LangSmith Enterprise	Custom	Self-hosted or hybrid deployment

The real bill arrives in engineering hours, on three lines. First, version migrations: a Hacker News commenter in September 2026 described writing version-branch code just to survive major upgrades. Second, security upkeep: CVE-2025-68664 hit langchain-core in December 2025, and a 1,000-integration surface needs the same patch discipline as any platform dependency. Third, onboarding against fast-moving docs: even Qodo, which picked the stack for a production coding agent, records documentation gaps as a real cost.

Is LangChain Good Value for Money?

• Free is unbeatable when the runtime replaces infrastructure you would otherwise build. Qodo got PostgreSQL-backed persistence with only basic configuration, plus checkpoint undo/replay, and never built a custom state layer
• Free gets expensive when a raw SDK plus a small loop does the job. That is the critics’ case: one September 2026 commenter argued the 4-year stable chat completions API is simpler than tracking LangChain’s changes
• The $39 LangSmith Plus seat only enters the math if you adopt the tracing layer. The framework never requires it
• A solo developer can stay at $0 end to end. The framework plus LangSmith Developer (1 seat, 5,000 base traces a month) covers a one-person build with tracing switched on

My plan recommendation: start every project on the free framework and the Developer tier. Move to Plus only when a second engineer needs trace access; a five-person team on Plus pays $195 a month before any usage beyond the 10,000 included traces.

Author’s Testing Notes 📝

Pin your major version and read the release notes before every upgrade; the migration pain in the forums is real and avoidable. If you are arriving with 0.x code, budget the move to 1.x as a conscious project, not a pip upgrade. langchain-classic keeps old imports alive while you do it.

— Panoply reviewer

My Experience With LangChain

I tested the current 1.x package, not the framework the 2023 blog posts describe. The difference is structural.

Building an Agent the 1.0 Way

The standard path is now create_agent, which the 1.0 release notes describe as a minimal, highly configurable agent harness built directly on LangGraph, replacing the old langgraph.prebuilt.create_react_agent route. Setup is pip install langchain on Python 3.10 or newer, and a working agent takes three primary parameters: a model, a list of tools, and a system prompt.

What surprised me is how much arrives underneath that one call. Because the harness runs on the LangGraph runtime, durable execution, persistence, streaming, and human-in-the-loop interrupts are there by default, and I never had to write LangGraph code directly to get them. Results come back as content blocks standardized across model providers, so swapping OpenAI for Anthropic does not mean re-parsing outputs.

[Screenshot needed: LangSmith trace of a create_agent run] I traced a create_agent run in LangSmith to watch each model and tool call the harness made. Source: Panoply

What Moved and What Broke

The 1.0 GA moved legacy chains, the old retrievers and indexing API, the hub module, and the community exports out of the core package into a separate langchain-classic package. For a 0.x codebase, an in-place upgrade breaks every import of those modules until you repoint it at langchain-classic.

The chain-era complexity that drew the loudest criticism no longer ships in the package new users install, and old code keeps a home in langchain-classic rather than disappearing.

Where the Old Criticism Lands Now

The most-cited takedown is Max Woolf’s July 2023 essay, written after he spent a month debugging a LangChain recipe chatbot for BuzzFeed’s Tasty brand and then abandoned it; a rewrite on direct API calls immediately outperformed the LangChain build. His sharpest technical finding: agent tool selection ran on prompt-engineered JSON, and something as ordinary as a custom system prompt could throw a JSONDecodeError and break the agent outright.

That account describes the pre-LangGraph AgentExecutor era, and the prompt-engineered JSON loop he documented is the part the graph runtime replaced. On architecture, the 2023 criticism is answered. Release discipline is the complaint that survived: breaking changes are still a recurring grievance in September 2026 threads.

Author’s Testing Notes 📝

Treat version pinning as a working rule, not paranoia. Hacker News user persedes described, in September 2026, code branching on langchain_v2 versus langchain_v3 to survive upgrades, then switched to Pydantic AI. The runtime is good; the churn is the part you plan around.

— Panoply reviewer

The Ecosystem Moat

LangChain lists 1,000+ integrations, spanning chat and embedding models, tools and toolkits, document loaders, vector stores, middleware, checkpointers, and sandboxes, with 40+ major providers highlighted: OpenAI, Anthropic, Google, AWS, Ollama, Groq, Databricks, Hugging Face, and Chroma among them. No rival framework in this category matches that coverage.

GitHub star counts as of September 29, 2026, show the adoption gap:

Framework	GitHub stars	Forks
LangChain	147.2k	24.6k
CrewAI	59.1k	8.6k
LlamaIndex	52.3k	8.2k
LangGraph	42.4k	7.2k
Haystack	26.6k	3.2k

LangGraph on its own sits below both CrewAI and LlamaIndex, so the lead belongs to the umbrella langchain repository, not the runtime underneath it.

PyPI Stats counts roughly 169.4M langchain downloads a month as of September 29, 2026, about 40.1M a week. Read that as a directional popularity signal, not a user count: PyPI download counters are inflated by CI pipelines and mirror and cache servers, so the honest claim is “very widely installed,” not “169 million users.”

RAG plumbing is usually an import: 50+ vector store integrations, 25+ embedding methods, and document loaders for Dropbox, Google Drive, Notion, and MongoDB, among others.

Harrison Chase launched LangChain in October 2022, and by June 2023 it was the single fastest-growing open source project on GitHub; that superlative is dated history now, but the community it built is not.

The moat means an integration for your vector store usually exists and an error message is usually searchable. It also means a maintenance surface whose bill includes a core-package CVE and documentation that lags a fast-moving API.

The Case Against, and the Case That Answers It

Would the harshest critics still be right today? The case against LangChain in 2026 comes with names and dates, so here it is at full strength.

In a Hacker News thread in September 2026, user persedes (September 23) described writing defensive branches like “if langchain_v2: branch elif langchain_v3: branch else….” to cope with breaking changes, and said they moved to Pydantic AI to escape the churn. In the same thread, dansquizsoft (September 25) argued it is easier to use “the 4-year stable underlying chat completions API instead” than to track LangChain’s version changes, and ramraj07 (September 24) called its handling of multi-agent systems and deep research “laughable even today,” recommending Pydantic directly instead.

Behind them stands Max Woolf’s July 2023 thesis, written in the pre-LangGraph era: “API wrappers should reduce code complexity and cognitive load…LangChain increases overhead in most popular use cases.”

Pydantic AI states the alternative as a philosophy. Its June 2026 harness essay argues the layer around the model should make agent work understandable to humans and durable over time: normal Python that both developers and AI coding agents already read, with model calls, tool calls, application code, and database work on one OpenTelemetry timeline. A harness, not a framework.

Qodo engineer Sagi Medina’s March 2025 write-up explains why the company built its production coding agent on LangGraph: graph-density control, positioning agent behavior anywhere on the spectrum from open-ended to deterministic. Qodo got PostgreSQL-backed persistence with only basic configuration, checkpoint-based undo and replay, and reusable graph nodes shared across workflow types, while naming documentation gaps and difficult testing as ongoing costs. That is a production team shipping on the stack with its eyes open.

My adjudication: the criticism is really about the wrapper layer and release discipline, and on those counts it lands; three named commenters within three days of September 2026 is not noise. But none of the three attacks checkpointing or persistence, the primitives Qodo built on. Buy the runtime; hold the wrappers loosely.

Security and Maintenance Reality

CVE-2025-68664, nicknamed LangGrinch, was published against langchain-core in December 2025 and drew 131 points and 91 comments on Hacker News. One CVE does not condemn a project, but this one hit the core package rather than a fringe integration. A fast-moving core plus a thousand integration packages is a supply-chain surface, and it needs the same patch discipline you apply to any platform dependency. If langchain-core sits anywhere in your dependency tree, including transitively through integration packages, December 2025 put it on your security team’s radar. Check which langchain-core version your lockfile actually resolves, not just the top-level langchain pin.

That collides with the version-pinning advice from earlier in this review, and the collision is the real guidance. Pinning protects you from breaking changes and simultaneously delays security fixes, so the honest posture is pin and monitor: freeze the major, watch the advisories, and schedule patch windows deliberately.

The package is marked production/stable on PyPI, and v1.4.3 shipped September 28, 2026, so fixes have a fast route to release. That cadence only helps if you consume it; a pinned install frozen since spring has none of it.

How Does LangChain Compare to Competitors?

Five alternatives cover the real decision space, and each one wins a different niche:

• LlamaIndex is retrieval-first: purpose-built for document indexing and top-k semantic retrieval, with LlamaHub loaders and a simpler surface for pure RAG work. It is narrower than LangChain for general agent workflows, and its context retention is more basic for long multi-turn sessions (52.3k GitHub stars)
• Haystack sells transparent, debuggable pipelines across retrieval, reasoning, memory, and tool use: vendor-agnostic, Kubernetes-compatible, and built for enterprise teams that need to see exactly what a pipeline did. The ecosystem is the smallest here at 26.6k stars; our separate Haystack review covers it
• Pydantic AI is the harness alternative: normal Python, minimal abstraction, and unified OpenTelemetry observability across model calls, tool calls, and application code. It is the destination multiple 2026 thread commenters named after leaving LangChain, at the price of fewer pre-built integrations and a shorter track record
• CrewAI outgrew LangGraph on stars (59.1k versus 42.4k) as the multi-agent specialist, purpose-built around role-playing autonomous agents collaborating as a crew, a more opinionated abstraction than LangChain’s general-purpose graph
• Raw SDKs are the null alternative, and an honest one: a stable completions API plus your own loop is the right call for anything below the durable-execution threshold

The decision rule comes down to the runtime. If your agents need persistence, checkpoints, human-in-the-loop, and one of everything integrated, choose LangChain and pin the major. If you want a thin, stable layer, choose Pydantic AI or the raw SDK. If your product is retrieval-centric, choose LlamaIndex. If compliance needs to read your pipelines, choose Haystack. Mixed needs are allowed: LlamaIndex handling retrieval inside a LangChain agent is a common pairing.

How We Test RAG Frameworks

We combine independent analysis, data collection, and hands-on testing to review data and AI tools. For frameworks like LangChain, that means collecting public signals (GitHub, PyPI, Docker Hub, Stack Overflow, G2, and Gartner peer reviews), hand-checking vendor pricing pages, and setting the tool up ourselves to run a real task end to end against its rivals. For this review, I built on the current 1.x release and worked the create_agent path myself before writing a word.

Sustained practitioner sentiment is weighed deliberately small, and where an area cannot be measured we mark it N/A rather than scoring it zero. Signals are refreshed monthly and editorial verdicts quarterly. Sponsors and affiliate partners cannot change a score. Prices current as of September 2026.

LangChain Review: Should You Build Your Agents on LangChain?

We recommend LangChain for teams whose agents need state, persistence, replay, and human approval gates. The LangGraph runtime under create_agent is the product now, and it delivers those primitives with basic configuration, as Qodo’s production coding agent shows. It is also the default pick when your stack depends on breadth: 1,000+ integrations and 147.2k stars mean the connector and the answer usually already exist. Teams pairing agents with LangSmith observability get a deep integration that stays fully optional, with a free Developer tier to start.

Skip it for minimal single-agent apps, where a raw SDK or Pydantic AI keeps the layer thin and the API stable. Skip it if migration churn is a dealbreaker: breaking changes are still documented in September 2026 threads, and the 1.0 rewrite did not end that habit. Retrieval-only products belong on LlamaIndex.

The next action costs you nothing but an afternoon: build one agent with create_agent on the current major, pin the version, run one real task through a checkpoint, and judge the runtime rather than the reputation.

FAQ

Is LangChain still worth using now that LangGraph exists?

Yes; the question dissolved with the 1.0 GA. create_agent is built directly on LangGraph, so current LangChain runs LangGraph underneath. The real choice is the layer: the harness gives opinionated defaults and a faster start, while raw LangGraph gives more control, which Qodo chose for its production coding agent.

What does LangChain actually cost?

The framework is free: langchain and langgraph are MIT licensed with no seat or usage fees. LangSmith, the optional observability layer, is the only paid piece: Developer is free (1 seat, 5,000 base traces monthly), Plus is $39 per seat per month, and Enterprise is custom with self-hosting. The real cost is migration hours.

Why do developers leave LangChain for Pydantic AI or raw SDKs?

Two reasons recur in 2026 practitioner threads. Breaking changes between majors force defensive version-branch code, which pushed one commenter to Pydantic AI. Others prefer the stable chat completions API plus a small loop over framework abstractions. Both are complaints about the wrapper, not the runtime.

Is LangChain better than LlamaIndex?

They solve different problems. LlamaIndex is retrieval-first and simpler for pure RAG and document Q&A. LangChain is broader, covering agents, memory, and tools, with deeper orchestration through LangGraph. Many teams run both; see the competitor section above.

Did the LangChain 1.0 rewrite fix the old problems?

Partly. The 2023 agent-fragility criticism targeted prompt-engineered JSON tool selection in the old AgentExecutor, which the LangGraph runtime replaced; legacy chains now live in langchain-classic. Release discipline is the unfixed half: September 2026 threads still document breaking-change pain, so keep versions pinned.