# LangChain vs LangGraph: LangChain now runs on LangGraph

> Use LangChain's create_agent for a fast start and LangGraph for custom, long-running workflows. Both are free and MIT-licensed; LangSmith is the paid part.

URL: https://claudegpt.si/news/langchain-vs-langgraph  
Published: 2026-11-19T22:59:59.700Z  
Author: ClaudeGPT Si Newsroom  
Section: Reviews  
Topics: LangChain, LangGraph, LangSmith, AI agents, Open source  
Publisher: ClaudeGPT Si

## Key takeaways

- Since version 1.0, LangChain's create_agent runs on LangGraph, and installing langchain also installs langgraph.
- LangChain's docs recommend LangChain for getting started quickly and LangGraph for fine-grained control, durable execution and workflows that mix fixed and model-driven steps.
- Both libraries are free under the MIT license; LangSmith, the paid platform, costs $0 for one seat or $39 per seat a month on Plus as of November 19, 2026.

LangChain vs LangGraph is no longer a choice between two rival frameworks. Since version 1.0, LangChain's agents run on LangGraph: use LangChain's `create_agent` when you want a working agent in a few lines, and drop down to LangGraph when you need to control every step, branch and pause yourself. Both are free, open source under the MIT license, and made by the same company.

The confusion is understandable. For years LangChain was the big library of chains and integrations, and LangGraph was the newer add-on for agents. The [LangChain docs](https://docs.langchain.com/oss/python/concepts/products) now describe them as two layers of one stack: LangChain is the agent framework and LangGraph is the agent runtime underneath it. This comparison is based on LangChain's own docs, its GitHub repositories, PyPI and its pricing page, read on November 19, 2026. It is not a hands-on test.

## LangChain vs LangGraph at a glance

| | LangChain | LangGraph |
| --- | --- | --- |
| What it is | Agent framework: models, tools, the agent loop, middleware | Orchestration runtime: graphs of state, nodes and edges |
| Main entry point | `create_agent` | `StateGraph` |
| Level | High level, few lines of code | Low level, you design the flow |
| Built on | LangGraph | Nothing from LangChain except `langchain-core` |
| Best for | Standard tool-calling agents, getting started, team conventions | Long-running, stateful workflows that mix fixed steps and model-driven steps |
| Human approval | `HumanInTheLoopMiddleware` | Interrupts that pause the graph |
| Multi-agent | Subagents and skills | Subgraphs |
| Latest Python release | 1.5.2 (November 18, 2026) | 1.2.23 (November 19, 2026) |
| Latest JavaScript release | `langchain` 1.6.7 | `@langchain/langgraph` 1.7.5 |
| Python version | 3.11 or newer | 3.10 or newer |
| License | MIT | MIT |
| GitHub stars | About 149,900 | About 45,200 |
| Price | Free | Free |

Versions are from PyPI and npm, and star counts from the GitHub repository pages, as of November 19, 2026.

## What LangChain does

LangChain's main job now is one function. The [LangChain overview](https://docs.langchain.com/oss/python/langchain/overview) describes `create_agent` as a small, configurable wrapper around the model loop: you pass a model, a list of tools and a system prompt, and you get an agent that calls the model, runs the tools it picks, and stops when the model calls no more tools.

```python
from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)
```

You change its behavior with middleware, small pieces of code that run before or after each model call or tool call. LangChain ships some ready-made: one redacts personal data before it reaches the model, one summarizes a conversation that gets too long, and one asks a person to approve a sensitive tool call. The [LangChain v1 release notes](https://docs.langchain.com/oss/python/releases/langchain-v1) list six hooks for your own middleware, from `before_agent` to `after_agent`.

The rest of LangChain is the integration layer: one interface to chat models from OpenAI, Anthropic, Google, AWS, Ollama and others, plus tools, messages and embeddings.

Version 1.0 also cut a lot. Legacy chains, retrievers such as `MultiQueryRetriever`, the indexing API and the prompt hub moved to a separate package, `langchain-classic`. Code that still uses them needs that package installed.

## What LangGraph does

The [LangGraph overview](https://docs.langchain.com/oss/python/langgraph/overview) calls it "a low-level orchestration framework and runtime for long-running, stateful agents." You draw your app as a graph. Nodes are functions, some plain code and some model calls. Edges decide what runs next. A shared state object moves through the graph.

```python
from langgraph.graph import StateGraph, MessagesState, START, END

graph = StateGraph(MessagesState)
graph.add_node(mock_llm)
graph.add_edge(START, "mock_llm")
graph.add_edge("mock_llm", END)
graph = graph.compile()
```

What you get for the extra work is control over how the run behaves:

- **Durable execution.** State is checkpointed, so a run can resume after a crash or a pause instead of starting over.
- **Human-in-the-loop.** The graph can stop, let a person inspect or edit the state, and continue.
- **Memory.** Short-term state per conversation thread, and long-term memory across sessions.
- **Streaming.** Tokens, state updates and other events stream out as the graph runs.

The docs stress that LangGraph does not dictate your prompts or how your agent is structured. That is the point of it. The [LangGraph repository](https://github.com/langchain-ai/langgraph) names Klarna, Replit and Elastic among the companies that use it.

## How the two fit together

The link is direct. LangChain 1.0 rebuilt its agents on LangGraph, and LangGraph 1.0 deprecated its own prebuilt `create_react_agent` in favor of LangChain's `create_agent`. Both reached 1.0 on PyPI on October 17, 2025.

Install `langchain` and you get `langgraph` with it: the current release requires LangGraph 1.2.12 or newer. That is why a LangChain agent gets checkpointing, streaming, human approval and "time travel" (rewinding a conversation to an earlier point) without you writing any graph code. The [LangGraph v1 notes](https://docs.langchain.com/oss/python/releases/langgraph-v1) put the intended path plainly: "Use LangChain for a fast start; drop to LangGraph for custom orchestration."

It does not work the other way. LangGraph runs without the `langchain` package, though it does install `langchain-core`, the small package of shared message and model types. You can call any model SDK inside a LangGraph node.

## When to use LangChain and when to use LangGraph

LangChain's docs give their own checklist. Use LangChain when:

- you want to build an agent quickly,
- you want standard building blocks for models, tools and the agent loop,
- your app is a straightforward agent without complex orchestration.

Use LangGraph when:

- you need fine-grained control over each step,
- your agent runs for a long time and must survive failures,
- your workflow mixes fixed steps with model-driven ones, such as "always validate, then let the model decide, then always log",
- you need infrastructure built for running agents in production.

The sensible order is to start with `create_agent` and see where it stops fitting. If your app is "a model with some tools," middleware covers most custom needs. If you find yourself fighting the loop to force a fixed order of steps, parallel branches or several agents handing work to each other, that is LangGraph's job.

## LangChain vs LangGraph for RAG

RAG, short for retrieval-augmented generation, means fetching relevant documents and giving them to the model before it answers. The RAG guide in LangChain's docs now builds it with Deep Agents, using retrieval tools and subagents rather than a fixed chain. LangGraph has a tutorial, [Build a custom RAG agent with LangGraph](https://docs.langchain.com/oss/python/langgraph/agentic-rag), for an agent that decides whether to search a vector store or answer directly. The docs say LangChain's built-in agents are enough for many cases and to build the agent directly in LangGraph when you need more customization.

One catch: the old LangChain retriever classes are in `langchain-classic` now, so a RAG app built on those classes needs that package or a rewrite.

## The third option: Deep Agents

LangChain's docs now steer many users to a third package before either of the other two. Deep Agents is what they call an agent harness: planning with a to-do list, subagents, a virtual file system and automatic context management, built on LangChain agents and LangGraph. The docs pitch it for long, multi-step tasks that need planning. If you would otherwise write those pieces yourself on top of LangGraph, check Deep Agents first.

## What it costs: free code, paid LangSmith

LangChain, LangGraph and Deep Agents are free and MIT-licensed. You pay your model provider, and you pay LangChain only if you use LangSmith, its hosted platform for tracing, evaluation and deployment. It works with agents from any framework.

Prices from the [LangSmith pricing page](https://www.langchain.com/pricing), as of November 19, 2026:

| Plan | Price | Traces included | Deployment |
| --- | --- | --- | --- |
| Developer | $0, one seat | 5,000 base traces a month, then pay as you go | Not included |
| Plus | $39 per seat a month, unlimited seats | 10,000 base traces a month, then pay as you go | One small serverless Agent Server free, more billed by usage |
| Enterprise | Custom | Custom | Self-hosted and hybrid options |

A trace is one run of your app, with every model and tool call inside it. Base traces are kept for 14 days and extended traces for 180 days. Extra Agent Servers, the hosted service for running LangGraph agents, are billed in LangChain Standard Units (LSUs) at $1 each. Runtime compute costs 0.0675 LSU per vCPU-hour and memory 0.0090 LSU per GiB-hour, with separate rates for the database. The pricing page does not list a per-trace price beyond the included allowance. VC-backed startups can get up to $10,000 in credits.

The page does not use the name "LangGraph Platform." Hosting for LangGraph agents is sold as LangSmith Agent Server.

## The company behind both

LangChain the company makes all of these. It raised $300 million at a $3 billion valuation on November 13, 2026, in a round led by CapitalG ([our report on the Series C](https://claudegpt.si/news/langchain-series-c-3b-valuation)), and says more than 7,000 organizations use LangSmith. The open-source libraries bring developers in, and LangSmith is how the company makes money. That is worth knowing when the docs recommend a managed product, but the libraries themselves run anywhere with no account.

## Frequently asked questions

### What is the difference between LangChain and LangGraph?

LangChain is a high-level agent framework built around create_agent, model integrations and middleware. LangGraph is the lower-level runtime underneath it, where you design the workflow as a graph of state, nodes and edges with checkpointing and human-in-the-loop pauses.

### Should I use LangChain or LangGraph for agents?

LangChain's docs say to start with create_agent for straightforward tool-calling agents. Use LangGraph when you need explicit control over state and control flow, long-running durable execution, or a mix of fixed and model-driven steps.

### Are LangChain and LangGraph free and open source?

Yes. Both are open source under the MIT license and free to use. LangChain charges only for LangSmith, its hosted tracing, evaluation and deployment platform.

### Can I use LangGraph without LangChain?

Yes. LangGraph's docs say it does not require LangChain, though it installs the small langchain-core package of shared types. You can call any model SDK inside a LangGraph node.

## Sources

- [Runtimes, frameworks, and harnesses](https://docs.langchain.com/oss/python/concepts/products), LangChain
- [LangChain overview](https://docs.langchain.com/oss/python/langchain/overview), LangChain
- [LangGraph overview](https://docs.langchain.com/oss/python/langgraph/overview), LangChain
- [What's new in LangChain v1](https://docs.langchain.com/oss/python/releases/langchain-v1), LangChain
- [What's new in LangGraph v1](https://docs.langchain.com/oss/python/releases/langgraph-v1), LangChain
- [Build a custom RAG agent with LangGraph](https://docs.langchain.com/oss/python/langgraph/agentic-rag), LangChain
- [LangSmith plans and pricing](https://www.langchain.com/pricing), LangChain
- [langchain-ai/langchain](https://github.com/langchain-ai/langchain), GitHub
- [langchain-ai/langgraph](https://github.com/langchain-ai/langgraph), GitHub
- [langchain on PyPI](https://pypi.org/project/langchain/), PyPI
- [langgraph on PyPI](https://pypi.org/project/langgraph/), PyPI
- [Announcing our Series C](https://www.langchain.com/blog/series-c), LangChain
