# LangChain vs LangGraph

> Source: https://theagentsindex.com/compare/langchain-vs-langgraph (structured, researched, re-verified)

LangChain and LangGraph are not two vendors competing for the same budget. Both come from the same company, LangChain Inc, and LangGraph sits underneath LangChain's own agent builder rather than beside it as an alternative. The 2,900 monthly searches behind "langchain vs langgraph" mostly resolve to one real question: which layer of this stack should you write code against directly?

LangChain is the framework most people mean when they say "build an agent fast." Its create_agent function composes a model, a set of tools, a prompt and middleware such as guardrails, retries and routing into a working tool-calling agent in a few lines, and it plugs into the largest integration ecosystem in the space: hundreds of model providers, vector stores and third-party tools with a maintained connector already written.

LangGraph is the orchestration engine that agent runs on. It implements the Pregel algorithm, so agents are graphs that can loop and branch rather than a straight-line chain, with native persistent memory and human-in-the-loop checkpoints built into the runtime instead of bolted on. LangChain's own documentation states this plainly: "LangChain's agents are built on top of LangGraph. This allows us to take advantage of LangGraph's durable execution, human-in-the-loop support, persistence, and more." Anyone calling create_agent is already running on LangGraph whether they ever import it directly or not.

That relationship sets the real axis of difference: not features, but how much of the graph you want to see. create_agent hands you an opinionated, pre-wired harness built for the common case, a model plus tools plus a system prompt. LangGraph's own API hands you the graph itself: you define the nodes, the edges, the state schema and the checkpoints by hand, which costs more code up front and buys precise control over workflows that mix deterministic steps with agentic ones, or that need a shape create_agent's harness was not built to express.

Pricing is identical because it is the same commercial product either way. Both libraries are MIT-licensed and free to self-host with no usage limits. The paid layer, LangSmith, covers tracing, evaluation and hosted deployment for agents built with either one: a Developer tier at $0 with up to 5,000 traces a month, a Plus tier at $39 per seat with up to 10,000 traces and pay-as-you-go beyond that, and a custom-priced Enterprise tier with self-hosted and hybrid deployment. LangGraph Platform's own hosting price is reported inconsistently across sources, and a small production deployment running real traffic typically lands around $75 to $100 a month in Compute Unit and Storage Unit fees before any LLM API costs.

Scale and backing look different because the two libraries arrived at different times. LangChain carries roughly 144,600 GitHub stars against LangGraph's 40,100, the gap you would expect from the older, broader project against the newer, narrower one it now sits on top of. Neither is a startup betting the company on next year: LangChain Inc raised a $125 million Series B in October 2025 at a $1.25 billion valuation, and because both libraries stay open source and self-hostable, a deployment built on either does not depend on that company's fate the way a closed-source tool's would.

LangChain's own guidance draws the line for when to drop down a layer: reach for create_agent for standard agent development, and go to LangGraph directly for advanced needs that combine deterministic and agentic workflows in ways the harness cannot express. For simpler cases than either, the same team also ships Deep Agents, a more batteries-included layer above create_agent with automatic context compression, which is worth knowing about if create_agent itself still feels like too much setup.

| Fact | LangChain | LangGraph |
| --- | --- | --- |
| What it is | The most widely-used framework for building LLM apps and agents, with LangGraph for stateful multi-agent control: open-source and free to self-host. | Open-source, MIT-licensed framework for building stateful, multi-agent AI workflows on cyclical graphs. |
| Pricing | Free | $0/seat/month |
| API | Yes | Yes — LangSmith exposes an Assistants API with over 30 endpoints for state and memory. LangGraph itself is a Python and JavaScript library installed via pip or npm. |
| Tags | API · Free tier · GPT · Multi-agent · Open source · Self-hosted | API · Claude · Enterprise · Free tier · GPT · Multi-agent · Open source · Self-hosted |
| Best for | Engineering teams building a bespoke, production-grade agent who want the largest integration ecosystem plus real stateful control. | Engineering teams building production agents who need cyclical graphs, durable state and replayable runs |
| Full facts | https://theagentsindex.com/langchain.md | https://theagentsindex.com/langgraph.md |

## Verdict: LangChain or LangGraph?

LangChain, specifically create_agent, for most people building a standard tool-calling agent. You get a working agent in a few lines, the largest integration ecosystem in the space, and you are not giving up any of LangGraph's durability, persistence or human-in-the-loop support in the trade, since create_agent runs on that engine already. If your workflow is a model, some tools, a system prompt, maybe some middleware, this is the layer to start on, and most teams never need to leave it.

Pick LangGraph directly if you are building something the harness cannot express: a workflow that mixes deterministic steps with agentic ones in a specific order, a custom state schema or checkpoint strategy, several coordinated agents with a topology create_agent does not offer as a preset, or infrastructure you intend to expose to other developers the way create_agent itself was built on this engine. Writing the graph by hand costs more code, and it buys the control that a pre-wired harness intentionally trades away.

The mistake runs in both directions. Starting on raw LangGraph for a standard tool-calling agent means hand-building durability, checkpointing and human-in-the-loop wiring that create_agent already gives you for free, for no control you end up using. Staying on create_agent once your workflow needs a graph topology, state shape or deterministic-plus-agentic sequencing the harness was not built to express means fighting the abstraction instead of dropping one layer down to the tool built for exactly that job.

**Our pick:** LangChain

## FAQ

**Is LangGraph a replacement for LangChain?**

No. LangGraph is the orchestration engine LangChain's own create_agent runs on, not a competing product from a different vendor. Choosing between them is a decision about which layer of the same stack to write code against, not a switch between two companies.

**If I use create_agent, am I giving up LangGraph's features?**

No. LangChain's own documentation states that create_agent is built on top of LangGraph specifically to inherit its durable execution, human-in-the-loop support and persistence. You get those features either way; going to LangGraph directly only buys you more control over how the graph itself is shaped.

**Is LangGraph free to use?**

Yes. LangGraph is MIT-licensed and free to self-host with no usage limits, same as LangChain. The paid product both sit on top of is LangSmith, which covers tracing, evaluation and hosted deployment starting at $0 for up to 5,000 traces a month.

**How much does running LangGraph in production actually cost?**

It depends on usage, and third-party sources do not fully agree on LangGraph Platform's own hosting price. A small production deployment typically runs $75 to $100 a month in LangSmith's Compute Unit and Storage Unit fees on top of seat costs, before counting any LLM API spend.