LangChain vs LangGraph: $0 Core, $39 Plus [2026]

The langchain vs langgraph question has a different answer in November 2026 than it did a year ago. LangChain’s standard create_agent API is now built on LangGraph, which means you no longer choose one library over the other. You choose which layer you write your code against, according to a November 3 comparison from Garage Labs Tech that matches LangChain’s own positioning.

That shift lands on a tight calendar. LangChain 0.3 and LangGraph 0.4 sit in maintenance mode through December 2026, so teams still on the old lines have roughly eight weeks to move. LangSmith, the paid platform around both frameworks, also moved self-serve customers onto new usage-based plans in October 2026.

Short version: start with LangChain’s create_agent for a standard tool-calling agent, and drop to LangGraph’s graph APIs when you need explicit control over state, branching, s for human approval, or multi-agent hand-offs. Teams following the wider AI and machine learning landscape will recognize the pattern, because agent tooling is converging on a thin high-level API sitting over a lower-level runtime. The specs, pricing math, migration path and verdict follow.

Don't miss new tech stories on Google

Add Shattered once in the Google app and our stories show up in your news suggestions.

Add now

LangChain vs LangGraph: Specs Side by Side #

The table below uses details that LangChain documents or that at least two pages confirmed on November 6, 2026. Where the sources left a field open, the cell says so instead of guessing. Both projects belong to LangChain, Inc., which remains an independent company with no confirmed acquisition or rename.

Feature	LangChain v1	LangGraph v1
Official role	Agent framework	Agent runtime
Abstraction level	High level, one call builds a working agent	Lower level, you define nodes, edges and state
Standard entry point	create_agent	Core graph APIs (kept intact in v1)
Dependency direction	create_agent is built on LangGraph	Powers LangChain’s agent loop
Control flow	Standard agent loop	Complex control flows, multi-agent orchestration, human-in-the-loop
State and durability	Inherited from LangGraph	Stateful, durable agent workflows
License	MIT	MIT
Software cost	$0	$0
Legacy line status	0.3 in maintenance through December 2026	0.4 in maintenance through December 2026
Release cadence (policy)	Majors every 6 to 12 months, minors every 1 to 2 months, patches weekly as needed	Same policy
v1 support after a 2.0 release	Not confirmed by two sources	Maintenance for at least one year
Streaming direction	Typed agent events (messages, tool calls, subagent status)	Same direction, unified v2 stream format needs LangGraph 1.1 or later
MCP support	FastMCP via langchain.mcp in v1.4.0	Not listed separately
Hosting path	Deploys to LangSmith Deployment	LangSmith Deployment (Agent Server) targets LangGraph agents
Local development billing	Not applicable	langgraph dev runs no longer report usage or bill at the self-hosted rate

Two rows deserve a second look. The dependency direction row explains why the usual “pick one” framing misleads: if you call create_agent, you already run LangGraph underneath. The cost row confirms that neither framework carries a license fee, since LangChain describes LangChain, LangGraph and Deep Agents as MIT-licensed open-source frameworks.

The release cadence row matters for planning. Because minors arrive every one to two months and patches often land weekly, pinning exact versions in production is not optional. A floating dependency on langchain-core can pull a streaming change into your server before your clients are ready, a problem we cover in the migration section.

One gap is worth flagging. Our sources do not confirm a separate support window for LangChain 1.0 after a 2.0 release on two independent pages, so we left that cell open. A single-source report says LangChain 1.0 and LangGraph 1.0 are both designated long-term-support lines until their 2.0 releases, which would match the one-year maintenance promise on the LangGraph side. No 2.0 date has surfaced.

What Changed in the v1 Line #

LangGraph 1.0 reached general availability on October 22, 2025, according to a LangChain resource page. A year later, the v1 documentation describes it as a stability-focused release that keeps the core graph APIs and execution model while improving type safety, documentation and developer ergonomics. That wording signals a runtime LangChain wants teams to build on for years, not one it plans to reshape every quarter.

The more visible change sits one layer up. LangChain v1 introduced create_agent as the standard way to build agents, and it replaces langgraph.prebuilt.create_react_agent as the recommended path. LangChain’s own materials call v1 a “production-ready foundation” centered on that function. The old prebuilt is deprecated, not retired, so existing code keeps running while the docs steer new projects elsewhere.

