LangGraph vs LangChain: Which Layer Do You Actually Need?

LangGraph vs LangChain isn't a choice between rivals any more. It's a choice of altitude. Since the 1.0 releases, LangChain's agents are built on top of LangGraph, so every LangChain agent you create is already a LangGraph graph underneath.

The short answer:

• LangChain is the agent framework. You call create_agent, hand it a model, tools, a prompt, and middleware, and you get a working tool-calling agent.
• LangGraph is the agent runtime. You draw the control flow yourself as a graph of nodes and edges, with persistence, pauses, and resumable state.
• You can use LangGraph without LangChain. You can't really use LangChain's agents without LangGraph, because installing langchain pulls langgraph in as a dependency.
• Most teams should start with LangChain and drop down to LangGraph only for the part of the workflow that doesn't fit a standard agent loop.

If you're weighing LangChain against a data-first framework instead, LangChain vs LlamaIndex covers that split. This post stays inside the LangChain family.

Quick comparison

LangGraph vs LangChain after 1.0: one sits on the other

Most comparisons you'll find were written for the old world, where LangChain meant chains and LangGraph meant "the graph thing for agents." That picture changed on October 22, 2025, when LangChain shipped 1.0 of both libraries together.

Three changes matter for this decision:

1. create_agent became the standard way to build agents in LangChain, and the v1 release notes say it is built on LangGraph. It replaces langgraph.prebuilt.create_react_agent, the prebuilt agent that used to live on the LangGraph side.
2. The old chains moved out. Legacy chains, retrievers, the indexing API, and the hub module went to a separate langchain-classic package, so the core langchain package now centres on the agent loop.
3. Both promised stability. The 1.0 announcement commits to no breaking changes until 2.0.

So if a tutorial tells you "LangChain is for linear chains, LangGraph is for loops," it's describing langchain-classic. The current LangChain is an agent framework whose agents are LangGraph graphs.

The dependency tree makes this concrete. As of September 2026, the langchain package on GitHub lists langgraph as a required dependency. The langgraph package lists langchain-core, the shared base types for messages and models, but not langchain itself.

Where LangChain is stronger

LangChain wins whenever your agent looks like the usual loop: the model picks a tool, the tool runs, the result goes back to the model, repeat until done.

The LangChain docs describe create_agent as a minimal, highly configurable agent harness. You compose it from four parts: model, tools, prompt, and middleware.

Middleware is where the value sits. Instead of rewriting the loop, you hook into it. LangChain ships prebuilt middleware for PII handling, conversation summarization, and human-in-the-loop approval, and you can write your own for dynamic prompts, selective tool access, or guardrails.

A concrete scenario: you want a support agent that reads an order database, drafts a refund, and asks a human before issuing anything over a threshold. That's create_agent plus a human-in-the-loop middleware. You never touch a graph.

The last row is the quiet one. Because the agent is a LangGraph graph, it inherits persistence, streaming, human-in-the-loop support, and time travel without you writing any graph code.

Where LangGraph is stronger

LangGraph wins when your process isn't one loop. The LangGraph overview calls it "a low-level orchestration framework and runtime" for long-running, stateful agents, and its selling point is that you can mix deterministic and agentic steps in one workflow.

Picture an invoice pipeline. Step one is a fixed parser. Step two is an LLM that classifies the vendor. Step three branches: known vendors go straight to approval, unknown ones go to a human, and the whole run has to survive a server restart halfway through. A single agent loop can't express that cleanly. A graph can.

The Graph API gives you the pieces:

• StateGraph, parameterised by a state schema you define, with reducers that decide how updates merge
• Nodes, plain functions that read state and return updates
• Edges, fixed or conditional, which can loop back to earlier nodes

Then the runtime features that make it production-shaped:

• Checkpointers. Per the persistence docs, a checkpointer saves a thread's graph state as checkpoints. That gives you conversation continuity, fault tolerance, and time travel. InMemorySaver is for development; Postgres-backed savers are for production.
• Threads. Each run is keyed by a thread_id, which is how the checkpointer knows which state to reload.
• Interrupts. Call interrupt() inside a node and the graph pauses indefinitely, saves its state, and surfaces a payload to your app. You resume by re-invoking the graph with Command(resume=...). Interrupts need a checkpointer and a thread ID to work.
• Stores for long-term memory that spans threads, such as user preferences.

