LangGraph

Scroll sideways for more →

LangGraph is an open-source low-level orchestration library for building stateful, multi-actor applications powered by large language models. It is developed by LangChain Inc., the company behind the more general-purpose LangChain framework, and it was created primarily by founding engineer Nuno Campos. LangGraph models agent workflows as graphs in which nodes are functions or sub-agents, edges describe the transitions between them, and a shared state object flows through every step. The graph abstraction supports cycles, conditional branching, persistence, streaming, time travel, and human-in-the-loop control, all of which are awkward or impossible to express with the linear chains that dominated earlier LLM frameworks.^[1][2]

LangGraph was first released on January 8, 2024 in response to a recurring complaint from LangChain users: the original LangChain Expression Language (LCEL) was elegant for one-shot retrieval-augmented generation pipelines, but it could not naturally express the loop that an agent needs in order to think, call a tool, observe a result, and try again. By the time LangGraph reached its 1.0 milestone on October 22, 2025, it had become, in LangChain Inc.'s description, "the most popular low-level agent orchestration framework and runtime," downloaded around 12 million times a month and used in production by companies including Klarna, Uber, LinkedIn, BlackRock, JPMorgan, Cisco, Norwegian Cruise Line, Replit, Elastic, and AppFolio.^{[3][4][5][56]} The broader LangChain ecosystem that LangGraph anchors records roughly 90 million monthly package downloads, holds more than 110,000 GitHub stars across its repositories, and counts about a third of the Fortune 500 as active users; LangGraph's own repository carries on the order of 35,000 stars.^[56][57]

LangChain Inc. positioned the 1.0 release as a stability landmark rather than a feature drop. "This is the first stable major release in the durable agent framework space, a major milestone for production-ready AI systems," the company wrote in its 1.0 announcement, adding that "after more than a year of iteration and widespread adoption by companies like Uber, LinkedIn, and Klarna, LangGraph is officially v1."^[36]

The library is offered under the MIT license. A managed deployment surface, originally branded LangGraph Platform and folded into the broader LangSmith product as a "Deployment" feature in October 2025, sits on top of the open-source library and handles persistence, scaling, scheduling, and observability for long-running stateful agents in production.^[6][7]

What problem does LangGraph solve?

LangChain was founded by Harrison Chase as an open-source project in October 2022, only weeks before OpenAI released ChatGPT. By mid-2023, the library had become the de facto entry point for building LLM applications, and LangChain Inc. raised a $25 million Series A from Sequoia Capital in February 2024 at a $200 million valuation.^[8][9] In October 2025, the company raised an additional $125 million Series B led by IVP at a $1.25 billion valuation, lifting total funding to $260 million.^[10][11] IVP, in announcing the round, described LangChain as having "emerged as the leading platform for building, evaluating, observing and deploying AI agents."^[57]

The early LangChain stack had a clear weakness when developers tried to ship real agents. The agent executor was a black box. It would take a user query, call an LLM, parse a tool name out of the response, run the tool, feed the observation back, and repeat until the model emitted a final answer. There was no way to inspect the loop mid-flight, no obvious way to persist state between calls, no way to involve a human in the middle of a long task, and no clean story for branching or coordinating multiple agents. LangChain Expression Language (LCEL), introduced later, made it easy to wire components together with the pipe operator, but LCEL was a directed acyclic graph by design. It could not loop.^[12]