Fall 2026 brought a steady stream of smaller releases on top of that base. LangChain v1.4.0, highlighted in the October 2026 newsletter, added FastMCP support through the langchain.mcp namespace. The langchain-core package shipped v1.7.0 on October 22, 2026 with incremental tool-call-delta streaming events, replacing the old pattern of repeatedly sending accumulated tool-call arguments.

Version trackers report newer point releases. One tracker lists LangGraph 1.2.0 on October 14, 2026, with finer node execution controls such as timeouts, error recovery and graceful shutdown, plus a beta DeltaChannel that reduces checkpoint overhead. The same tracker lists LangGraph 1.2.19 on October 30, 2026, with fixes to tracing, event namespaces and tool-node streaming. Treat those numbers as reported, because LangChain’s official pages in our sources did not confirm them.

The legacy lines are the real deadline. LangChain 0.3 and LangGraph 0.4 stay in maintenance through December 2026. If your repository still imports from those versions, plan the upgrade now, because the support clock runs out just as most teams enter year-end change freezes.

Nothing in the November 2026 sources shows a rename, retirement or acquisition of LangChain, LangGraph or LangSmith. The confirmed changes concern positioning (LangChain as the easy on-ramp, LangGraph as the runtime) and billing, not product survival. That distinction matters if you read older blog posts that treat the two libraries as competitors.

How create_agent Sits on LangGraph #

Think of the stack in three layers. At the bottom, LangGraph handles state, persistence and execution of a graph. In the middle, LangChain’s create_agent assembles a standard loop where a model decides, calls tools, reads results and repeats. At the top, your product code sets prompts, tools and guardrails. Because the middle layer compiles down to a graph, you can inspect or extend the result with LangGraph primitives.

The Default Path: One Function, One Loop

For most agents the default path covers the job. You hand create_agent a model, a list of tools and a system prompt, and you get a runnable agent. The loop, message handling and tool dispatch come prebuilt. This is the “easier high-level agent API” LangChain describes, and it removes the boilerplate that made early LangChain agents feel heavy.

from langchain.agents import create_agent
from langchain.tools import tool

@tool
def lookup_order(order_id: str) -> str:
    """Return the status of an order."""
    return f"Order {order_id}: shipped"

agent = create_agent(
    model="your-provider:your-model",
    tools=[lookup_order],
    system_prompt="You are a support agent. Use tools before answering.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Where is order 1042?"}]}
)
print(result["messages"][-1].content)

The Escape Hatch: Write the Graph Yourself

Some workflows do not fit a single loop. A refund flow might require a model draft, a policy check, a human approval step that can wait hours, and a payment call that must never run twice. LangGraph lets you model each step as a node, wire the edges, and attach a checkpointer so the run survives restarts. The -and-resume pattern below uses LangGraph’s interrupt primitive.

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command

class RefundState(TypedDict):
    amount: float
    approved: bool

def review(state: RefundState):
    answer = interrupt({"question": "Approve refund?", "amount": state["amount"]})
    return {"approved": answer == "yes"}

def pay(state: RefundState):
    return {"approved": state["approved"]}

builder = StateGraph(RefundState)
builder.add_node("review", review)
builder.add_node("pay", pay)
builder.add_edge(START, "review")
builder.add_edge("review", "pay")
builder.add_edge("pay", END)

graph = builder.compile(checkpointer=InMemorySaver())
cfg = {"configurable": {"thread_id": "refund-1"}}

graph.invoke({"amount": 80.0, "approved": False}, cfg)   # s at review
graph.invoke(Command(resume="yes"), cfg)                  # resumes later

Swap InMemorySaver for a database-backed checkpointer in production, otherwise a process restart loses the d run. The point of the sketch is the shape: explicit state, explicit edges, and a that costs nothing while it waits. A prebuilt loop cannot express that cleanly.

What LangChain’s CEO Says About the Split #

The clearest explanation of the split comes from LangChain’s co-founder and CEO, Harrison Chase, who has written about it on the company blog. Keep in mind that he speaks for the vendor, so read these statements as the intended design rather than as independent testing. Still, they show why the two libraries now coexist.

In a retrospective on the project’s first three years, Chase wrote: “While langchain was the fastest place to get started, we traded power for ease of use.” In the same post he added: “LangGraph was inspired by the limitations of the initial langchain.” Read together, those lines admit that early LangChain hid too much, and that LangGraph exists to hand control back.

