Most LangChain vs LangGraph debates still treat them as rival frameworks, but since October 2025 one is built on top of the other. The real question is which layer of the same stack your project needs, and you can usually answer it with one test about loops and state.
Key takeaways
- LangChain 1.0 and LangGraph 1.0 shipped together on 22 October 2025, and LangChain’s new agent API runs on LangGraph’s runtime.
- Use LangChain when your app fits the standard “model calls tools, then answers” loop and you want to ship fast.
- Use LangGraph when you need loops you design yourself, state that survives a crash, or a human approving steps.
- Older advice that says “LangChain is a straight line and LangGraph has loops” predates 1.0 and is now incomplete.
- Both projects promise no breaking changes until version 2.0.
Why does the LangChain vs LangGraph question keep coming up?
Both are open-source Python and JavaScript libraries from the same company, both build apps on large language models (LLMs), and both now talk about “agents”. It’s easy to assume they compete.
The question came back on 19 October 2026 when a dev.to post adapting an IBM Technology explainer made the classic case. LangChain chains steps into a directed acyclic graph (DAG), meaning a flowchart that only moves forward. LangGraph adds loops and a shared state that every step can read and change.
That framing is still a good mental model. It just leaves out what changed with 1.0.
What changed when both frameworks hit 1.0?
LangChain released its 1.0 alphas on 2 September 2025 and the stable versions of both libraries on 22 October 2025. The official announcement redrew the line between them.
LangChain became a smaller, higher-level package built around one function, create_agent. It runs the core loop (the model picks a tool, the tool runs, the model reads the result, then repeats or answers) on LangGraph’s runtime. It replaces LangGraph’s old create_react_agent helper, which is now deprecated.
Customisation now happens through middleware, which are small hooks that run inside the agent loop. Built-in middleware covers human approval, summarising a conversation as it nears the model’s context limit, and redacting personal data. Legacy chains moved to a separate langchain-classic package, and Python 3.10 or newer is required.
LangGraph 1.0 changed very little, which was deliberate. It added durable state, so a run can pick up again after a server restart, and first-class support for pausing a run while a person reviews it.
LangChain vs LangGraph: how do they compare side by side?
| Question | LangChain 1.0 | LangGraph 1.0 |
|---|---|---|
| What is it? | High-level agent API plus model and tool integrations | Low-level orchestration runtime |
| How do you shape the flow? | A prebuilt model-and-tools loop, adjusted with middleware | Your own graph of nodes (steps) and edges (transitions) |
| Loops and branches | Inside the standard agent loop | Any loop or branch you design |
| State | Handled for you | Explicit, shared and checkpointed |
| Human approval | Through middleware | Pause and resume anywhere |
| Best for | Shipping a standard agent fast | Long-running, custom or regulated workflows |
| Needs the other? | Yes, it runs on LangGraph | No, it works on its own |
When should you pick LangChain?
Pick LangChain when your app fits the standard loop of model, tools and answer. A support bot that searches your docs, a “chat with this PDF” tool or an assistant that calls three internal APIs all fit.
LangChain’s own LangGraph documentation says the same thing. If you are new to agents or want a higher-level abstraction, start with LangChain’s prebuilt agents. You get provider-neutral model calls, structured output without an extra LLM call, and middleware for common needs.
Think of it like a meal kit. The recipe and portions are decided for you, and you can still swap an ingredient.
When do you need LangGraph?
In the meal-kit analogy, LangGraph is the full kitchen. Reach for it when you can sketch your workflow as a flowchart with arrows that point backwards. Some examples:
- Mixed logic: a loan-review flow where fixed rule checks sit next to LLM judgement calls.
- Long runs: a process that waits days for a document and must not lose its place if a server restarts.
- Oversight: anything that moves money or touches personal data, where a person must approve a step before it runs.
- Multiple agents: a researcher agent and a writer agent passing work back and forth until a reviewer agent signs off.
- Tight budgets: when you need to control exactly which model runs at each step to manage cost and latency.
LangChain’s docs list Klarna, Uber and J.P. Morgan among the companies that use LangGraph. The trade-off is more code. You define the nodes, the edges and the shape of the state yourself.
Is the “start simple, go deeper” path real?
Mostly, yes. Because create_agent already runs on LangGraph, an agent you build with LangChain can be dropped into a larger LangGraph workflow as a single node. You don’t throw away the first version.
Independent guides such as Atlan’s 2026 comparison describe using both as the default setup. Some blogs go further and say every new project should start in LangGraph. My opinion: that’s overkill for a straightforward retrieval bot. Write the extra graph code only when a real loop or pause forces you to.
If you are still deciding whether an agent is worth building at all, our look at how AI is changing small businesses covers the business side.
What happens next
Both projects have promised no breaking changes until 2.0, so code written against the 1.x APIs should keep working through point releases. Expect most new features to arrive as middleware in LangChain and as runtime features in LangGraph, not as new chain types.
The practical housekeeping item is migration. If your code still imports create_react_agent from langgraph.prebuilt or relies on old chain classes, plan a move to langchain.agents or langchain-classic before 2.0 arrives.
FAQ
Can I use LangGraph without LangChain?
Yes. LangGraph’s documentation says you don’t need LangChain to use it, though many teams use LangChain’s model and tool integrations inside LangGraph nodes.
Is LangChain only for straight-line chains now?
No. Since 1.0, its main API is create_agent, which runs a looping tool-calling agent on LangGraph’s runtime. Old linear chains live on in the langchain-classic package.
Which one should a beginner learn first?
Start with LangChain’s create_agent to learn the model-and-tools loop, then learn LangGraph when you need custom loops, durable state or human approval steps.
Your next step: sketch your agent’s workflow on paper. If no arrow points backwards and nothing needs to pause, open the LangChain quickstart. If either happens, start with LangGraph.
2 comments