LangChain vs LangGraph: Which Fits Your AI Agent in 2026?

TL;DR

  • LangChain, the company behind both frameworks, just raised $300 million at a $3 billion valuation (November 13, 2026), so both tools are here to stay.
  • LangChain is the quick way to build an AI agent. You give it a model and some tools, and its create_agent function handles the loop for you.
  • LangGraph is the lower-level engine underneath. You draw your agent as a graph of steps, which gives you full control over what happens, in what order, and when a human steps in.
  • They aren’t rivals. Since version 1.0 in October 2025, LangChain agents run on top of LangGraph, so you can start with one and move to the other without starting over.
  • Pick LangChain for chatbots, simple tool-using agents and quick prototypes. Pick LangGraph for long-running workflows, approval steps, multi-agent systems and anything where cost or reliability really matters.
  • New to agents? Start with LangChain. The LangGraph docs themselves recommend it.

The question everyone gets wrong

If you’ve started building with AI agents, you’ve almost certainly hit this fork in the road. LangChain or LangGraph? Both come from the same company. Both build agents. And a lot of blog posts treat them like competitors you have to choose between.

They’re not. The easiest way to think about it is a car. LangChain is the car: get in, turn the key and drive. LangGraph is the engine and gearbox: you can build any vehicle you like with it, but you’ll need to know how the parts fit together.

That picture became even more accurate on October 22, 2025, when both projects hit version 1.0 on the same day. LangChain 1.0 was rebuilt so its agents run on top of LangGraph. So when you use LangChain today, you’re already using LangGraph under the hood. You just don’t have to touch it.

What is LangChain?

LangChain calls itself “the fastest way to build an AI agent”. Its heart is one function, create_agent. You hand it a model, a list of tools and some instructions, and it runs the standard agent loop: the model thinks, picks a tool, reads the result, and repeats until it has an answer.

What makes the 1.0 version interesting is middleware: small add-ons that hook into that loop. LangChain ships some ready-made ones:

  • Human-in-the-loop, which pauses for your approval before a sensitive tool call, like sending an email.
  • Summarization, which squeezes a long chat history so you don’t blow your context window.
  • PII redaction, which strips out personal information before it reaches the model.

LangChain also gives you a standard way to talk to models from different providers, so switching from one AI model to another is far less painful. And because it now runs on LangGraph, your agent gets persistence, streaming and human-in-the-loop support without you needing to learn LangGraph.

One thing to know if you learned LangChain a while ago: the old chains, retrievers and other legacy pieces have moved into a separate package called langchain-classic. The main package is now much leaner and focused on agents. It also needs Python 3.10 or newer.

What is LangGraph?

LangGraph’s own docs describe it as “a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents”. In plain English: instead of one fixed loop, you design your agent as a graph. Each step is a node, and the arrows between them decide what happens next, including branches, loops and pauses.

That sounds like more work, and it is. But it buys you things a simple loop can’t easily give you:

  • Durable execution. If your server crashes halfway through a job, the workflow picks up where it left off instead of starting again.
  • Built-in persistence. State is saved as you go, without you writing your own database code.
  • Human-in-the-loop, anywhere. Pause at any step for someone to review, edit or approve, then carry on.
  • Mixing rules with AI. Some steps can be plain, predictable code; others can be left to the model. You decide which.
  • Memory, both short-term within a conversation and long-term across sessions.

You don’t even need LangChain to use LangGraph; the docs say so directly. LangChain says LangGraph is used in production by companies including Klarna, Uber and J.P. Morgan.

LangChain vs LangGraph: the key differences