He repeated the contrast in a post on agent frameworks and observability, where he wrote: “langgraph was lower level and more flexible.” That sentence maps directly onto the specs table. Flexibility lives in LangGraph, and convenience lives in LangChain.

The most useful framing appears in a post separating frameworks, runtimes and harnesses. Chase wrote: “LangChain is an agent framework, LangGraph is an agent runtime, DeepAgents is an agent harness.” He then explained how the pieces connect: “Agent runtimes are generally lower level than agent frameworks and can power agent frameworks.” That is exactly the arrangement in v1, where the framework’s agent function rides on the runtime.

What should you take from this? First, the maintainers do not see the libraries as substitutes. Second, the three-way vocabulary (framework, runtime, harness) tells you where to look when something breaks: a tool-calling bug usually lives in your framework layer, while a lost checkpoint or a stuck lives in the runtime. Third, the vendor’s own admission about trading power for ease explains why many older tutorials push you toward LangGraph for anything non-trivial.

A caution on currency. Chase’s posts describe design intent, and the product names and version lines have moved since he wrote them. Use his terminology, but check the v1 documentation for current function names and signatures before you copy any code from older write-ups.

Benchmarks and Measured Outcomes: What the Numbers Show #

No independent head-to-head latency or accuracy benchmark of LangChain against LangGraph appeared in the sources we checked. That absence is informative. Since create_agent compiles to a LangGraph graph, the two entry points share an execution engine, so any gap you measure will mostly reflect your own prompts, tools and model, not the library. That is an inference, and the harness further down lets you test it on your workload.

What the sources do contain are published outcome figures from three customers, plus one platform change. All of them come from LangChain-hosted case studies or changelogs, so they carry vendor selection bias. They measure results of building with the stack (mostly with LangSmith for tracing and evaluation), not a speed contest between the two frameworks.

Source	Reported figure	What it measures	Caveat
Klarna case study	80% shorter case resolution time	Support case handling with an AI assistant monitored in LangSmith	Vendor-published, tied to LangSmith
Podium case study	90% fewer engineering escalations	Engineering load after adopting LangSmith	Vendor-published, tied to LangSmith
Snyk Assist story	85%+ of sessions resolved without a support ticket	Share of customer sessions the agent closed on its own since the April 2026 launch	Built with LangChain and LangGraph, vendor-hosted story
LangSmith changelog, Oct 26 to Nov 2, 2026	40% lower Engine usage cost	Platform price cut for Engine runs	Applies to the paid platform, not the open-source frameworks

Read the table for direction, not precision. Klarna’s 80% and Podium’s 90% describe business outcomes that depend on the company, the task and the baseline. Snyk’s 85% comes closest to a framework-level result, since Snyk built its assistant on both libraries, but it still reflects Snyk’s support content and users. None of the three tells you whether LangChain or LangGraph made the difference.

Run your own comparison instead. The harness below times the same prompts through a create_agent agent and through a hand-built graph, then reports median and 95th percentile latency. Use a fixed model, fixed temperature and a recorded set of 30 to 50 real prompts. Run each variant at least 20 times per prompt, because model latency varies more than framework overhead does.

import statistics
import time

def bench(app, prompts, runs=20):
    samples = []
    for prompt in prompts:
        for _ in range(runs):
            start = time.perf_counter()
            app.invoke({"messages": [{"role": "user", "content": prompt}]})
            samples.append(time.perf_counter() - start)
    samples.sort()
    return {
        "median_s": round(statistics.median(samples), 3),
        "p95_s": round(samples[int(len(samples) * 0.95) - 1], 3),
        "n": len(samples),
    }

print("create_agent:", bench(agent, PROMPTS))
print("custom graph:", bench(graph_app, PROMPTS))

If the two medians land within a few percent of each other, you have your answer: choose on maintainability and control, not speed. If the custom graph is meaningfully slower, look at your checkpointer and state size before blaming the library. Reduced checkpoint overhead was one of the stated goals of the reported LangGraph 1.2 work, so state size is a sensible first suspect.

Pricing: Free Frameworks, Metered Platform #

