85 agentic tools audited for security incidents · Talk to the lab →
MotionticBook a call
Compare

LangChain vs LangGraph: two layers of one stack since 1.0

Since both reached 1.0 on 17 October 2025, LangChain is the high-level agent layer whose create_agent runs on LangGraph, and LangGraph is the lower-level runtime for explicit graphs, persistence and human-in-the-loop, so the choice is about how much control over the agent's flow a team needs, not which library to adopt.

Checked

Most LangChain vs LangGraph content online predates October 2025 and describes two separate libraries. That framing is out of date. In the 1.0 releases, LangChain's create_agent became the standard way to build an agent and it runs on LangGraph, while LangGraph's own create_react_agent was deprecated.

For a team building a production agent, the question is now which layer to write against. LangChain gives a short path to a working tool-calling agent with middleware for guardrails. LangGraph exposes the graph, the state and the checkpoints underneath, which matters once a workflow is long-running, branches or needs a human to approve steps.

What changed in 1.0

  • LangChain 1.0

    create_agent is the standard way to build agents and runs on LangGraph. Middleware hooks (before_model, wrap_model_call, wrap_tool_call, after_model) give one place for guardrails and approvals. Legacy chains moved to the langchain-classic package, and Python 3.10 or later is required.

  • LangGraph 1.0

    A stability release: the core graph APIs are unchanged and create_react_agent is deprecated in favour of LangChain's create_agent. LangGraph describes itself as an agent runtime and low-level orchestration framework.

  • Deep Agents, a third layer

    LangChain's batteries-included agent harness adds planning, sub-agents, memory and context management on top of LangGraph. It was still pre-1.0 (0.7.32) on 30 October 2026, with 30,793 GitHub stars.

Where LangGraph earns its verbosity

LangGraph's docs list durable execution, persistence that lets an agent resume where it left off after a failure, human-in-the-loop inspection and editing of state at any point, short-term and long-term memory, and streaming. It can be used without LangChain.

Those features matter for agents that run for minutes or hours, wait on a person, or mix hand-coded deterministic steps with model decisions in one graph. A short request-response agent rarely needs them, and the extra code is a cost.

How to decide

  • Start in LangChain when

    The agent is a tool-calling loop with a handful of tools, guardrails fit in middleware, and the team wants the broadest set of model and tool integrations.

  • Drop to LangGraph when

    The flow has explicit branches, retries or approval steps, state must survive restarts, or several agents hand work to each other. Because create_agent already runs on LangGraph, moving down a layer does not mean a rewrite.

  • Look at Deep Agents when

    The job is long-horizon work such as research or coding, where planning, sub-agents and file-based context are the core of the design.

How Motiontic approaches it

Motiontic's engineers are framework-neutral. They choose per project after a short spike on the client's real task, keep prompts, tool definitions and evals outside the framework so a later switch is a refactor rather than a rewrite, and hand the eval suite to the client's team so the next framework decision can be measured.

LangChain and LangGraph, figures retrieved 30 October 2026

LangChain and LangGraph, figures retrieved 30 October 2026
LangChainLangGraph
RoleHigh-level agent layer; create_agent and middlewareLow-level runtime: graphs, state, checkpoints
Relationshipcreate_agent runs on LangGraphUsable on its own, without LangChain
LicenceMITMIT
LanguagesPython, JavaScript / TypeScriptPython, JavaScript / TypeScript
Latest version1.4.7 (Python, 21 Oct 2026)1.2.18 (Python, 26 Oct 2026)
Durability and human-in-the-loopMiddleware hooks for guardrails and approvalsDurable execution, persistence, state editing at any point
ObservabilityLangSmithLangSmith, with graph visualisation
GitHub stars (Python repo)148,71944,172
PyPI downloads, last week37.24M13.76M

Common questions

Is LangGraph replacing LangChain?

No. Since 1.0, LangChain's create_agent runs on LangGraph, so the two are layers of one stack. LangChain is the quick-start agent layer and LangGraph is the runtime for teams that need explicit control of state and flow.

Can LangGraph be used without LangChain?

Yes. LangGraph's docs state that it can be used without LangChain. Many teams use LangGraph for orchestration and call model SDKs directly inside the nodes.

Is create_react_agent deprecated?

Yes. LangGraph 1.0 deprecated create_react_agent, and LangChain 1.0 made create_agent the standard way to build agents. Tutorials written for the 0.x releases often use the old APIs.

What is Deep Agents in relation to LangGraph?

Deep Agents is LangChain's agent harness built on LangGraph, adding planning, sub-agents, memory and context management. It was at version 0.7.32 for Python on 30 October 2026.

Which should a team learn first, LangChain or LangGraph?

A team new to the stack usually starts with LangChain's create_agent, then reads the LangGraph concepts once it needs persistence, branching or approval steps. Both share the same runtime, so the knowledge carries over.

Running agents that have to hold up?

Describe the agent, the systems it touches and what it must never get wrong. The first call is with a lab engineer, who will say plainly whether it is ready for production, and whether Motiontic is the right team.