Nuno Campos, who joined LangChain as its first employee, led the design of a new abstraction modelled explicitly on graph computation. Inspired by Pregel (the bulk synchronous parallel framework that powered Google's web graph processing) and by Apache Beam, the new library represented agent control flow as a directed graph with explicit cycles, a shared state object, and a Pregel-style execution loop in which all node writes from one superstep become visible at the start of the next. The result, released as an open-source companion to LangChain on January 8, 2024, was named LangGraph.^[1][13][14]

When was LangGraph released? Version timeline

LangGraph evolved quickly across 2024, 2025, and 2026. The table below summarizes the milestones that mattered for production users.

Scroll sideways for more →

Versioning since 1.0 follows a strict no-breaking-changes policy until a hypothetical 2.0 release. LangChain Inc. has been explicit that the 1.0 mark was about codifying patterns that had already been validated at customers like Uber, LinkedIn, and Klarna, not about packing in features.^[36][44]

Core abstractions

LangGraph is small at its core. The library exports four primary concepts (state, nodes, edges, and a graph compiler) plus a persistence layer made up of checkpointers and stores. Most production behavior comes from composing these pieces.

State

Every LangGraph application is built around a state object. State is defined as either a Python TypedDict or a Pydantic model and represents the entire memory of the graph at a given point in time. Each node in the graph receives the current state as input and returns a partial update. By default the new dictionary fields overwrite the old ones, but each field can declare a reducer function that combines the old and new values, for example by appending to a list of messages instead of replacing it. The combination of typed state plus per-field reducers makes LangGraph state both inspectable and mergeable, which is what enables time travel and branching later.^[15]

Reducers also matter for concurrent writes. When two nodes run in parallel within the same superstep and both update the same field, the reducer decides how to combine their outputs. The most common reducer is add_messages, which appends new messages to a list while collapsing duplicates and respecting role-based ordering. Custom reducers are ordinary Python functions of the form (old, new) -> merged, so any merge policy that fits the problem can be expressed.^[15]

Nodes

Nodes are ordinary Python or TypeScript functions. A node receives the current state and returns a dictionary of fields to update. Nodes can be pure functions, LLM calls, retrievers, tool use executors, or even nested subgraphs. They can be async, and they can run in parallel within the same superstep when fanned out by an edge. There is no special node base class to inherit from. Anything callable that takes a state and returns a partial state update is a valid node. LangGraph 1.2 added per-node configuration helpers, including the set_node_defaults() builder method, that let teams attach timeouts, retry policies, and idle limits to individual nodes without rewiring the graph.^[44]

Edges

Edges describe how control moves between nodes. There are three kinds. A normal edge is an unconditional transition from node A to node B. A conditional edge is a function that inspects the current state and returns the name of the next node (or a list of names for parallel fan-out). The two reserved edges, START and END, mark the entry and exit points of the graph. Conditional edges are how a LangGraph agent decides whether to keep using tools, hand off to another agent, or finish.^[15]

Unlike LCEL, edges in LangGraph can form cycles. The same conditional edge can route back to a node that was already visited, which is exactly what an agent loop looks like: call the LLM, inspect the response, call a tool if requested, return to the LLM, and repeat.

StateGraph and graph compilation

StateGraph is the main builder class. A developer instantiates it with a state schema, adds nodes by name, adds edges between them, sets the entry point, and then calls .compile() to produce a runnable graph. Compilation runs basic structural checks (no orphaned nodes, no edges to undefined targets) and is the place where runtime options such as the checkpointer and the interrupt list are attached. The compiled graph exposes synchronous invoke, asynchronous ainvoke, and a family of streaming methods.^[15]

A second graph class, MessageGraph, was provided in early LangGraph for the very common case of an agent whose state is just a list of messages. MessageGraph was effectively syntactic sugar over StateGraph and was deprecated as the prebuilt agent helpers in langgraph.prebuilt (later langchain.agents) absorbed the same convenience.^[16]

Channels and Pregel semantics

Under the hood, the LangGraph runtime implements the Pregel / Bulk Synchronous Parallel (BSP) model. Nodes do not call each other directly: they communicate through named channels, and the runtime executes the graph in a sequence of supersteps. Within a superstep, every active node reads the current value of its input channels, runs once, and writes to its output channels. Those writes are not visible inside the same superstep. Once every active node has finished, the runtime applies the writes through their reducers, advances to the next superstep, and dispatches the next set of nodes whose subscribed channels have changed. The graph terminates when no node has anything left to do.^[2][13] The clean boundary between supersteps is what makes a checkpoint taken between two supersteps a consistent snapshot. Parallel fan-out is the default rather than an opt-in feature: if a conditional edge returns a list of node names, all of them run in the same superstep against the same input state.

LangGraph 1.2 introduced DeltaChannel, a new channel type that stores only the incremental change at each superstep rather than re-serializing the full accumulated value. Delta channels are most useful for channels that grow over time, such as a long message list in a multi-day thread. A snapshot_frequency=K argument writes a full snapshot every K steps to bound read latency, trading off checkpoint size against rebuild cost.^[44]

Send and Command

Two lower-level primitives extend the graph beyond a static set of nodes and edges. Send allows a node or edge to dispatch a payload to a named node with a custom partial state, which is the canonical way to do dynamic fan-out (for example, mapping an agent over an unknown number of subtasks). Command is an object a node can return that combines a state update with an explicit routing instruction. The two together are how prebuilt agent patterns express handoffs without rewriting the graph topology at every iteration.^[2][13]

Checkpointers and persistence

A checkpointer saves a snapshot of the state every time the graph progresses, keyed by a thread ID. Once a checkpointer is attached, every superstep is durable. If the process restarts, a request times out, or a human walks away from a half-finished approval, the next call with the same thread ID resumes from the last checkpoint instead of starting over. LangGraph ships several checkpointer implementations:

Scroll sideways for more →

In-memory checkpointers exist mostly for testing. The recommended production option is PostgresSaver, which the managed LangSmith Deployment surface also uses under the hood. The 1.2 release of langgraph-checkpoint (4.1.0) and the SQLite and Postgres backends (3.1.0) added support for streaming delta channel history and reduced bytes-per-checkpoint for high-volume threads.^[17][18][44]

A second persistence primitive, the Store, was added to support long-term memory across threads. Where a checkpointer captures the running state of one conversation, a Store is a key-value record intended for facts that should outlive any single thread, for example the user's preferences or a profile that an agent has learned over many sessions.^[19]

Threads

A thread is the unit of conversation in LangGraph. Each thread has its own ID, its own history of checkpoints, and its own resumable state. Two users hitting the same compiled graph use two threads, so their checkpoints and state never mix. Internally, threads are simply a primary key on the checkpoint store: every superstep is keyed by (thread_id, checkpoint_id). Splitting work across threads is also how LangGraph supports parallel users on a single deployment without explicit locking, since the runtime never has to coordinate state between threads.^[17]

Interrupts and human-in-the-loop

LangGraph supports two complementary mechanisms for pausing execution. Static interrupts, declared at compile time as interrupt_before=['node_name'] or interrupt_after=[...], halt the graph immediately before or after the named node and surface the current state to the caller. The caller can then inspect, edit, or replace the state, and resume the graph by calling it again with None as the input.^[20]

Dynamic interrupts use the interrupt() function inside a node body. The function pauses the graph at exactly the line where it is called and returns the value provided by the caller on resume. Dynamic interrupts are useful when the decision about whether to involve a human depends on data that the node has just computed, for example a low-confidence score on a refund request. Both styles rely on the checkpointer to preserve state across the pause.^[20]

Time travel

Because the checkpointer stores the entire state at every superstep, the user can rewind a graph to any earlier point and continue from there with new input. This is exposed through a get_state_history API that returns the ordered list of past checkpoints. A developer can pick one, modify the state, and resume execution from that point. The same feature underlies the "undo" and "what-if" debugging affordances in LangGraph Studio, where an engineer can step backward to before a wrong tool call and rerun the rest of the agent with a corrected input. LangGraph 1.1 tightened replay behaviour around interrupts and improved checkpoint restoration inside subgraphs, removing a class of bugs where rewinding could put a parent and a child subgraph into inconsistent states.^[21][45]

Streaming

LangGraph compiled graphs expose several streaming modes that can be combined in a single subscription. values mode streams the full state after each superstep. updates mode streams only the partial updates that each node returned. messages mode streams LLM tokens as they are generated, which is what user interfaces use to render the typewriter effect. debug mode emits low-level events about the runtime itself, including which nodes were dispatched and which channels were written. A custom channel lets a long-running tool emit progress signals out of band, for example to show "reading file 4 of 12" while a node is still executing.^[22]

LangGraph 1.1 introduced the version="v2" streaming and invoke contracts. Passing version="v2" to stream() or astream() returns a unified StreamPart shape with type, ns, and data keys on every chunk, and each mode now exposes its own TypedDict so static type checkers can narrow on the type field. Passing the same argument to invoke() or ainvoke() returns a GraphOutput object exposing .value (the typed output) and .interrupts (any pending interrupt records). When the graph declares a Pydantic model or dataclass as its return type, the runtime now coerces the final state to that type automatically.^[45][46] LangGraph 1.2 added an experimental v3 streaming layer that is content-block-centric and supports typed, per-channel projections, aimed at building richer UIs over partial tool outputs.^[44]

Prebuilt agents and ToolNode

The langgraph.prebuilt package (renamed and partially absorbed into langchain.agents in the 1.0 release cycle) ships ready-made building blocks. create_react_agent constructs a tool-calling ReAct-style agent in a single function call, given a model and a list of tools. ToolNode wraps a list of tool callables into a node that reads tool calls off the latest assistant message, runs them in parallel, and emits the resulting tool messages back into the state. Both helpers are simply convenience constructors that produce the same StateGraph a developer could assemble by hand.^[23]

Functional API

In January 2025, LangChain Inc. introduced an alternative way to write LangGraph workflows. The Functional API exposes two decorators, @entrypoint and @task, which let developers describe an agent as an ordinary function with await calls instead of an explicit graph. A function decorated with @task is a unit of durable work, equivalent to a node, and a function decorated with @entrypoint is the durable composition of those tasks, equivalent to a compiled graph. The Functional API uses the same Pregel runtime, the same checkpointers, and the same streaming modes as the Graph API; only the syntax differs.^[37][38]

The trade-offs are practical rather than philosophical. The Graph API makes control flow explicit and visual, which is what a debugger like LangGraph Studio can render and what regulated workloads usually want for audit. The Functional API is faster to write and easier to read for linear or mostly-linear workflows, especially the common case where an agent calls a sequence of tasks in a loop. Most teams use the two together.^[37]

Agent middleware

The September 8, 2025 alpha releases of LangChain 1.0 introduced an AgentMiddleware abstraction that became the canonical extension point for customizing agent behaviour in 2026. Middleware is implemented in the LangChain layer rather than inside LangGraph, but the documentation is explicit that middleware is "not a separate runtime: hooks run inside the compiled LangGraph that create_agent returns." A middleware-augmented agent is therefore still an ordinary LangGraph object that can be invoked, streamed, checkpointed, interrupted, and used as a node inside a larger graph.^[47][48][49]

A middleware class implements one or more of three hook methods. before_model runs immediately before the model call inside the agent loop and may update state or jump to another node. after_model runs immediately after the model call and may also update state or transfer control. modify_model_request runs before the model call and is allowed to mutate the request payload itself, including the tools, the prompt, the message list, the model identifier, the model settings, the output format, and the tool choice. Multiple middlewares are chained: on the way into a model call they run in declared order, and on the way back out they run in reverse, the same pattern used by web-server middleware stacks.^[47][48]

The standard library of middlewares ships with the LangChain package. SummarizationMiddleware collapses old turns once the context is about to overflow. HumanInTheLoopMiddleware wraps tool calls in an approval gate. Model retry middleware automatically retries failed model calls with configurable exponential backoff. Anthropic prompt caching middleware adds cache controls to message blocks before they reach Claude. OpenAI content moderation middleware screens user input, model output, and tool results against OpenAI's moderation endpoint. Rate-limit, PII-detection, and analytics middlewares cover the most common production controls. Custom middlewares are just Python classes, so teams can implement their own policies on top of the same hooks.^[47][49]

Deep Agents

Deep Agents is a separate open-source library, released by LangChain Inc. in 2026, that packages an opinionated "agent harness" on top of create_agent and therefore on top of LangGraph. The official documentation summarises the layering as: "LangGraph is the graph runtime. LangChain's create_agent is a minimal agent harness on top of it. Deep Agents is a more opinionated harness on top of create_agent."^[50][51][52]

Where a stock LangGraph ReAct agent has one tool-calling loop and whatever tools the developer wires in, a Deep Agent comes preloaded with a planning tool, a virtual filesystem, sub-agent delegation, and shell execution, all implemented as middleware. The planning tool (write_todos) lets the agent maintain an explicit task list that survives interrupts and human edits. The virtual filesystem (ls, read_file, write_file, edit_file) lets the agent stash large intermediate documents outside the chat history, with pluggable backends spanning in-memory state, local disk, a LangGraph Store for cross-thread persistence, and sandboxes such as Modal, Daytona, or Deno for isolated code execution. A built-in task tool spawns sub-agents that run in their own context window, returning only a summary so the parent agent's context stays clean.^[51][52]

The 0.6.x line, current as of May 2026, added CodeInterpreterMiddleware (experimental) for tool execution through a scoped QuickJS runtime, more flexible summarization triggers based on model profiles, reusable skill packs that agents can load dynamically at runtime, and tighter integration with Model Context Protocol servers.^[50][52] Deep Agents inherits LangGraph's durability, streaming, and human-in-the-loop guarantees because it never leaves the LangGraph runtime; it is best understood as a particular bundle of middleware and tools, not as a new framework.

How does LangGraph differ from LangChain LCEL?

LangChain Expression Language (LCEL) and LangGraph cover overlapping ground but have very different strengths. The table below summarizes the practical trade-offs.

Scroll sideways for more →

LangChain Inc. treats the two libraries as complementary. LangChain provides the primitive components (model wrappers, retrievers, parsers, memory adapters), while LangGraph provides the orchestration layer for anything stateful, agentic, or long-running. Since the 1.0 release cycle, LangChain's own agent helpers are built on top of LangGraph internally so that they automatically inherit checkpointing, streaming, and human-in-the-loop support.^[12][24]

Multi-agent patterns

LangGraph treats single agents and multi-agent systems as the same kind of object: a graph. Multi-agent designs differ only in how the graph is wired and how state is partitioned. Three patterns have become canonical, and a fourth, hierarchical agent teams, builds on them through subgraphs.

Scroll sideways for more →

In the supervisor pattern, a router agent sits at the center of the graph and decides which specialist to call next based on the current state. Each specialist is a node (often itself a compiled subgraph). Because routing is the supervisor's only job, the supervisor's prompt stays small and focused, which makes the pattern easier to debug and more accurate than letting agents decide handoffs on their own. LangChain Inc. ships a dedicated helper, langgraph-supervisor, that compiles a supervisor graph from a list of named agents and an optional manager LLM; the 1.1 release added a top-level create_supervisor constructor that mirrors the older library's API.^[25][26][45]

The swarm pattern removes the supervisor and lets agents hand off to each other directly. Each agent has a set of handoff tools whose only job is to return a Command that transfers control to a named peer along with any context to share. There is no central router, so the swarm tends to be faster (one fewer LLM call per hop) but harder to keep on rails.^[26]

In plan-and-execute, one agent decomposes the user request into a list of steps, and a second agent executes each step in turn. The shared state holds both the original objective and the current step list, which the planner can revise after each execution if a step fails or new information arrives. Each step is a natural pause point for human review through interrupts.^[27]

Because every compiled graph is itself a callable that takes a state and returns a state, a graph can be used as a node in another graph. This composition makes hierarchical agent teams natural: a top-level supervisor manages mid-level supervisors, each of which manages its own pool of specialists. Subgraphs can use their own state schema and their own checkpointer, which makes it possible to scope memory and persistence to a single team without mixing it into the parent's state.^[27]

LangGraph CodeAct

LangGraph CodeAct, released in March 2025, is a separate library that implements the CodeAct architecture popularized by the Manus agent and the original CodeAct paper from researchers at Tsinghua. Instead of asking the model to emit structured tool calls in JSON, a CodeAct agent emits Python source code, which a sandboxed executor runs against a registry of tools exposed as Python functions. The model can therefore compose tools with ordinary control flow (loops, comprehensions, exception handling, intermediate variables) instead of relying on the orchestrator to do it after the fact.^[39][40]

The practical pitch is fewer LLM calls per task. A traditional tool-calling agent needs one round trip per tool, since the model has to wait for each result before deciding the next call. A CodeAct agent can write a single block of code that calls three tools, transforms the outputs, and returns the final answer. The trade-off is that running model-generated code is dangerous unless the executor is properly sandboxed. LangGraph CodeAct ships with adapter wrappers for safe execution backends and integrates with LangChain tools, MCP tools, and arbitrary Python callables.^[39]

LangGraph Studio

LangGraph Studio is a visual debugger for LangGraph applications. It renders the compiled graph topology, shows live state at every superstep, lets the developer rewind to any past checkpoint, edit state in place, and resume execution. Because it integrates directly with the checkpoint history exposed by the open-source library, the visualization is not a separate trace but the graph's actual run state.^[28]

Studio originally shipped in late 2024 as a macOS-only desktop application that talked to a local development server. In mid-2025 the desktop build was retired in favor of a browser-based version hosted at smith.langchain.com, which works against both local servers and managed deployments. The web Studio supports breakpoints (a UI for the same interrupt_before/interrupt_after primitives), side-by-side replays of alternative branches created by editing past state, and a chat-style harness for testing agents under realistic input.^[7][28]

LangSmith Deployment (formerly LangGraph Platform)

LangSmith Deployment is the managed deployment surface for LangGraph applications. It was first announced in beta in mid-2024 as LangGraph Cloud, reached general availability in May 2025 as LangGraph Platform, and was folded into the LangSmith product family in October 2025 alongside LangSmith Observability and LangSmith Evaluation.^[6][7] The open-source library is still called LangGraph; only the managed deployment surface was renamed.

The Deployment layer adds horizontally scalable infrastructure for long-running stateful agents. It provides:

• A managed Postgres-backed checkpointer so that agent state survives restarts and rolling deployments.
• A task queue with automatic retries, replays, and resume-from-checkpoint behavior, so any node failure picks up where it left off rather than restarting from scratch.
• Multiple deployment topologies, including Self-Hosted Lite (free, capped at one million node executions per month), Cloud SaaS (fully managed by LangChain Inc.), Bring Your Own Cloud (managed control plane in a customer VPC), and Self-Hosted Enterprise (entirely on customer infrastructure).
• One-click GitHub deploys, scheduled and cron-style runs, and a built-in REST API for invoking agents from external systems.
• Native integration with LangSmith tracing so that traces in observability dashboards link directly to the corresponding server logs and graph runs.^[6][7][29]

Deployment tiers

Scroll sideways for more →

The pricing page exposes three packaged tiers (Developer, Plus, and Enterprise) that correspond loosely to the deployment topologies. The Plus tier is the smallest paid tier with BYOC and SLA support, while Enterprise contracts include features such as RBAC, SSO, audit logs, and dedicated support.^[29]

By the time of the 1.0 release, around 400 companies had deployed agents on the managed deployment surface, including Cisco, Uber, LinkedIn, BlackRock, and JPMorgan.^[3][4]

LangSmith integration

LangSmith is LangChain Inc.'s observability and evaluation platform, and it is the default tracing backend for LangGraph. Every compiled graph emits structured traces that LangSmith ingests as a tree of runs: the top-level graph invocation, each superstep, each node, and each LLM or tool call inside a node. Because the trace tree mirrors the graph topology, an engineer can click into a flaky tool call in the LangSmith UI and end up at the exact superstep and checkpoint where it happened.^[30][41]

LangSmith's evaluation features extend the same hooks. A developer can record a dataset of LangGraph runs, define an evaluator (heuristic, LLM-as-judge, or human review), and run the evaluator over either historical traces or fresh runs of a specific graph version. The evaluator output is wired back into the trace timeline so regressions show up against the same UI engineers already use for debugging. LangSmith also ships AI-assisted features such as the Polly debugging copilot and the Insights Agent, which surface patterns and anomalies in production traffic without requiring engineers to write queries.^[41]

Who uses LangGraph in production?

LangGraph's production footprint is unusually well documented for an open-source agent framework, partly because LangChain Inc. publishes named case studies and partly because regulated customers like banks and airlines have used LangGraph as a reference architecture for compliance discussions. The table below lists publicly verified production users.

Scroll sideways for more →

A recurring pattern across these case studies is the combination of LangGraph for orchestration and LangSmith for observability, which is what regulated buyers tend to need before an agent can leave an experimental pilot. Klarna's assistant has reportedly reduced resolution time by about 80%, handles roughly two-thirds of all customer inquiries, and according to CEO Sebastian Siemiatkowski performed work equivalent to about 853 full-time agents while saving the company on the order of $60 million; the company also walked back some of its earlier headcount reductions in 2025 after complaints that the bot handled nuanced cases poorly, an experience widely cited as a cautionary case for AI customer-service ambitions.^[53][54] Replit's in-IDE coding agent runs on LangGraph; Uber's developer-platform team runs large-scale agent-driven code migrations across the company's monorepos; LinkedIn's internal SQL Bot translates natural-language questions into warehouse queries; AppFolio's property-management copilot reportedly saves property managers more than ten hours per week.^[3][4][30]

MCP and ecosystem integration

LangGraph integrates with the Model Context Protocol (MCP), the open standard for exposing tools to AI agents. The companion langchain-mcp-adapters package, maintained jointly by LangChain Inc. and the Anthropic MCP team, converts MCP tool definitions into LangChain tool objects that drop straight into a LangGraph ToolNode. A MultiServerMCPClient manages connections to one or more MCP servers, runs the listing handshake, and exposes the union of their tools to the agent. Because the adapter sits at the tool layer, LangGraph picks up new MCP servers, file systems, browser automations, internal APIs, and so on, without changes to the graph itself.^[42][43]

LangGraph also integrates with model providers through LangChain's chat model wrappers. Any model that LangChain supports works inside a LangGraph node, including Claude via the Anthropic API, GPT-5 via the OpenAI API, Gemini, Llama-family models via local runtimes, and the rest of the chat model catalog. Because LangGraph itself does not bind to a model provider, switching models is usually a one-line change at the model factory.

How does LangGraph compare with other agent frameworks?

The agent-framework space saw an explosion of options between 2023 and 2026. The seven most-cited alternatives or competitors to LangGraph fall into two camps: open-source frameworks, like Microsoft's AutoGen, CrewAI, Pydantic AI, and AWS Strands, and vendor SDKs from the major model providers, including the OpenAI Agents SDK, the Claude Agent SDK, and Google's Agent Development Kit. They differ less in features than in worldview.

Scroll sideways for more →

Independent comparisons in 2025 and 2026 from Galileo, DataCamp, Composio, Langfuse, and the Maxim AI guide tend to converge on similar conclusions. AutoGen feels natural when work is structured as a conversation among specialists. CrewAI fits cleanly role-decomposable work. The OpenAI Agents SDK is the fastest path to ship something inside the OpenAI ecosystem, and the Claude Agent SDK is best when the task is software engineering. LangGraph is the most production-ready of the open-source options when an application needs deterministic flow control, durable state, replayable runs, and mature observability, especially under regulated workloads in finance, healthcare, and security.^{[31][32][33][34][35]} The ecosystem is converging: LangChain's own agent helpers are now LangGraph graphs underneath, several other frameworks have adopted similar ideas about checkpoints and human-in-the-loop primitives, and 2026 industry round-ups continue to position LangGraph as the de facto enterprise tier in the open-source agent framework market.^[55]

Quick reference: key abstractions

Scroll sideways for more →

LangGraph 1.0, 1.1, 1.2 and recent history

LangGraph reached its 1.0 stable release on October 22, 2025, coordinated with LangChain 1.0. LangChain Inc. called it "the first stable major release in the durable agent framework space."^[36] The 1.0 milestone was about consolidating APIs and codifying patterns validated at customers like Uber, LinkedIn, and Klarna rather than packing in new features. LangGraph 1.0 maintained full backward compatibility, with the only notable change being the deprecation of the langgraph.prebuilt namespace in favor of equivalent helpers in langchain.agents. Python 3.9 support was dropped in line with its end-of-life; LangGraph 1.0 requires Python 3.10 or newer. In the same release window, LangGraph Platform was folded into the LangSmith product family as the LangSmith Deployment feature, completing a multi-quarter consolidation of LangChain Inc.'s commercial offerings under the LangSmith brand.^[6][7][36]

LangGraph 1.1, released on March 10, 2026, focused on type safety and developer experience rather than new runtime capabilities. The headline change was the version="v2" streaming and invoke contract: stream() and astream() now emit a unified StreamPart shape with typed TypedDicts per mode, and invoke() and ainvoke() return a GraphOutput object whose .value is automatically coerced into the declared Pydantic model or dataclass and whose .interrupts exposes any pending interrupt records. The release also fixed a number of replay and time-travel edge cases around interrupts and subgraph checkpoints, and shipped a top-level create_supervisor constructor for the supervisor multi-agent pattern.^[45][46]

LangGraph 1.2, released on May 12, 2026, broadened the reliability story. The most prominent addition was DeltaChannel (still beta), which records only the incremental change at each superstep rather than re-serializing the full channel value, with a snapshot_frequency knob to bound rebuild latency. The release added per-node timeouts (both wall-clock and idle), node-level error handlers that can run a recovery function after the retry budget is exhausted (a fit for Saga-style compensation patterns), and a RunControl primitive for cooperative graceful shutdown that leaves a resumable checkpoint behind. Event streaming gained an experimental v3 layer that is content-block-centric and supports typed per-channel projections. A companion set_node_defaults() method on StateGraph lets developers attach those policies declaratively. The 1.2 line shipped alongside langgraph-prebuilt==1.1.0 and 3.1.0 / 4.1.0 releases of the SQLite, Postgres, and core checkpoint packages, which added support for streaming delta channel history.^[44]

Strengths and trade-offs

LangGraph fits naturally where applications need long-running agents that survive process restarts and human delays, workflows that require explicit human approval at one or more steps (finance, healthcare, legal, or any audit-sensitive setting), multi-agent systems whose routing logic and shared memory need to be inspectable and replayable, deterministic guardrails with explicit edges and validated state, and a tight loop between LangSmith observability and orchestration.

Lighter-weight tools tend to win on simpler problems. A one-shot summarization, classification, or RAG pipeline that does not loop is usually faster to write in LCEL. A pure conversation between a few LLMs without much state is often simpler in AutoGen or CrewAI. A throwaway prototype on the OpenAI stack is fastest in the OpenAI Agents SDK. An agent whose only job is software engineering on a developer machine is well served by the Claude Agent SDK. A document-centric agent that lives mostly inside a RAG pipeline often fits more naturally in LlamaIndex Workflows. Teams that want a heavily preloaded "research agent in a box" with planning, virtual files, and sub-agent delegation out of the box may reach for Deep Agents on top of LangGraph rather than wiring those middlewares up themselves.

See also

• LangChain
• LangSmith
• Large language model
• Agent
• Tool use
• Function calling
• AutoGen
• CrewAI
• OpenAI
• Anthropic
• Claude
• Model Context Protocol

References

1. LangChain Blog, "LangGraph: Multi-Agent Workflows," January 2024, https://blog.langchain.com/langgraph-multi-agent-workflows/ ↩
2. LangChain Documentation, "LangGraph overview," https://docs.langchain.com/oss/javascript/langgraph/overview ↩
3. LangChain Blog, "Top 5 LangGraph Agents in Production 2024," https://blog.langchain.com/top-5-langgraph-agents-in-production-2024/ ↩
4. LangChain Blog, "Is LangGraph Used In Production?" https://blog.langchain.com/is-langgraph-used-in-production/ ↩
5. LangChain, "Built with LangGraph," https://www.langchain.com/built-with-langgraph ↩
6. LangChain Changelog, "LangGraph Platform: New deployment options for agent infrastructure," https://changelog.langchain.com/announcements/langgraph-platform-new-deployment-options-for-agent-infrastructure ↩
7. LangChain Blog, "LangGraph Platform is now Generally Available: Deploy & manage long-running, stateful Agents," https://blog.langchain.com/langgraph-platform-ga/ ↩
8. Wikipedia, "LangChain," https://en.wikipedia.org/wiki/LangChain ↩
9. Sacra, "LangChain valuation, funding & news," https://sacra.com/c/langchain/ ↩
10. TechCrunch, "Open source agentic startup LangChain hits $1.25B valuation," October 21, 2025, https://techcrunch.com/2025/10/21/open-source-agentic-startup-langchain-hits-1-25b-valuation/ ↩
11. Fortune, "Exclusive: Early AI darling LangChain is now a unicorn with a fresh $125 million in funding," October 20, 2025 ↩
12. Milvus Blog, "LangChain vs LangGraph: A Developer's Guide," https://milvus.io/blog/langchain-vs-langgraph.md ↩
13. DeepWiki, "Core Execution System," https://deepwiki.com/langchain-ai/langgraph/3-core-execution-system ↩
14. GitHub, langchain-ai/langgraph repository, https://github.com/langchain-ai/langgraph ↩
15. LangChain Documentation, "Graph API overview," https://docs.langchain.com/oss/python/langgraph/graph-api ↩
16. LangChain Reference, "graphs | langgraph," https://reference.langchain.com/python/langgraph/graphs ↩
17. LangChain Documentation, "Persistence," https://docs.langchain.com/oss/javascript/langgraph/persistence ↩
18. LangChain Reference, "checkpoints | langgraph," https://reference.langchain.com/python/langgraph/checkpoints ↩
19. Atlan, "Long-Term Memory LangChain Agents: LangGraph and LangMem Guide," https://atlan.com/know/long-term-memory-langchain-agents/ ↩
20. LangChain Documentation, "Interrupts," https://docs.langchain.com/oss/python/langgraph/interrupts ↩
21. Christian Mendieta, "Human-in-the-Loop AI: Time-Travel Workflows with LangGraph," https://christianmendieta.ca/human-in-the-loop-ai-time-travel-workflows-with-langgraph/ ↩
22. AI Practitioner, "Human-in-the-Loop Agents: Steering AI with LangGraph Streaming, Breakpoints," https://aipractitioner.substack.com/p/human-in-the-loop-agents-steering ↩
23. PyPI, "langgraph-prebuilt," https://pypi.org/project/langgraph-prebuilt/ ↩
24. LangChain Documentation, "Workflows and agents," https://docs.langchain.com/oss/python/langgraph/workflows-agents ↩
25. GitHub, langchain-ai/langgraph-supervisor-py, https://github.com/langchain-ai/langgraph-supervisor-py ↩
26. dev.to (Focused), "Multi-Agent Orchestration in LangGraph: Supervisor vs Swarm," https://dev.to/focused_dot_io/multi-agent-orchestration-in-langgraph-supervisor-vs-swarm-tradeoffs-and-architecture-1b7e ↩
27. LangGraph Tutorials, "Hierarchical Agent Teams," https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/ ↩
28. LangChain Blog, "Announcing LangGraph v0.1 & LangGraph Cloud: Running agents at scale, reliably," https://blog.langchain.com/langgraph-cloud/ ↩
29. LangChain Pricing, "LangSmith Plans and Pricing," https://www.langchain.com/pricing ↩
30. LangChain, "LangGraph Agents in Production: case studies," https://docs.langchain.com/oss/python/langgraph/case-studies ↩
31. Galileo, "AutoGen vs. CrewAI vs. LangGraph vs. OpenAI AI Agents Framework," https://galileo.ai/blog/autogen-vs-crewai-vs-langgraph-vs-openai-agents-framework ↩
32. DataCamp, "CrewAI vs LangGraph vs AutoGen," https://www.datacamp.com/tutorial/crewai-vs-langgraph-vs-autogen ↩
33. Composio, "OpenAI Agents SDK vs LangGraph vs Autogen vs CrewAI," https://composio.dev/blog/openai-agents-sdk-vs-langgraph-vs-autogen-vs-crewai ↩
34. Langfuse, "Comparing Open-Source AI Agent Frameworks," https://langfuse.com/blog/2025-03-19-ai-agent-comparison ↩
35. Maxim AI, "Best AI Agent Frameworks 2025," https://www.getmaxim.ai/articles/top-5-ai-agent-frameworks-in-2025-a-practical-guide-for-ai-builders/ ↩
36. LangChain Blog, "LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones," https://www.langchain.com/blog/langchain-langgraph-1dot0 ↩
37. LangChain Blog, "Introducing the LangGraph Functional API," January 29, 2025, https://blog.langchain.com/introducing-the-langgraph-functional-api/ ↩
38. LangChain Documentation, "Functional API overview," https://docs.langchain.com/oss/python/langgraph/functional-api ↩
39. GitHub, langchain-ai/langgraph-codeact, https://github.com/langchain-ai/langgraph-codeact ↩
40. LangChain on X, announcement of LangGraph CodeAct, March 2025 ↩
41. LangChain Blog, "LangSmith for LangGraph," https://blog.langchain.com/langsmith-langgraph/ ↩
42. LangChain Changelog, "MCP Adapters for LangChain and LangGraph," https://changelog.langchain.com/announcements/mcp-adapters-for-langchain-and-langgraph ↩
43. GitHub, langchain-ai/langchain-mcp-adapters, https://github.com/langchain-ai/langchain-mcp-adapters ↩
44. GitHub releases, "langgraph==1.2.0," May 12, 2026, https://github.com/langchain-ai/langgraph/releases ↩
45. LangChain Documentation Changelog, "LangGraph v1.1 release notes," March 10, 2026, https://docs.langchain.com/oss/python/releases/changelog ↩
46. LangChain Changelog, "LangGraph 1.0 is now generally available," October 22, 2025, https://changelog.langchain.com/announcements/langgraph-1-0-is-now-generally-available ↩
47. LangChain Blog, "Agent Middleware," https://www.langchain.com/blog/agent-middleware ↩
48. LangChain Documentation, "Middleware overview," https://docs.langchain.com/oss/python/langchain/middleware/overview ↩
49. LangChain Blog, "LangChain and LangChain 1.0 alpha releases," September 8, 2025, https://www.langchain.com/blog/langchain-langchain-1-0-alpha-releases ↩
50. GitHub, langchain-ai/deepagents, https://github.com/langchain-ai/deepagents ↩
51. LangChain Documentation, "Deep Agents overview," https://docs.langchain.com/oss/python/deepagents/overview ↩
52. LangChain Blog, "Deep Agents," https://www.langchain.com/blog/deep-agents ↩
53. Customer Experience Dive, "Klarna says its AI agent is doing the work of 853 employees," https://www.customerexperiencedive.com/news/klarna-says-ai-agent-work-853-employees/805987/ ↩
54. LangChain Blog, "How Klarna's AI assistant redefined customer support at scale for 85 million active users," https://www.langchain.com/blog/customers-klarna ↩
55. Firecrawl, "The Best Open Source Frameworks For Building AI Agents in 2026," https://www.firecrawl.dev/blog/best-open-source-agent-frameworks ↩
56. IVP, "LangChain: The Platform for the Enterprise AI Agent Era," October 2025, https://www.ivp.com/content/langchain-the-platform-for-the-enterprise-ai-agent-era/ ↩
57. IVP, "LangChain: The Platform for the Enterprise AI Agent Era" (90M monthly downloads, 110,000+ GitHub stars, ~1/3 of the Fortune 500 as active users), https://www.ivp.com/content/langchain-the-platform-for-the-enterprise-ai-agent-era/ ↩