The frameworks cost nothing. LangChain and LangGraph are MIT-licensed, so you pay only for models, hosting and any infrastructure you run yourself. LangChain’s money comes from LangSmith, the platform for observability, evaluation, deployment and agent operations. That is where a langchain vs langgraph budget discussion actually lives.

LangSmith moved self-serve customers to October 2026 plans billed in LangChain Standard Units (LSUs), where 1 LSU equals $1. Customers with contracts, credit grants or negotiated adjustments stay on their existing terms, and startup-program customers on Plus moved to new Startup plans while keeping their current term. Evals Review’s November 2026 pricing breakdown tracks the same structure.

Item	Price or rate	What you get
LangChain framework	$0	MIT-licensed open source
LangGraph framework	$0	MIT-licensed open source
LangSmith Developer	$0 per seat per month	1 seat, 5,000 included base traces per month
LangSmith Plus	$39 per seat per month	10,000 included traces total, up to 3 workspaces, unlimited seats at $39 each
Extra Plus traces	0.005 LSU per trace ($0.005)	Overage beyond the included allowance
LangSmith Enterprise	Custom, contact sales	Unlimited users, 1 production and 1 development instance, usage billed separately
Enterprise and self-hosted traces	0.0075 LSU per trace ($0.0075)	Flat rate unless a contract says otherwise
Evaluation run (Perceived Error)	0.015 LSU per run	Metered evaluation usage
Bulk Export	0.25 LSU per GiB exported	Data export from LangSmith
Startup credits	Up to $10,000	For VC-backed startups, discounted rates and credits

The pricing page also lists metered rates under runtime and database headings: 0.0675 LSU per vCPU-hour and 0.0090 LSU per GiB-hour for runtime compute and memory, plus 0.177 LSU per vCPU-hour and 0.025 LSU per GiB-hour for the database. At $1 per LSU, those rates convert directly into dollar costs, but confirm which deployment tier they apply to before you budget.

LangChain estimates that typical LangSmith Engine usage runs 1,000 to 2,500 LSUs per month, which translates to roughly $1,000 to $2,500 at list rates, depending on trace volume and complexity. A November 5 changelog entry says Engine usage now consumes 40% fewer usage credits. Local runs with langgraph dev no longer report usage, so prototyping does not inflate your bill.

For a small team, the practical read is simple. You can build, test and ship either framework for $0 in license fees, add the free Developer tier for tracing, and move to Plus at $39 per seat once you need more than 5,000 traces a month or more than one seat. Enterprise only enters the picture when you want self-hosting, bring-your-own-cloud or negotiated usage.

State, Durability and Human-in-the-Loop #

LangGraph’s reason to exist is stateful, durable execution. LangChain’s documentation positions it for long-running agents, complex control flows, multi-agent orchestration and human-in-the-loop steps. When a run can take minutes or days, or when it must for a person, the runtime layer stops being an implementation detail and becomes the product.

Consider what durability buys. A checkpointer stores state after each step, so a crashed worker resumes from the last good node instead of replaying an entire conversation and re-calling paid tools. A at an approval node holds state without holding a process open. And because the graph is explicit, you can inspect which node ran, which edge fired and where a failure occurred.

The plain create_agent loop inherits much of this through its LangGraph base, but you shape it less. If you only need a model that calls tools until it finishes, the default behavior is fine. If you need a rule like “never call the payment tool twice” or “route legal questions to a different branch,” encoding that in graph structure is safer than encoding it in a prompt.

Operational detail shows how closely the community watches production behavior. LangChain’s forum carries a thread about a bug affecting thread-history and state-update requests on factory graphs in langgraph-api, reported in October and described as fixed in versions 0.16.7 and later. Another thread, dated October 31, 2026, asks whether a checkpointer that accepts two concurrent writers should still score the top conformance level. Those are community-forum items, not formal announcements, but they show active scrutiny of persistence correctness.

Deployment follows the same logic. LangSmith Deployment, also called the Agent Server path, is infrastructure for LangGraph agents, and the LangGraph CLI builds and runs that server locally. The CLI documentation required langgraph-cli 0.4.32 or later in late October 2026. On November 3, 2026, LangSmith made bring-your-own-cloud deployment generally available on AWS, with Azure and Google Cloud in beta, which matters for teams that cannot send agent traffic outside their own accounts.

If durability and approvals are central to your product, a regulated workflow for example, start from LangGraph directly. You will write more code, yet every state transition becomes visible and testable. If durability is a nice-to-have, start with create_agent and add graph structure only when a real failure forces the issue.

