LangGraph
Last reviewed
Sources
No citations yet
Review status
Needs citations
Revision
v4 ยท 8,086 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Sources
No citations yet
Review status
Needs citations
Revision
v4 ยท 8,086 words
Add missing citations, update stale details, or suggest a clearer explanation.
| LangGraph | |
|---|---|
| Developer | LangChain Inc. |
| Initial release | January 8, 2024 |
| Stable release | 1.2 (May 12, 2026) |
| Repository | github.com/langchain-ai/langgraph |
| Written in | Python, TypeScript |
| Type | Agent orchestration framework, LLM library |
| License | MIT |
| Lead creator | Nuno Campos (founding engineer, LangChain Inc.) |
| Founders of LangChain | Harrison Chase, Ankush Gola |
| Built on | LangChain, Pregel / Bulk Synchronous Parallel model |
| Common uses | Stateful agents, multi-agent systems, tool use workflows, human-in-the-loop applications |
| Notable users | Klarna, LinkedIn, Uber, JPMorgan, BlackRock, Cisco, Replit, Norwegian Cruise Line, Elastic, AppFolio |
| Related products | LangGraph Studio, LangSmith Deployment, Deep Agents |
| Website | langchain.com/langgraph |
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]
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]
LangGraph evolved quickly across 2024, 2025, and 2026. The table below summarizes the milestones that mattered for production users.
| Date | Release | Notable changes |
|---|---|---|
| January 8, 2024 | Initial public release | First open-source publication of StateGraph, conditional edges, and the in-memory checkpointer. |
| June 2024 | LangGraph 0.1 / LangGraph Cloud beta | First general availability of the open-source library; LangGraph Cloud launched as a hosted task queue and persistence layer. |
| Late 2024 | LangGraph Studio (desktop) | Released as a macOS-only desktop application for visual debugging and graph inspection against local servers. |
| January 29, 2025 | Functional API | New @entrypoint and @task decorators added so workflows could be written as ordinary functions instead of explicit graphs. |
| March 2025 | LangGraph CodeAct | Companion library implementing the CodeAct architecture; agents emit Python code instead of structured tool calls. |
| May 2025 | LangGraph Platform GA | Cloud, BYOC, Self-Hosted Lite, and Self-Hosted Enterprise deployment topologies reached general availability. |
| Mid-2025 | LangGraph Studio (web) | Studio shipped as a browser application at smith.langchain.com, replacing the desktop-only build. |
| September 8, 2025 | LangChain 1.0 alpha | Introduced the new middleware abstraction (AgentMiddleware, before_model, after_model, modify_model_request) that runs inside the compiled LangGraph returned by create_agent. |
| October 22, 2025 | LangGraph 1.0 | First stable major release, coordinated with LangChain 1.0; Python 3.9 dropped, langgraph.prebuilt deprecated in favor of langchain.agents. |
| October 2025 | LangSmith Deployment | LangGraph Platform rebranded as the Deployment feature inside the LangSmith product family. |
| March 10, 2026 | LangGraph 1.1 | Type-safe version="v2" streaming and invoke formats; GraphOutput object with .value and .interrupts; automatic coercion to declared Pydantic models or dataclasses; replay/time-travel fixes for interrupts and subgraph checkpoints. |
| May 12, 2026 | LangGraph 1.2 | DeltaChannel (beta) cuts checkpoint overhead in long threads; per-node timeouts; node-level error handlers for Saga-style recovery; graceful cooperative shutdown via RunControl; event streaming v3 (beta). |
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]
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.
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 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 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 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]
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]
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]
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:
| Checkpointer | Storage | Typical use |
|---|---|---|
MemorySaver | In-process Python dict | Local development and notebooks |
SqliteSaver | SQLite database file | Single-machine demos and small services |
PostgresSaver / AsyncPostgresSaver | PostgreSQL | Production, distributed deployments |
| Redis-based savers (community) | Redis | High-throughput caching scenarios |
| MongoDB savers (community) | MongoDB | Document-store environments |
| LangSmith Deployment managed checkpointer | Managed Postgres on LangChain infra | Cloud and Bring-Your-Own-Cloud deployments |
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]
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]
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]
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]
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]
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]
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]
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 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.
LangChain Expression Language (LCEL) and LangGraph cover overlapping ground but have very different strengths. The table below summarizes the practical trade-offs.
| Capability | LangChain LCEL | LangGraph |
|---|---|---|
| Programming model | Pipe operator over Runnables, declarative DAG | Explicit graph of nodes and edges, imperative |
| Topology | Directed acyclic graph (no loops) | Directed graph with cycles |
| State | Implicit, per-call | Explicit, typed, shared across nodes |
| Persistence | None at the chain level | First-class via checkpointers |
| Human-in-the-loop | Not supported natively | Static and dynamic interrupt primitives |
| Time travel and replay | Not supported | Native via checkpoint history |
| Streaming | Token streaming via callbacks | Token, node, custom, and v2 typed event streams |
| Multi-actor coordination | Awkward (chained or nested chains) | Designed for it (subgraphs, supervisor, swarm) |
| Sweet spot | Single-pass RAG, summarization, prompt + parser pipelines | Long-running agents, multi-agent systems, durable workflows |
| Learning curve | Low for simple pipelines | Moderate, requires graph thinking |
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]
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.
| Pattern | How control moves | Strengths | Trade-offs | Prebuilt helper |
|---|---|---|---|---|
| Supervisor | Central router agent picks a specialist each turn | Most accurate, easiest to debug and observe | One extra LLM call per hop; supervisor prompt becomes a chokepoint at scale | langgraph-supervisor, create_supervisor |
| Swarm | Agents hand off to each other directly via tool calls | Lower latency, fits open-ended collaboration | Harder to keep on rails, less inspectable | langgraph-swarm |
| Plan-and-execute | Planner agent emits a list of steps; executor runs them | Forces a deliberate plan before acting; easy to surface to users | Bad plans propagate; planner needs reflection or replanning | Tutorial in langgraph examples |
| Hierarchical teams | Subgraphs nest under a top-level supervisor | Scopes memory and persistence per team; reuses any pattern inside | More moving parts, more state schemas to maintain | Composed manually with subgraphs |
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, 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 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 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:
| Tier | Hosting | Control plane | Data plane | Pricing model | Typical fit |
|---|---|---|---|---|---|
| Self-Hosted Lite | Customer machines | Bundled, runs locally | Customer | Free up to 1M node executions per month | Hobbyists, solo developers, internal demos |
| Cloud SaaS | LangChain Inc. (multi-tenant) | LangChain Inc. | LangChain Inc. | Usage-based on node executions and uptime | Most production teams without strict residency rules |
| Bring Your Own Cloud (BYOC) | Customer VPC | LangChain Inc. (managed) | Customer VPC | Plus tier and above | Regulated industries that need data to stay in-region |
| Self-Hosted Enterprise | Customer infrastructure | Customer | Customer | Enterprise contract | Air-gapped, defense, or fully on-prem deployments |
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 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]
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.
| Company | Industry | What they built on LangGraph | Source |
|---|---|---|---|
| Klarna | Payments | Customer-support assistant for ~85M active users, handling two-thirds of inquiries with ~80% reduction in resolution time | LangChain blog [3] |
| Replit | Developer tools | Replit Agent, the in-IDE coding agent | LangChain blog [3] |
| Norwegian Cruise Line | Travel | Guest-facing AI experiences, evaluation and tuning loop | LangChain blog [3] |
| Elastic | Security and observability | Threat-detection agent network for SecOps triage | LangChain blog [3] |
| Uber | Mobility | Large-scale agent-driven code migrations across monorepos | LangChain blog [4] |
| Professional network | SQL Bot, internal natural-language SQL assistant | LangChain blog [4][30] | |
| AppFolio | Property management | Realm-X copilot reportedly saving 10+ hours per week per property manager | LangChain blog [30] |
| Cisco | Networking | Internal agent platform for network operations | LangChain blog [4] |
| BlackRock | Asset management | Internal research and operations agents | LangChain blog [4] |
| JPMorgan | Banking | Production agent stack | LangChain blog [4] |
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]
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.
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.
| Framework | Vendor | Core metaphor | Strengths | Trade-offs |
|---|---|---|---|---|
| LangGraph | LangChain Inc. | State graph with explicit nodes, edges, and checkpoints | Most fine-grained control; durable state, time travel, native human-in-the-loop, mature observability via LangSmith | Steeper learning curve than chat-style frameworks; requires graph thinking |
| AutoGen | Microsoft Research | Multi-agent conversation | Strong code execution agent; good for research and prototyping; integrates with Azure | Conversation transcript can balloon; less control over branching and durable state |
| CrewAI | CrewAI Inc. (open source) | Role-based crews led by a manager agent | Lowest barrier for non-graph thinkers; mimics human team structure; very fast to start | Less control over deterministic flow; harder to add hard guardrails; SOC 2 still in progress as of 2025 |
| LlamaIndex Workflows | LlamaIndex Inc. | Event-driven async workflows | Document- and retrieval-centric; good fit for RAG-heavy agents | Newer; smaller multi-agent ecosystem than LangGraph |
| Pydantic AI | Pydantic Inc. | Typed function tools with structured outputs | Tightest type safety in Python; great for validated tool I/O | Younger ecosystem; less tooling for long-running state |
| OpenAI Agents SDK | OpenAI | Lightweight agent with function calling and handoffs | Minimal API; quickest path to a working agent on the OpenAI stack; deep tie-in to OpenAI tools | Tied to OpenAI models and platform; thinner story for long-running state, multi-vendor model routing, and self-hosting |
| Claude Agent SDK | Anthropic | Permissioned tool-use harness, originally for Claude Code | Excellent for software engineering tasks; tight integration with Claude tool-use behavior | Optimized for coding rather than general orchestration; tied to Anthropic models |
| Google ADK | Agent Development Kit with declarative agent definitions | Native Gemini integration; first-class on Vertex AI | Newer than the others; ecosystem still forming | |
| AWS Strands | Amazon Web Services | Strands library for tool-using agents on Bedrock | First-class on AWS Bedrock; tight IAM integration | AWS-specific; smaller community |
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]
| Abstraction | Purpose | Where it lives |
|---|---|---|
StateGraph | Builder for a typed-state graph of nodes and edges | langgraph.graph |
MessageGraph (deprecated) | Convenience builder for message-list state | langgraph.graph |
START, END | Reserved entry and exit pseudo-nodes | langgraph.graph |
| Conditional edge | Function returning the next node name(s) from state | add_conditional_edges on StateGraph |
Send | Dispatch a custom payload to a named node | langgraph.types.Send |
Command | Combine a state update with explicit routing | langgraph.types.Command |
interrupt_before / interrupt_after | Static breakpoints set at compile time | StateGraph.compile arg |
interrupt() | Dynamic pause inside a node body | langgraph.types.interrupt |
MemorySaver, SqliteSaver, PostgresSaver | Checkpointers for state persistence | langgraph.checkpoint.* |
DeltaChannel (1.2, beta) | Channel storing only the delta per superstep | langgraph.channels |
RunControl (1.2) | Cooperative shutdown signal for resumable termination | langgraph.types |
Store | Long-term memory across threads | langgraph.store.* |
create_react_agent | Prebuilt tool-calling ReAct agent | langgraph.prebuilt (and langchain.agents) |
create_supervisor | Prebuilt supervisor multi-agent constructor | langchain.agents |
ToolNode | Prebuilt node that runs tool calls in parallel | langgraph.prebuilt |
@entrypoint, @task | Functional API decorators for non-graph workflows | langgraph.func |
AgentMiddleware | Middleware base class for create_agent hooks | langchain.agents.middleware |
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]
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.