LangGraph
Last reviewed
May 8, 2026
Sources
43 citations
Review status
Source-backed
Revision
v2 ยท 6,462 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 8, 2026
Sources
43 citations
Review status
Source-backed
Revision
v2 ยท 6,462 words
Add missing citations, update stale details, or suggest a clearer explanation.
| LangGraph | |
|---|---|
| Developer | LangChain Inc. |
| Initial release | January 8, 2024 |
| Stable release | 1.0 (October 2025) |
| 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, LangGraph Platform (renamed LangSmith Deployment in October 2025), LangSmith |
| 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 in October 2025, it had become the dominant open-source framework for production LLM agents, with around 90 million monthly downloads, hundreds of enterprise deployments, and customer references including Klarna, Uber, LinkedIn, BlackRock, JPMorgan, Cisco, Norwegian Cruise Line, Replit, Elastic, and AppFolio.[3][4][5]
The library is offered under the MIT license. A managed deployment surface called LangGraph Platform, later folded into the broader LangSmith Deployment product, 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]
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 and 2025. 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. |
| 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 under the LangSmith umbrella alongside LangSmith Observability and Evaluation. |
| Early 2026 | LangGraph 1.1 | Type-safe v2 streaming format applied uniformly across stream, astream, invoke, and ainvoke. |
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]
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.
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.
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 |
| LangGraph Platform 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 LangGraph Platform also uses under the hood for managed deployments.[17][18]
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.[21]
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. In LangGraph 1.1 these modes were unified under a v2 streaming format that types both the synchronous and asynchronous APIs, so that stream, astream, invoke, and ainvoke all return the same shape.[22][36]
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]
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, and custom 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 |
| 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.[25][26]
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]
LangGraph Platform is the managed deployment surface for LangGraph applications. It was first announced in beta in mid-2024, reached general availability in May 2025, and was rebranded as LangSmith Deployment in October 2025 when LangChain Inc. consolidated its commercial product line under the LangSmith brand.[6][7]
The Platform 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 LangGraph Platform, 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, ~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%; 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, and several other frameworks have adopted similar ideas about checkpoints and human-in-the-loop primitives.
| 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.* |
Store | Long-term memory across threads | langgraph.store.* |
create_react_agent | Prebuilt tool-calling ReAct agent | langgraph.prebuilt (and langchain.agents) |
ToolNode | Prebuilt node that runs tool calls in parallel | langgraph.prebuilt |
@entrypoint, @task | Functional API decorators for non-graph workflows | langgraph.func |
LangGraph reached its 1.0 stable release on October 22, 2025, coordinated with LangChain 1.0. 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 renamed LangSmith Deployment, completing a multi-quarter consolidation of LangChain Inc.'s commercial offerings under the LangSmith brand.[6][7][36]
LangGraph 1.1, released in early 2026, was a smaller follow-up. The headline change was a v2 streaming format with a single typed contract across stream, astream, invoke, and ainvoke. The 1.1 release also tightened the typings on Send and Command, fixed edge cases in the Functional API, and shipped a create_supervisor constructor for the common multi-agent case.[36]
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.