Streaming, MCP and Tooling Updates This Fall #

Streaming changed more than any other area in the last two months. LangChain’s November 5 post argues that agent streaming should move from raw token chunks toward application-level events, covering messages, tool calls and subagent status, and it says the work spans LangChain, LangGraph and Deep Agents. For a chat interface, that means your front end subscribes to meaningful events rather than parsing partial strings.

The change has a compatibility cost. LangChain’s guidance says that to read the new incremental tool-call streaming, you should upgrade langchain-core on the server to 1.7.0 or later together with langchain 1.4.7 or later. On the client side, Python users need langchain-core 1.6.13 or later because langgraph-sdk uses it to read the stream. JavaScript users should upgrade @langchain/react, @langchain/vue, @langchain/svelte or @langchain/angular to 1.2.6 or later.

There is a safe rollout trick. Because langchain and deepagents accept any langchain-core 1.x, upgrading either package can drag the core to 1.7.0 without you asking. To hold a server back until every client has upgraded, LangChain recommends pinning langchain-core<1.7.0. Teams that skip this step risk a server that emits events older clients cannot read.

langchain>=1.4.0
langchain-core>=1.6.13,<1.7.0

MCP support arrived in the high-level layer. LangChain v1.4.0 added FastMCP support under langchain.mcp, so tools exposed by Model Context Protocol servers can plug into an agent without custom glue. LangGraph users reach the same tools by wiring them into nodes, which is more work but gives you exact control over when and how each call runs.

LangSmith added its own pieces. It launched Custom Apps for Plus and Enterprise, letting teams build interfaces inside the platform. A November 2 changelog entry says LangSmith now records token usage and derived costs automatically for major model providers, while letting you attach custom cost data for tools and retrieval. Reportedly, Engine v2 and Managed Deep Agents were announced as well, though that comes from a single announcement.

Observability and Evaluation: Where LangSmith Fits #

Whichever framework you pick, you will want to see what the agent did. Agents fail in ways unit tests miss: a tool called with the wrong argument, a retrieval step that returned stale text, a loop that burned through tokens before giving up. LangSmith exists to capture those runs as traces, score them with evaluations and feed the failures back into your prompts and graphs.

LangChain lists the current commercial product names on its enterprise pricing page, dated November 2, 2026: Observability and Evaluations, Deployment, Deployment (Self-Hosted), Engine, Fleet, Sandboxes, Tuned Evals and Bulk Export. The first is the entry point for most teams. It records each model call, tool call and graph step, then lets you filter by failure, latency or cost.

Cost tracking got a meaningful upgrade in the first days of November. LangSmith began automatically recording token usage and derived costs for major model providers, and it lets you add custom cost data for tools, retrieval and other operations. The model-pricing page gained provider filtering and start-date sorting, with your selections preserved in the page URL. Teams that bill internal customers for agent usage will appreciate that detail.

The framework choice changes what you see in a trace. With create_agent, a trace looks like a loop: model call, tool call, model call. With a hand-built graph, a trace follows your node names, so a failure reads “review node, approval timed out” instead of “model call 4.” That naming discipline pays off when a support engineer, not the original author, debugs the run at 2 a.m.

Evaluation deserves the same attention as tracing. The Numan example below describes an eval-first approach, meaning the team defined how it would judge the agent before shipping. You can do the same with either framework. Record 30 to 50 representative conversations, define pass and fail criteria, run them on every change, and block deploys that regress. At the metered rate of 0.015 LSU per evaluation run, a 50-prompt suite costs about $0.75 per full pass at list price.

Support is a separate line item. LangChain’s support page lists Base, Standard and Premium support plans for LangSmith, though the page text we retrieved does not show their prices. The same page says enterprise customers can receive support for LangChain, LangGraph and Deep Agents open-source issues, which matters if your legal team wants a named vendor behind the libraries your product depends on.

Finally, remember that tracing is optional. Both frameworks run without LangSmith, and you can send traces to other tools or log them yourself. The trade is convenience against independence. For a team of three shipping a first agent, the free Developer tier removes friction. For a regulated company, self-hosting or bring-your-own-cloud on Enterprise may be the only acceptable route, and AWS bring-your-own-cloud has been generally available since November 3, 2026.