Do you need LangChain for LangGraph?

No. The LangGraph docs say it directly: you don't need to use LangChain to use LangGraph. You can write your own model calls inside LangGraph nodes and never import langchain.

What you do get either way is langchain-core, because LangGraph depends on it for shared types like messages.

The reverse is where people get confused. If you use LangChain's create_agent, you are using LangGraph whether you think about it or not. That's why "LangChain or LangGraph" is often the wrong question. The better one is "do I need to write the graph myself, or is the standard agent loop enough?"

Where Deep Agents and LangSmith fit

Two more names show up in every search for this topic, and both have changed recently.

Deep Agents sits one level above LangChain. In an August 2026 post, LangChain frames the stack as three layers: LangGraph is the agent runtime, LangChain is the agent framework, and Deep Agents is the agent harness. Deep Agents is the core LangChain agent plus middleware for things like context compression and spawning subagents. LangChain's own advice is to start there and drop down only when you need more control.

LangSmith is the commercial platform around all of it: observability, evaluation, and deployment. The naming trips people up. Per the LangSmith changelog, in October 2025 LangGraph Platform was renamed LangSmith Deployment and LangGraph Studio became LangSmith Studio. Existing deployments and APIs were unchanged.

LangSmith Deployment runs on cloud, hybrid, self-hosted, or a standalone Agent Server, and its docs say it's framework-agnostic. It can host agents built with LangGraph, Claude Agent SDK, CrewAI, and others.

The libraries stay open source under MIT. LangSmith is a separate commercial product with its own plans, so budget for it on its own terms rather than assuming it comes with the libraries. If you're comparing LangSmith's tracing with an open-source option, see Langfuse vs LangSmith. If you're leaving the LangChain family altogether for a vendor SDK, OpenAI Agents SDK vs Claude Agent SDK covers that route.

How to decide

1. New to the ecosystem and building a normal agent? → LangChain's create_agent. Add middleware before you reach for a graph.
2. Want a batteries-included agent with subagents and context management? → Deep Agents, which is LangChain underneath.
3. Process mixes fixed steps, branches, and LLM calls? → LangGraph.
4. Runs are long, must pause for humans mid-process, or must survive crashes? → LangGraph with a durable checkpointer.
5. Don't want LangChain's abstractions at all? → LangGraph on its own. It works fine without langchain.
6. Following an old tutorial that imports chains? → That's langchain-classic. Don't start new work there.

Before any of this: getting a working agent at all

Everything above assumes you're a developer with a Python environment, API keys, and time to debug a graph that loops forever. That's the right audience for LangGraph. It's also a wall for a lot of people who just saw someone's agent demo and want that result on their own files.

Taku is built for that second group. It's an AI-native desktop workspace where you mirror an AI app, skill, or workflow someone already got working, run it, remix it, and keep it. It isn't an agent framework and doesn't compete with LangChain or LangGraph, which are much stronger for building custom agents from code. Taku is in Beta, and the Mac app is available now. The free app library shows what mirroring a working setup looks like.

FAQ

Is LangGraph replacing LangChain?

No. They're layers of the same stack. LangChain's create_agent is built on LangGraph, and LangChain's own guidance is to use the higher layer until you need the lower one's control.

Can I use LangGraph without LangChain?

Yes. LangGraph's docs state you don't need LangChain to use it. It does depend on langchain-core for shared types, but not on the langchain package.

Is LangChain still just for chains?

Not since 1.0. Legacy chains and retrievers moved to langchain-classic, and the core package now focuses on create_agent and middleware.

What happened to LangGraph Platform?

It was renamed LangSmith Deployment in October 2025, and LangGraph Studio became LangSmith Studio. The open-source LangGraph library kept its name.

Are LangChain and LangGraph free to use?

Both libraries are MIT-licensed on GitHub. LangSmith, the observability and deployment platform, is a separate commercial product with its own plans.

Which should a beginner learn first?

LangChain's create_agent. You'll be using LangGraph underneath from day one, and you'll recognise the moment you need to write a graph yourself.