[ You're building an AI agent ]
                     |
  Human approval at several steps? --Yes--> LangGraph
                     |
                     No
  Runs for hours or must survive a crash? --Yes--> LangGraph
                     |
                     No
  Several agents handing work to each other? --Yes--> LangGraph
                     |
                     No
  Need tight control over cost or speed? --Yes--> LangGraph
                     |
                     No

               [ LangChain ]

Not sure which one you need? Start at the top and follow the arrows. A single “yes” means LangGraph is worth the extra effort; four “no”s mean LangChain will do the job.

angChain will do the job.

LangChainLangGraph
What it isHigh-level agent frameworkLow-level orchestration framework and runtime
How you buildCall create_agent with a model and toolsDesign a graph of nodes and edges
ControlStandard loop, customised with middlewareFull control over every step, branch and loop
Learning curveGentle; good for beginnersSteeper; you need to think in states and graphs
Human approvalVia ready-made middlewareAt any step you choose
Crash recoveryInherited from LangGraphBuilt in (durable execution)
Best forChatbots, tool-using assistants, prototypesLong-running, multi-step, high-stakes workflows
Needs the other?Runs on LangGraph under the hoodWorks on its own, without LangChain

When to use LangChain

LangChain’s own guidance is simple: reach for it when you want to ship fast with a standard agent pattern, your agent fits the default loop of model, tools, answer, and you’re happy customising it with middleware rather than wiring every step yourself.

Here’s what that looks like in practice.

1. A customer-support chatbot with a few tools

Your bot needs to answer questions, check an order status and look up your FAQ. That’s a model plus three tools, which is exactly the loop create_agent runs. Add summarization middleware so long chats don’t get too expensive, and you’re done.

2. An internal assistant that searches your docs

An assistant that searches your company wiki and answers in plain English is a classic retrieval use case. The model decides when to search, reads the results and answers. No branching logic needed.

3. A quick prototype to test an idea

If you’re trying to prove an idea to your team this week, you don’t want to design a graph. LangChain gets a working agent running in a few lines of code, and because it runs on LangGraph, you won’t have to throw it away later.

4. Switching between AI models

LangChain’s standard model interface means you can try a model from one provider and then swap to another without rewriting your app. That’s handy when prices or quality change, which happens a lot.

5. An agent that needs light guardrails

Need the agent to ask before sending an email, or to strip personal data before it reaches the model? LangChain’s ready-made middleware covers both, with no custom graph needed.

When to use LangGraph

LangChain recommends LangGraph for workflows that mix fixed steps with AI decisions, long-running business processes, sensitive work that needs a human to sign off, highly custom flows, and apps where you have to keep a tight grip on cost or speed.

1. Approval workflows

Think of a refund agent. It reads the customer’s message, checks the order, drafts a refund and then must wait for a manager before any money moves. LangGraph lets you pause at exactly that step, save everything, and resume when someone clicks approve, even if that’s the next morning.

2. Long-running business processes

Onboarding a new employee, processing an insurance claim or reconciling invoices can take hours or days. LangGraph’s durable execution means a server restart in the middle doesn’t lose the work; the workflow picks up where it stopped.

3. Multi-agent systems

When one agent researches, another writes and a third checks the facts, someone has to decide who goes next and what each one sees. That’s a graph. LangGraph gives you control over the hand-offs instead of hoping a single loop gets it right. (If you’re weighing this up, our guide to single AI agents vs multi-agent systems walks through when multiple agents are worth it.)

4. Workflows that mix rules and AI

Many real processes have parts that must always happen the same way, like “always check the customer is verified first”, and parts where AI judgement helps. LangGraph lets you hard-code the first and leave the second to the model.

5. Apps where cost and speed really matter

An open-ended loop can call the model more times than you expect. With LangGraph you decide exactly how many model calls happen and where, which makes cost and latency far more predictable at scale.

You don’t have to choose just one

Here’s the part most comparisons miss. Since 1.0, LangChain and LangGraph are designed to be used together:

  • Start with LangChain. Build your agent with create_agent and ship it.
  • Drop down to LangGraph when you hit a wall. If you need a custom step, a branch or an approval gate the middleware can’t handle, you can build that part in LangGraph, because your LangChain agent is already running on it.
  • Mix them. A LangGraph workflow can include a LangChain agent as one of its steps. Use the graph for the parts that must be controlled and the agent for the parts that need flexibility.

There’s also a third option worth knowing about. Deep Agents, from the same team, sits on top of both and adds planning, a virtual file system and sub-agents for long, complex jobs like research or coding. It’s overkill for most projects, but handy when a single context window isn’t enough.

Which one should you use? A quick decision guide

Ask yourself these questions in order:

  1. Are you new to building agents? Use LangChain. LangGraph’s own docs suggest starting there.
  2. Does your agent just need a model and some tools? Use LangChain.
  3. Does a human need to approve something before it happens? LangChain’s middleware may be enough for one or two approvals. If approvals sit at several points in a process, use LangGraph.
  4. Will a single task run for hours or days, or must it survive a crash? Use LangGraph.
  5. Do you have several agents that must hand work to each other? Use LangGraph.
  6. Does every model call cost you real money at scale? Use LangGraph to control exactly when the model is called.

If you answered “LangChain” to everything, great: you’ll be up and running today. If one answer pointed to LangGraph, you can still start with LangChain and move that one part over later.

FAQ

Is LangGraph replacing LangChain?

No. They do different jobs. LangChain is the high-level way to build agents, and since version 1.0 it runs on top of LangGraph. LangGraph is the lower-level engine for when you need more control.

Do I need to learn LangChain before LangGraph?

No, LangGraph works on its own. But if you’re new to agents, the LangGraph docs recommend starting with LangChain’s agents and getting comfortable with models and tools first.

Can I use LangChain and LangGraph together?

Yes, and that’s the intended setup. LangChain agents already run on LangGraph, and a LangGraph workflow can include a LangChain agent as one step.

What changed in LangChain 1.0?

Released on October 22, 2025, LangChain 1.0 introduced create_agent as the standard way to build agents, added middleware for things like human approval and summarization, and moved older features such as chains into a separate langchain-classic package. It needs Python 3.10 or newer.

Which is better for production?

Both are used in production. For simple agents, LangChain is enough and gets the reliability features of LangGraph underneath. For long-running, high-stakes or heavily customised workflows, LangGraph gives you the control you’ll want. LangChain says companies including Klarna, Uber and J.P. Morgan use LangGraph.

Are LangChain and LangGraph free?

Both are open-source frameworks, free to use. You still pay for the AI models you call, and the company sells separate paid products, such as LangSmith for monitoring and deployment.