Real-World Deployments: Six Examples #

Case studies cannot settle a framework debate, but they show what production use looks like. These six examples come from LangChain’s own pages and the October 2026 newsletter, so treat them as vendor-selected. Where a result belongs to LangSmith rather than to the open-source libraries, we say so.

1. Klarna. Klarna’s AI assistant cut case resolution time by 80%, according to a LangChain case study that credits LangSmith for monitoring and evaluation. The figure speaks to the platform, not to a specific framework choice.
2. Podium. Podium reduced engineering escalations by 90% with LangSmith, again a platform result. It shows why many teams adopt tracing first and pick frameworks second.
3. Snyk Assist. Snyk built an internal support agent on LangChain and LangGraph with LangSmith for observability, released it to customers in April 2026, and in September 2026 moved it into the core Snyk product for every paying customer. More than 85% of sessions resolved without a support ticket, which saved the support team hundreds of hours.
4. Numan. The health-coaching company Numan described LangGraph and LangSmith together as its agent-development stack, in an October 19, 2026 post about building an eval-first AI health coach. The emphasis on evaluation before launch fits LangGraph’s explicit-state style.
5. Jev orchestration. The October 2026 newsletter highlighted production agents built with Jev and LangGraph, including orchestration of Jev’s decision model. Decision models that return structured choices suit graph nodes well.
6. NVIDIA integration. On March 16, 2026, LangChain announced an enterprise agentic AI platform integration with NVIDIA, covering LangSmith, LangGraph, LangChain, Deep Agents, the NVIDIA Agent Toolkit, Nemotron, NeMo Agent Toolkit, NIM and Dynamo. The announcement names Sequoia Capital, Benchmark and IVP as LangChain’s backers.

The pattern across these examples is consistent. Nobody ships on a single library. They combine a high-level agent API, a graph runtime where control matters, and a tracing and evaluation layer. Snyk’s path is the instructive one: a support bot started as an internal tool, proved itself in April 2026, and became a customer feature five months later, a lifecycle where evals and persistence matter more than raw speed.

Which Should You Pick? Seven Use-Case Recommendations #

Answer these by workload, not by loyalty. The recommendations assume the v1 line on both libraries, and they follow from the specs above rather than from a benchmark.

Use case	Start with	Why
Internal Q&A bot with a handful of tools	LangChain create_agent	One function gives a working loop, and you can drop down later
Customer support agent with refunds or account changes	LangGraph	Approval steps, idempotent payment nodes and resumable state
Multi-agent research pipeline	LangGraph	Explicit hand-offs and shared state between agents
Quick prototype or hackathon demo	LangChain create_agent	Fastest route from idea to running agent
Regulated workflow needing audit trails	LangGraph plus LangSmith	Every node and transition is inspectable
Agent that uses many MCP servers	LangChain with langchain.mcp	FastMCP support arrived in v1.4.0
Long-running background job (hours or days)	LangGraph with a durable checkpointer	Survives restarts and holds d runs cheaply

A few notes on edge cases. If your team is new to agents, resist the urge to hand-build a graph on day one. The extra structure helps only when you already know where your flow branches, and guessing wrong costs you refactoring time. Build the default loop, log traces, and let real failures tell you which node deserves its own step.

If your team is experienced and the product has hard safety rules, flip that advice. Write the graph first, encode the rules as edges and checks, and use the prebuilt loop only for sub-steps that are genuinely open-ended. Safety rules held in graph structure survive prompt changes, model swaps and the next engineer’s well-meaning edit.

Teams running local models should note that both frameworks are model-agnostic in practice, so the choice does not tie you to a hosted provider. Pair either one with a local runtime if data cannot leave your network, and keep the tracing layer in mind, since LangSmith offers self-hosted and bring-your-own-cloud options on Enterprise.

Migration Guide: From 0.3, 0.4 and create_react_agent to v1 #

Moving to the v1 line takes less effort than the version jump suggests, because LangGraph v1 kept its core graph APIs and execution model. The main code change for most agents is swapping the deprecated prebuilt for create_agent. Budget a day for a small service and a week for a fleet with shared tooling. Start now, since the legacy lines stay in maintenance only through December 2026.

