Multi-Agent Systems

LangChain vs LangGraph (v1): Differences and When to Use Each

Since v1.0, LangChain's agents run on LangGraph. What changed in October 2025, how the two differ, and when to use each for enterprise agent systems.

Inductivee Intelligence Team· AI EngineeringApril 15, 2026(updated November 1, 2026)14 min read

TL;DR

LangChain is the agent framework: model, tool and retriever integrations plus create_agent, a ready-made agent loop you customise with middleware. LangGraph is the lower-level runtime underneath it, for custom control flow, durable state and human-in-the-loop. Since v1.0 (October 2025), LangChain's agents run on LangGraph, so using create_agent already means using LangGraph; you reach for LangGraph directly when you need to own the control flow. Rule of thumb: start with create_agent, and drop down to LangGraph when your workflow needs loops, branching or pauses that the standard agent loop and its middleware cannot express. Version note: as of 1 November 2026, PyPI lists langchain 1.4.7 (21 October 2026) and langgraph 1.2.19 (30 October 2026).

What LangChain vs LangGraph Means in v1

The confusion starts with the name. LangGraph sounds like a LangChain alternative — a competing framework you choose between. It is not. Both come from the same team (LangGraph's earliest PyPI release is dated January 2024), and since LangChain 1.0 they are layered: LangChain's own documentation says its agents are built on top of LangGraph, which gives them durable execution, human-in-the-loop support and persistence.

So the useful question is no longer 'LangChain or LangGraph?' but 'is the standard agent loop enough, or do I need to own the control flow?' LangChain's create_agent is described in its docs as a minimal, highly configurable harness: call a model, let it choose tools, stop when it calls no more tools, and customise the behaviour with middleware. LangGraph is described as a lower-level framework and runtime, useful for highly custom and controllable agents: you define state, nodes and edges yourself.

If you learned LangChain from an older tutorial, you may picture chains and agent executors. Much of that legacy functionality now lives in the separate langchain-classic package, and LangChain recommends create_agent for building agents. The sections below are written for the v1 relationship.

What Changed in LangChain 1.0 and LangGraph 1.0 (October 2025)

create_agent is the new standard way to build agents in LangChain. It replaces langgraph.prebuilt.create_react_agent, which LangGraph has deprecated in favour of LangChain's create_agent (LangChain and LangGraph 1.0 announcement, 22 October 2025).
create_agent runs on LangGraph. LangChain's documentation says you get persistence, streaming, human-in-the-loop and time travel without needing to learn LangGraph.
Middleware is the defining feature of create_agent: hooks run before and after the agent and the model, and around model and tool calls. LangChain ships middleware for human approval of tool calls, summarising long conversations, and redacting PII.
Legacy functionality — including legacy chains such as LLMChain and ConversationChain — moved to the langchain-classic package for backwards compatibility.
LangChain packages now require Python 3.10 or higher (Python 3.9 support was dropped).
LangGraph 1.0 is a stability-focused release: the core graph APIs and execution model are unchanged, and the only notable change is the deprecation of the langgraph.prebuilt module. LangChain states a commitment to no breaking changes until 2.0 for these libraries.

LangChain create_agent vs LangGraph: Head-to-Head Comparison (v1)

Dimension	LangChain (create_agent)	LangGraph
Primary abstraction	A standard agent loop (model, tools, middleware)	A stateful graph of nodes and edges with explicit state
Runs on	LangGraph (per LangChain's docs)	Its own runtime
Persistence and durable execution	Provided through LangGraph without extra code	First-class: checkpointing, persistence, durable execution
Human-in-the-loop	Middleware for approving, editing or rejecting tool calls	Interrupts that let you inspect and modify state, then resume
Control flow	The standard loop, customised with middleware	Any graph you design: branches, loops, parallel paths
Best for	Getting a production agent running with minimal code	Custom orchestration, multi-agent topologies and deterministic-plus-agentic hybrids
Observability	LangSmith tracing	LangSmith tracing
Learning curve (our view)	Lower: configure a loop	Higher: learn the state, node and edge model
Stability	1.x; no breaking changes until 2.0 (per LangChain)	1.x; no breaking changes until 2.0 (per LangChain)

When create_agent Is Enough

Single-Agent Tool-Calling Workflows

A single agent that calls a handful of tools — fetch a customer record, query inventory, draft a response, send an email — fits the standard model-and-tools loop. You get persistence and human approval of sensitive tool calls from the runtime and middleware, without designing a graph. Reach for LangGraph only when the loop stops being enough.

Retrieval-Augmented Generation

A RAG flow — embed the query, retrieve, compose a prompt, call the model — is a linear pipeline. LangChain's integrations for models, retrievers and vector stores are what you need; there is no shared state, loop or pause that needs a graph. Adding LangGraph here adds ceremony without value.

Structured Output and Stateless Transformations

Classification, summarisation, translation and schema extraction take the output of one step as the input to the next. Use LangChain's integrations and structured-output support; check the current docs for the exact API.

Guardrails Through Middleware

Requirements like redacting PII, summarising long histories or requiring human approval of a tool call can be met with middleware that LangChain ships, without leaving create_agent.

LangGraph vs LangChain: When to Drop Down to LangGraph

Multi-Agent Workflows With Shared State

When two or more agents collaborate on a shared scratchpad — a researcher that gathers data, a writer that drafts, a critic that reviews — you want explicit state, and LangGraph's nodes and edges express the collaboration pattern. The state object is visible, every node reads and writes it, and you can see which agent changed what.

Loops With Conditional Termination

Research workflows, iterative refinement, Reflexion-style self-critique and plan-and-execute loops share one structure: run a step, evaluate the result, then terminate or loop back. LangGraph's conditional edges express this directly.

Long Pauses for Human Approval

When a workflow must wait for a person — a contract-review agent waiting for legal sign-off, a procurement agent waiting for a purchase authorisation — the pause may last hours or days. LangGraph's persistence stores the graph state so the workflow can resume from where it paused. LangChain's human-in-the-loop middleware covers approval of tool calls inside the standard loop; use LangGraph when the approval point is part of a custom workflow.

Mixing Deterministic and Agentic Steps

LangChain's own overview recommends LangGraph for advanced needs that combine deterministic and agentic workflows — for example a fixed validation step before an agent is allowed to act, or a deterministic routing decision between agent steps.

LangChain and LangGraph Together

The real-world answer is usually both, layered. In v1 that layering is built in: LangChain's create_agent runs on LangGraph, and you can drop to LangGraph when you need custom orchestration. LangGraph also works standalone — its README says it can be used without LangChain, and integrates with any LangChain product — so you can call a model client directly inside a node, or use LangChain's model, retriever and tool integrations inside nodes.

An illustrative design (not a description of a specific deployment): a procurement-style workflow as a LangGraph graph with five nodes — intake, research, draft, review, send — where the state holds the request, research notes, draft and review outcome. Each node calls a model with its own prompt, the edges are conditional (if review passes, go to send; if it fails, loop back to draft), and the checkpointer persists state after every node so the workflow can resume after a restart. LangChain components supply the model and retriever integrations inside the nodes; the graph owns the state and the edges. For the same pattern applied to a real domain problem, see our multi-agent procurement automation architecture.

What LangSmith Is and How It Relates to Both

LangSmith is LangChain's platform for agent evaluations, observability and debugging; its documentation describes it as the tool to trace, debug and evaluate agents built with LangChain, LangGraph or other frameworks. It is a separate product from both libraries, and LangSmith Deployment (formerly LangGraph Platform) is the managed way to deploy stateful agents. You can use LangChain and LangGraph without it, but without LangSmith or an equivalent such as OpenTelemetry tracing you will struggle to see what a graph did. For how the platforms compare, see our AI agent platforms comparison.

Engineering Trade-offs to Understand

State Schema Design Is Harder Than It Looks

LangGraph asks you to define a typed state object that represents everything the graph knows. Getting this schema right is the hardest part of LangGraph design: too narrow and you refactor as the workflow grows, too wide and every node touches irrelevant fields. A sensible default is to start narrow with the inputs and outputs the first version needs, and extend as the graph grows.

Checkpointer Choice Matters in Production

Persistence is only as durable as the store behind it. An in-memory store loses everything on a restart, so it is for development only; production deployments need a database-backed checkpointer. Check LangGraph's persistence documentation for the current list of supported checkpointers, or use LangSmith Deployment, which manages persistence for you.

Debugging Graphs Requires Graph-Aware Tooling

Debugging a graph without tracing is painful: you need node-level traces and state transitions to reason about what happened. LangSmith provides this for LangChain and LangGraph. If you cannot use LangSmith (regulated environments), budget time for an OpenTelemetry integration.

Streaming Is More Complex With Graphs

You can stream tokens from inside a node and stream graph events such as node starts and ends, but the user experience of streaming from a graph-structured workflow is more involved than streaming from a single loop. Plan the streaming UX around the graph structure.

Warning

A common failure mode is reaching for LangGraph too early. Teams see the multi-agent examples, get excited, and rebuild a workflow that the standard agent loop handled into a stateful graph — and end up with a harder-to-debug system with no new capability. A rule that works: start with create_agent, and move to LangGraph only when you have a concrete need for custom shared state, loops, long pauses or checkpointed recovery that the standard loop and its middleware cannot express cleanly.

A Default Rubric for Choosing Between Them

The choice turns on one question: does the workflow need custom state, loops or long pauses that the standard agent loop cannot express? If no, use LangChain's create_agent with middleware. If yes, build that part in LangGraph — LangChain integrations can still supply the models, retrievers and tools inside the nodes.

The choice does not have to be ideological. A single codebase can use create_agent for simple agents and LangGraph for the workflows that need explicit control. If you are comparing LangGraph with CrewAI instead, see our LangGraph vs CrewAI comparison and our CrewAI enterprise deployment guide; for the broader framework landscape, see our agentic AI frameworks comparison and multi-agent orchestration enterprise guide.

If you are mid-architecture and want engineering-honest input on whether a workflow should use the standard agent loop or a custom graph, our AI-readiness assessment is designed for exactly that scoping conversation, and Inductivee Intelligence works on these architectures.

Sources & Further Reading

Version and relationship claims were checked against the primary sources below on 1 November 2026, plus the Inductivee Intelligence services and guides that apply these patterns.

Frequently Asked Questions

Can I use LangChain and LangGraph together?

Yes — and since v1.0 you often already are. LangChain's create_agent runs on LangGraph, so a LangChain agent gets LangGraph's persistence and human-in-the-loop support automatically. You can also build a LangGraph graph directly and use LangChain's model, retriever and tool integrations inside its nodes. LangGraph can equally be used standalone.

Is LangChain built on LangGraph now?

For agents, yes. LangChain's documentation says that LangChain's agents are built on top of LangGraph, and the v1.0 announcement says create_agent uses LangGraph under the hood to run its agent loop. That gives LangChain agents LangGraph's durable execution, persistence and human-in-the-loop support. LangChain also remains the home of the model, tool and retriever integrations.

Is LangGraph a replacement for LangChain?

No. They are layered, not competing. LangChain is the higher-level agent framework; LangGraph is the lower-level runtime for highly custom and controllable agents. Both come from the same team, and LangChain's agents run on LangGraph.

Do I still need LangGraph if I use create_agent?

You are already using LangGraph when you use create_agent, because it runs on it, and you do not need to learn LangGraph to get persistence, streaming and human-in-the-loop. You use LangGraph directly when you need to own the control flow: custom state, loops, branching, long pauses, or a mix of deterministic and agentic steps.

Is LangChain still worth using in 2026?

Yes, for what it is now: the integrations for models, retrievers and tools, plus create_agent and its middleware for building a standard agent quickly. Older chain-style code lives in langchain-classic. If you only need a custom graph, LangGraph can be used standalone, but LangChain's integrations still save you from reimplementing provider and tool wiring.

When should I choose LangChain over LangGraph?

Choose LangChain's create_agent when a standard model-and-tools loop is enough: single-agent tool use, RAG, structured output and stateless transformations. You still get persistence and human approval of tool calls through the runtime and middleware. Move to LangGraph when you cannot express the workflow cleanly with the standard loop.

When does LangGraph become necessary?

When the workflow needs custom state shared by multiple agents, loops with conditional termination, human-in-the-loop pauses that are part of a custom workflow, long-running workflows that must resume after a restart, or a mix of deterministic and agentic steps that the standard loop cannot express.

Can I use LangGraph without LangChain?

Yes. The LangGraph README says it can be used standalone and also integrates with any LangChain product. Nodes can call any model client directly. Many teams still use LangChain's integrations inside nodes to avoid reimplementing provider, retriever and tool wiring.

Which is better for multi-agent systems, LangChain or LangGraph?

For multi-agent topologies that you design yourself — supervisors, hand-offs, shared state, checkpointed coordination — LangGraph's explicit graph is the better fit. LangChain's create_agent is a standard agent loop; check its current documentation for how it composes agents.

What is the difference between LangChain and LangSmith?

LangChain is an open-source framework with the integrations and the create_agent harness you build agents with; LangSmith is LangChain's platform for agent evaluations, observability and debugging. LangSmith's documentation describes it as the tool to trace, debug and evaluate agents built with LangChain, LangGraph or other frameworks. It is a separate product from both libraries, and LangSmith Deployment (formerly LangGraph Platform) is the managed way to deploy LangGraph agents.

How steep is the LangGraph learning curve compared to LangChain?

In our view LangGraph has the steeper curve: you define a typed state schema, write nodes that read and write it, write conditional edges and choose a persistence backend. create_agent asks you only to configure a model, tools and middleware. The ramp is real but manageable if you anchor it in a concrete use case.

How do Pydantic AI, LangChain and LangGraph differ?

They sit at different layers. LangChain gives you integrations and a ready-made agent loop (create_agent); LangGraph is the lower-level graph runtime for custom control flow and durable state; Pydantic AI is a separate Python agent framework from the Pydantic team, built around typed inputs and outputs. See our [Pydantic AI enterprise architecture guide](/blog/pydantic-ai-enterprise-architecture) for that comparison, and choose by how much control flow and state you need to own.

Written By

Inductivee Intelligence Team

Author

Agentic AI Engineering Team

The Inductivee Intelligence engineering team — multi-agent orchestration, RAG pipeline architecture, and data liquidity engineering. Our writing is grounded in what we actually build, break, and operate in production.

Agentic AI ArchitectureMulti-Agent OrchestrationLangChainLangGraphCrewAIMicrosoft Agent Framework

LinkedIn profile

Inductivee Intelligence is a remote-first agentic AI engineering studio. Our engineering content is written by active practitioners and technically reviewed before publication.

Engineer This With Inductivee Intelligence

The engineering patterns in this article are what our team builds into production every day. Explore the related service to see how we deliver this capability at enterprise scale.

Service

Ready to Build This Into Your Enterprise?

Inductivee Intelligence engineers agentic systems, RAG pipelines, and enterprise data liquidity solutions. Let's scope your project.

Start a Project