{"slug": "langchain-vs-langgraph-0-core-39-plus-2026", "title": "LangChain vs LangGraph: $0 Core, $39 Plus [2026]", "summary": "LangChain's standard create_agent API is now built on LangGraph, so developers no longer choose between the two libraries but instead pick which layer to write against, according to a November 3 comparison from Garage Labs Tech. Both frameworks are MIT-licensed at $0 software cost, while LangSmith self-serve customers moved to new usage-based plans in October 2026, and LangChain 0.3 and LangGraph 0.4 sit in maintenance mode through December 2026, giving teams on the old lines roughly eight weeks to migrate. LangChain v1.4.0 adds FastMCP support via langchain.mcp, and LangGraph's unified v2 stream format requires LangGraph 1.1 or later.", "body_md": "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](https://www.garagelabstech.com/blog/langchain-vs-langgraph-vs-langsmith) that matches LangChain’s own positioning.\n\nThat 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.\n\nShort 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, pauses for human approval, or multi-agent hand-offs. Teams following the wider [AI and machine learning landscape](https://shattered.io/category/ai-machine-learning/) 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.\n\nDon't miss new tech stories on Google\n\nAdd Shattered once in the Google app and our stories show up in your news suggestions.\n\n[Add now](https://www.google.com/preferences/source?hl=en&q=https%3A%2F%2Fshattered.io%2F)\n\n## LangChain vs LangGraph: Specs Side by Side\n\nThe 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.\n\n| Feature | LangChain v1 | LangGraph v1 | \n|---|---|---|\n| Official role | Agent framework | Agent runtime | \n| Abstraction level | High level, one call builds a working agent | Lower level, you define nodes, edges and state | \n| Standard entry point | `create_agent` | Core graph APIs (kept intact in v1) | \n| Dependency direction | `create_agent` is built on LangGraph | Powers LangChain’s agent loop | \n| Control flow | Standard agent loop | Complex control flows, multi-agent orchestration, human-in-the-loop | \n| State and durability | Inherited from LangGraph | Stateful, durable agent workflows | \n| License | MIT | MIT | \n| Software cost | $0 | $0 | \n| Legacy line status | 0.3 in maintenance through December 2026 | 0.4 in maintenance through December 2026 | \n| Release cadence (policy) | Majors every 6 to 12 months, minors every 1 to 2 months, patches weekly as needed | Same policy | \n| v1 support after a 2.0 release | Not confirmed by two sources | Maintenance for at least one year | \n| Streaming direction | Typed agent events (messages, tool calls, subagent status) | Same direction, unified v2 stream format needs LangGraph 1.1 or later | \n| MCP support | FastMCP via `langchain.mcp` in v1.4.0 | Not listed separately | \n| Hosting path | Deploys to LangSmith Deployment | LangSmith Deployment (Agent Server) targets LangGraph agents | \n| Local development billing | Not applicable | `langgraph dev` runs no longer report usage or bill at the self-hosted rate | \n\nTwo 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.\n\nThe 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.\n\nOne 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.\n\n## What Changed in the v1 Line\n\nLangGraph 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.\n\nThe 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.\n\nFall 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.\n\nVersion 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.\n\nThe 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.\n\nNothing 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.\n\n## How create_agent Sits on LangGraph\n\nThink 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.\n\n### The Default Path: One Function, One Loop\n\nFor 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.\n\n``` python\nfrom langchain.agents import create_agent\nfrom langchain.tools import tool\n\n@tool\ndef lookup_order(order_id: str) -> str:\n    \"\"\"Return the status of an order.\"\"\"\n    return f\"Order {order_id}: shipped\"\n\nagent = create_agent(\n    model=\"your-provider:your-model\",\n    tools=[lookup_order],\n    system_prompt=\"You are a support agent. Use tools before answering.\",\n)\n\nresult = agent.invoke(\n    {\"messages\": [{\"role\": \"user\", \"content\": \"Where is order 1042?\"}]}\n)\nprint(result[\"messages\"][-1].content)\n```\n\n### The Escape Hatch: Write the Graph Yourself\n\nSome 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 pause-and-resume pattern below uses LangGraph’s `interrupt` primitive.\n\n``` python\nfrom typing import TypedDict\nfrom langgraph.graph import StateGraph, START, END\nfrom langgraph.checkpoint.memory import InMemorySaver\nfrom langgraph.types import interrupt, Command\n\nclass RefundState(TypedDict):\n    amount: float\n    approved: bool\n\ndef review(state: RefundState):\n    answer = interrupt({\"question\": \"Approve refund?\", \"amount\": state[\"amount\"]})\n    return {\"approved\": answer == \"yes\"}\n\ndef pay(state: RefundState):\n    return {\"approved\": state[\"approved\"]}\n\nbuilder = StateGraph(RefundState)\nbuilder.add_node(\"review\", review)\nbuilder.add_node(\"pay\", pay)\nbuilder.add_edge(START, \"review\")\nbuilder.add_edge(\"review\", \"pay\")\nbuilder.add_edge(\"pay\", END)\n\ngraph = builder.compile(checkpointer=InMemorySaver())\ncfg = {\"configurable\": {\"thread_id\": \"refund-1\"}}\n\ngraph.invoke({\"amount\": 80.0, \"approved\": False}, cfg)   # pauses at review\ngraph.invoke(Command(resume=\"yes\"), cfg)                  # resumes later\n```\n\nSwap `InMemorySaver` for a database-backed checkpointer in production, otherwise a process restart loses the paused run. The point of the sketch is the shape: explicit state, explicit edges, and a pause that costs nothing while it waits. A prebuilt loop cannot express that cleanly.\n\n## What LangChain’s CEO Says About the Split\n\nThe 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.\n\nIn [a retrospective on the project’s first three years](https://www.langchain.com/blog/three-years-langchain), 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.\n\nHe 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.\n\nThe 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.\n\nWhat 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 pause 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.\n\nA 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.\n\n## Benchmarks and Measured Outcomes: What the Numbers Show\n\nNo 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.\n\nWhat 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.\n\n| Source | Reported figure | What it measures | Caveat | \n|---|---|---|---|\n| Klarna case study | 80% shorter case resolution time | Support case handling with an AI assistant monitored in LangSmith | Vendor-published, tied to LangSmith | \n| Podium case study | 90% fewer engineering escalations | Engineering load after adopting LangSmith | Vendor-published, tied to LangSmith | \n| 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 | \n| 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 | \n\nRead 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.\n\nRun 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.\n\n``` python\nimport statistics\nimport time\n\ndef bench(app, prompts, runs=20):\n    samples = []\n    for prompt in prompts:\n        for _ in range(runs):\n            start = time.perf_counter()\n            app.invoke({\"messages\": [{\"role\": \"user\", \"content\": prompt}]})\n            samples.append(time.perf_counter() - start)\n    samples.sort()\n    return {\n        \"median_s\": round(statistics.median(samples), 3),\n        \"p95_s\": round(samples[int(len(samples) * 0.95) - 1], 3),\n        \"n\": len(samples),\n    }\n\nprint(\"create_agent:\", bench(agent, PROMPTS))\nprint(\"custom graph:\", bench(graph_app, PROMPTS))\n```\n\nIf 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.\n\n## Pricing: Free Frameworks, Metered Platform\n\nThe 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.\n\nLangSmith 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](https://evalsreview.com/pricing/langsmith) tracks the same structure.\n\n| Item | Price or rate | What you get | \n|---|---|---|\n| LangChain framework | $0 | MIT-licensed open source | \n| LangGraph framework | $0 | MIT-licensed open source | \n| LangSmith Developer | $0 per seat per month | 1 seat, 5,000 included base traces per month | \n| LangSmith Plus | $39 per seat per month | 10,000 included traces total, up to 3 workspaces, unlimited seats at $39 each | \n| Extra Plus traces | 0.005 LSU per trace ($0.005) | Overage beyond the included allowance | \n| LangSmith Enterprise | Custom, contact sales | Unlimited users, 1 production and 1 development instance, usage billed separately | \n| Enterprise and self-hosted traces | 0.0075 LSU per trace ($0.0075) | Flat rate unless a contract says otherwise | \n| Evaluation run (Perceived Error) | 0.015 LSU per run | Metered evaluation usage | \n| Bulk Export | 0.25 LSU per GiB exported | Data export from LangSmith | \n| Startup credits | Up to $10,000 | For VC-backed startups, discounted rates and credits | \n\nThe 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.\n\nLangChain 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.\n\nFor 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.\n\n## State, Durability and Human-in-the-Loop\n\nLangGraph’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 pause for a person, the runtime layer stops being an implementation detail and becomes the product.\n\nConsider 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 pause 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.\n\nThe 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.\n\nOperational 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.\n\nDeployment 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.\n\nIf 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.\n\n## Streaming, MCP and Tooling Updates This Fall\n\nStreaming 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.\n\nThe 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.\n\nThere 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.\n\n```\n# requirements.txt: hold the server back until all clients upgrade\nlangchain>=1.4.0\nlangchain-core>=1.6.13,<1.7.0\n\n# after every client is on 1.6.13+ (Python) or 1.2.6+ (JS packages):\n# langchain>=1.4.7\n# langchain-core>=1.7.0\n```\n\nMCP 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.\n\nLangSmith 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.\n\n## Observability and Evaluation: Where LangSmith Fits\n\nWhichever 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.\n\nLangChain 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.\n\nCost 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.\n\nThe 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.\n\nEvaluation 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.\n\nSupport 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.\n\nFinally, 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.\n\n## Real-World Deployments: Six Examples\n\nCase 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.\n\n1. **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.\n2. **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.\n3. **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.\n4. **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.\n5. **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.\n6. **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.\n\nThe 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.\n\n## Which Should You Pick? Seven Use-Case Recommendations\n\nAnswer 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.\n\n| Use case | Start with | Why | \n|---|---|---|\n| Internal Q&A bot with a handful of tools | LangChain `create_agent` | One function gives a working loop, and you can drop down later | \n| Customer support agent with refunds or account changes | LangGraph | Approval steps, idempotent payment nodes and resumable state | \n| Multi-agent research pipeline | LangGraph | Explicit hand-offs and shared state between agents | \n| Quick prototype or hackathon demo | LangChain `create_agent` | Fastest route from idea to running agent | \n| Regulated workflow needing audit trails | LangGraph plus LangSmith | Every node and transition is inspectable | \n| Agent that uses many MCP servers | LangChain with `langchain.mcp` | FastMCP support arrived in v1.4.0 | \n| Long-running background job (hours or days) | LangGraph with a durable checkpointer | Survives restarts and holds paused runs cheaply | \n\nA 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.\n\nIf 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.\n\nTeams 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.\n\n## Migration Guide: From 0.3, 0.4 and create_react_agent to v1\n\nMoving 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.\n\n1. **Inventory versions.** Run`pip list | grep -i lang` in every service and record the`langchain` ,`langchain-core` ,`langgraph` and`langgraph-cli` versions. Flag anything on LangChain 0.3 or LangGraph 0.4.\n2. **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.\n3. **Replace the prebuilt agent.** Change imports and the call, then confirm the prompt argument name against the v1 docs.\n4. **Align client and server versions.** Use the pinning pattern from the streaming section so servers and clients upgrade in the right order.\n5. **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.\n6. **Check your CLI.** If you deploy through LangSmith, make sure`langgraph-cli` is 0.4.32 or later, as the deployment documentation required in late October 2026.\n7. **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.\n\n``` python\n# Before (deprecated, still runs)\nfrom langgraph.prebuilt import create_react_agent\nagent = create_react_agent(model, tools, prompt=\"You are a support agent.\")\n\n# After (recommended in v1)\nfrom langchain.agents import create_agent\nagent = create_agent(model, tools=tools, system_prompt=\"You are a support agent.\")\n```\n\nTwo 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.\n\nFinally, 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.\n\n## Pros and Cons of Each Approach\n\nBoth 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.\n\n**LangChain `create_agent`: pros**\n\n- Fastest path from idea to a running tool-calling agent\n- Runs on LangGraph, so persistence and streaming come along\n- FastMCP support in v1.4.0 simplifies tool wiring\n- MIT license and $0 software cost\n- Clear upgrade path: you can inspect and extend the underlying graph later\n\n**LangChain `create_agent`: cons**\n\n- Less control over branching and step order than a hand-built graph\n- Safety rules often end up in prompts, which are easier to break\n- Older tutorials describe pre-v1 patterns that no longer match the docs\n- Fast release cadence demands version pinning\n\n**LangGraph: pros**\n\n- Explicit state, nodes and edges make behavior testable\n- Durable execution, pauses and human approval are first-class\n- Stable v1 runtime with core graph APIs preserved\n- At least one year of maintenance promised for v1 after a 2.0 release\n- Suits multi-agent hand-offs and long-running jobs\n\n**LangGraph: cons**\n\n- More code and a steeper learning curve for simple agents\n- Production persistence needs a real checkpointer and operational care\n- Easy to over-engineer a flow that a single loop would handle\n- Hosted deployment pulls you toward the paid LangSmith platform\n\nThe 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.\n\n## Alternatives and Where Deep Agents Fits\n\nLangChain 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.\n\nThat 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.\n\nOutside 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.\n\nWeigh 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.\n\nOne 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.\n\n## Verdict: Use create_agent First, Reach for LangGraph on Purpose\n\nThe 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.\n\nOur 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.\n\nThree 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.\n\nWhat 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.\n\n## FAQ: LangChain vs LangGraph\n\n### Is LangGraph replacing LangChain?\n\nNo. 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.\n\n### Can I use LangGraph without LangChain?\n\nYes, 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`.\n\n### Are LangChain and LangGraph free?\n\nBoth 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.\n\n### What is the difference between create_react_agent and create_agent?\n\n`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`.\n\n### Which version should I run today?\n\nRun 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.\n\n### Does LangGraph support human approval steps?\n\nYes. LangChain positions LangGraph for human-in-the-loop execution, and the `interrupt` primitive with a checkpointer lets a run pause and resume later. Use a durable checkpointer in production so a restart does not lose the paused state.\n\n### Is there a performance benchmark comparing the two?\n\nWe 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.\n\n### What does LangSmith cost for a small team?\n\nA 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](https://theagenticweekly.com/news) for plan changes, since LangSmith repriced self-serve plans in October 2026.", "url": "https://wpnews.pro/news/langchain-vs-langgraph-0-core-39-plus-2026", "canonical_source": "https://shattered.io/langchain-vs-langgraph-create-agent-0-core-39-plus-2026/", "published_at": "2026-11-06 12:24:34+00:00", "updated_at": "2026-11-06 12:51:35.918468+00:00", "lang": "en", "topics": ["ai-agents", "developer-tools", "agent-protocols", "ai-tools"], "entities": ["LangChain", "LangGraph", "LangSmith", "LangChain, Inc.", "Garage Labs Tech", "Deep Agents", "FastMCP"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/langchain-vs-langgraph-0-core-39-plus-2026", "markdown": "https://wpnews.pro/news/langchain-vs-langgraph-0-core-39-plus-2026.md", "text": "https://wpnews.pro/news/langchain-vs-langgraph-0-core-39-plus-2026.txt", "jsonld": "https://wpnews.pro/news/langchain-vs-langgraph-0-core-39-plus-2026.jsonld"}}