1. Inventory versions. Runpip list | grep -i lang in every service and record thelangchain ,langchain-core ,langgraph andlanggraph-cli versions. Flag anything on LangChain 0.3 or LangGraph 0.4.
2. Create a branch and upgrade. Install v1 packages in a clean environment and run your existing tests before touching code. Failures at this stage show real incompatibilities.
3. Replace the prebuilt agent. Change imports and the call, then confirm the prompt argument name against the v1 docs.
4. Align client and server versions. Use the pinning pattern from the streaming section so servers and clients upgrade in the right order.
5. Re-run evaluations. Compare traces before and after on a fixed prompt set. If you use LangSmith, the free Developer tier covers 5,000 base traces a month.
6. Check your CLI. If you deploy through LangSmith, make surelanggraph-cli is 0.4.32 or later, as the deployment documentation required in late October 2026.
7. Cut over and watch. Roll out behind a flag, compare cost and latency for a week, then remove the old code path before the December 2026 maintenance cliff.

from langgraph.prebuilt import create_react_agent
agent = create_react_agent(model, tools, prompt="You are a support agent.")

from langchain.agents import create_agent
agent = create_agent(model, tools=tools, system_prompt="You are a support agent.")

Two pitfalls come up often. First, mixing a v1 server with old clients breaks streaming if the core package moves ahead of the client libraries. Second, teams sometimes rewrite a working custom graph into create_agent because the docs now recommend it. Do not do that. The deprecation covers the prebuilt, not the graph APIs, and a hand-built graph that works is not technical debt.

Finally, watch billing during the move. Self-serve LangSmith customers shifted to October 2026 plans, so a trace-heavy test run can consume your included allowance faster than you expect. Check your plan page before running large evaluation sweeps, and keep local experiments on langgraph dev, which no longer reports usage.

Pros and Cons of Each Approach #

Both libraries share the same strengths in ecosystem and license. The differences show up in control, learning curve and operating cost. Here is where each layer earns its keep and where it costs you.

LangChain create_agent: pros

• Fastest path from idea to a running tool-calling agent
• Runs on LangGraph, so persistence and streaming come along
• FastMCP support in v1.4.0 simplifies tool wiring
• MIT license and $0 software cost
• Clear upgrade path: you can inspect and extend the underlying graph later

LangChain create_agent: cons

• Less control over branching and step order than a hand-built graph
• Safety rules often end up in prompts, which are easier to break
• Older tutorials describe pre-v1 patterns that no longer match the docs
• Fast release cadence demands version pinning

LangGraph: pros

• Explicit state, nodes and edges make behavior testable
• Durable execution, s and human approval are first-class
• Stable v1 runtime with core graph APIs preserved
• At least one year of maintenance promised for v1 after a 2.0 release
• Suits multi-agent hand-offs and long-running jobs

LangGraph: cons

• More code and a steeper learning curve for simple agents
• Production persistence needs a real checkpointer and operational care
• Easy to over-engineer a flow that a single loop would handle
• Hosted deployment pulls you toward the paid LangSmith platform

The cons are mostly mirror images. LangChain’s convenience costs control, and LangGraph’s control costs code. Since one is built on the other, you rarely have to commit permanently. That flexibility is the strongest argument for starting at the top layer and descending only when the workload demands it.

Alternatives and Where Deep Agents Fits #

LangChain now describes a third open-source piece, Deep Agents, as an agent harness. In Chase’s vocabulary, a harness packages opinionated defaults for long-horizon work on top of the runtime. Deep Agents is MIT-licensed like its siblings and appears in LangChain’s streaming and enterprise materials, and a managed version (Managed Deep Agents v0.8) reportedly added user-owned credentials, user-level memory and HTTP channels in September 2026.

That makes the practical menu three-deep rather than two. Use create_agent for a standard tool-calling agent, LangGraph for explicit control, and Deep Agents when you want a prebuilt harness for longer tasks. LangChain’s own enterprise page lists the commercial products around them: Observability and Evaluations, Deployment, Deployment (Self-Hosted), Engine, Fleet, Sandboxes, Tuned Evals and Bulk Export.

Outside the LangChain family, the field has shifted too. LangChain published a June 23, 2026 page titled “LangChain vs. AutoGen in 2026: What the Maintenance Announcement Changed,” which signals that the AutoGen project entered a maintenance posture. Because that page comes from a competitor’s vendor, verify the status on AutoGen’s own repository before you decide. Provider SDKs and cloud agent services from the major clouds offer other routes, though each brings its own lock-in.

Weigh lock-in honestly. The open-source frameworks are portable, but the smoother tracing, evaluation and deployment path runs through LangSmith. That is a reasonable commercial model, and it is also a dependency. If you want to avoid it, keep your graph logic free of platform-specific calls and route traces through an open standard where possible.

One more factor is team skill. A graph runtime rewards engineers who think in state machines, while a high-level agent API rewards engineers who think in prompts and tools. Hire or train for the layer your product needs, and avoid forcing a prompt-first team to maintain a forty-node graph they did not design.

Verdict: Use create_agent First, Reach for LangGraph on Purpose #

The takeaway: treat langgraph vs langchain as a layering decision, not a rivalry. Both are free under the MIT license, both sit on the same runtime in the v1 line, and both follow the same release policy. The paid part of the stack is LangSmith, which starts at $0 for one seat and 5,000 base traces, then costs $39 per seat for Plus.

Our recommendation rests on data, not hype. Choose create_agent when your agent loops over tools and you can describe its rules in a prompt. Choose LangGraph when you need approvals, resumable state, strict step order or multi-agent coordination. Choose both when you build a product that grows, because you will start with the first and add the second where failures cluster.

Three dates should drive your schedule. LangChain 0.3 and LangGraph 0.4 lose active support after December 2026. The streaming upgrade to langchain-core 1.7.0 already shipped on October 22, 2026, so mismatched clients are a live risk. And LangSmith’s October 2026 plans are in effect now, so review your trace volume before your next bill.

What we could not verify matters too. No independent benchmark separates the two entry points on speed or accuracy, the customer figures come from vendor pages, and several newer version numbers rest on a single tracker. Run the harness on your own prompts before you commit a roadmap to either layer. If the medians match, and we expect they will, spend your attention on evals, pinning and approval design instead.

FAQ: LangChain vs LangGraph #

Is LangGraph replacing LangChain?

No. LangChain v1’s create_agent is built on LangGraph, so the two libraries work together. LangChain is the higher-level agent framework and LangGraph is the lower-level runtime. Nothing in the November 2026 sources shows either project being retired, renamed or acquired.

Can I use LangGraph without LangChain?

Yes, you can build graphs with LangGraph’s own APIs, and many production flows do exactly that. In practice most teams still install LangChain packages for model integrations and tools, but the graph APIs do not require you to use create_agent.

Are LangChain and LangGraph free?

Both frameworks are MIT-licensed open source with no license fee. You pay for model usage and hosting. LangSmith, the observability and deployment platform, has a $0 Developer tier with one seat and 5,000 base traces per month, and Plus costs $39 per seat per month.

What is the difference between create_react_agent and create_agent?

create_react_agent was LangGraph’s prebuilt agent. LangChain v1’s create_agent replaces it as the recommended standard, and the prebuilt is deprecated rather than removed. Existing code keeps working, but new projects should use create_agent.

Which version should I run today?

Run the v1 line of both. LangChain 0.3 and LangGraph 0.4 are in maintenance through December 2026. The release policy expects minors every one to two months and patches often weekly, so pin exact versions and upgrade clients before servers when streaming changes land.

Does LangGraph support human approval steps?

Yes. LangChain positions LangGraph for human-in-the-loop execution, and the interrupt primitive with a checkpointer lets a run and resume later. Use a durable checkpointer in production so a restart does not lose the d state.

Is there a performance benchmark comparing the two?

We found no independent head-to-head benchmark. Since create_agent runs on LangGraph, large speed differences are unlikely, and model latency usually dominates. Measure your own prompts with a fixed model and at least 20 runs per prompt before drawing conclusions.

What does LangSmith cost for a small team?

A team can start at $0 on the Developer tier. Plus runs $39 per seat per month with 10,000 included traces and up to three workspaces, and extra traces cost 0.005 LSU each, where 1 LSU equals $1. Enterprise pricing is custom. Check current release news for plan changes, since LangSmith repriced self-serve plans in October 2026.

source & further reading

shattered.io — original article Post-Quantum Firmware Signing: 5 Schemes Ranked [2026] Intel Runs 816B Muse Spark Open on 4 GPUs [2026] $11.4M of Nvidia Hardware Vanishes in Transit [2026]