OpenAI Agents SDK vs LangGraph for production agents

Choosing between OpenAI Agents SDK vs LangGraph shapes your agent’s architecture, operational burden, and model portability. Both are open-source orchestration layers, but they optimize for opposite tradeoffs: the SDK bets on convention and OpenAI-native simplicity, while LangGraph bets on explicit control and model agnosticism.

Capabilities

Agent composition

The OpenAI Agents SDK models a system as a set of Agent objects that hand off to each other. You declare instructions, tools, and handoff targets. The runner loops until an agent finishes or transfers. It is deliberately acyclic—handoffs form a directed graph without explicit cycles.

from agents import Agent, Runner

triage = Agent(name="Triage", instructions="Route to billing or tech")
billing = Agent(name="Billing", instructions="Handle billing questions")
triage.handoffs = [billing]

result = Runner.run_sync(triage, "I was double charged")

LangGraph represents agents as nodes in a stateful StateGraph. Edges can be conditional and cyclic. You own the control flow, which makes loops, retries, and multi-step planning first-class.

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class State(TypedDict):
    input: str
    output: str

def triage(state: State):
    return {"output": "routed"}

builder = StateGraph(State)
builder.add_node("triage", triage)
builder.add_edge(START, "triage")
builder.add_edge("triage", END)
graph = builder.compile()

State and memory

OpenAI Agents SDK keeps conversation history inside the runner’s turn loop. Durable memory requires you to persist the input/output yourself or use OpenAI’s session endpoints. There is no built-in checkpointing.

LangGraph ships with checkpointing backends (in-memory, Postgres, Redis). Every graph transition can be persisted, enabling time-travel debugging and resumption after crashes. For production agents that run for minutes, this matters.

Human-in-the-loop

LangGraph supports interruption points via interrupt() and resumption with graph.invoke(inputs, config). The SDK provides guardrails and input filtering, but pausing mid-agent for human approval means you must break the run into separate Runner calls and rebuild context.

Cost Model

Neither framework charges a license fee. Your spend is the underlying model API plus optional observability.

OpenAI Agents SDK pushes you toward OpenAI’s Responses or Chat Completions APIs. If you stay in-model, cost is OpenAI’s published per-token rate. Using the SDK with a third-party model requires a custom ModelProvider shim, which is supported but lightly documented for non-OpenAI hosts.

LangGraph is model-agnostic. You call whatever LLM client you want inside a node. Cost depends on that provider. LangSmith tracing is free for limited volumes; beyond that it is a per-trace subscription.

If you route through an OpenAI-compatible gateway such as n4n.ai, you get per-token metering and automatic fallback when a provider is rate-limited, while keeping either framework’s code unchanged by pointing the base URL at the gateway.

Latency and Throughput

The SDK adds a thin async loop around model calls. Overhead is sub-millisecond per handoff. Real latency is dominated by OpenAI round-trips. Because handoffs are serial, a multi-agent chain accumulates sequential model latency.

LangGraph introduces graph compilation and state serialization. For simple linear graphs the overhead is small (single-digit ms). With checkpointing to Postgres on every step, you add a network write per transition—plan for that in high-throughput flows. LangGraph can run nodes concurrently via async nodes, which the SDK does not do natively.

Ergonomics

The SDK reads like a script. You define agents and call Runner.run. Tracing is built in and exports to OpenAI’s dashboard. New engineers become productive in an hour.

LangGraph forces you to define a state schema and node functions. That verbosity is a feature for complex flows but a tax for trivial ones. The docs assume comfort with reducers and typed dicts. The payoff is that the data flow is explicit and testable.

Ecosystem and Tooling

OpenAI Agents SDK integrates with OpenAI’s tool ecosystem: hosted tools, file search, code interpreter, and eval suites. It is the path of least resistance if your stack is already OpenAI-centric.

LangGraph sits on LangChain’s integration catalog—hundreds of vector stores, retrievers, and model adapters. It has a managed runtime (LangGraph Platform) for deployment, scaling, and persistence. The community publishes patterns for supervisor, hierarchical, and reactor topologies.

Limits and Sharp Edges

The SDK’s handoff model makes cycles awkward. If you need an agent to revisit a previous step based on a critique, you must implement that outside the runner. Guardrails run as filters, not as graph nodes, so complex conditional logic leaks into code.

LangGraph’s flexibility invites over-engineering. Version churn in the langgraph package has broken compiles between minor versions. State schema mistakes surface as runtime errors, not type checks, unless you rigorously use TypedDict and mypy.

Comparison Table

Which to Choose

Use OpenAI Agents SDK if…

• You are building a focused multi-agent assistant on OpenAI models.
• Your flows are mostly linear: triage → specialist → answer.
• You want tracing and guardrails without standing up extra infrastructure.
• Your team values speed of development over fine-grained control.

A typical fit: a support bot that routes queries to billing or technical agents and returns a final answer.

Use LangGraph if…

• You need loops, self-critique, or dynamic branching.
• Your agents must run across Anthropic, Google, and self-hosted models.
• Durability matters: long-running jobs that survive process restarts.
• You want to embed human approval inside a multi-step plan.

Examples: an agent that drafts code, runs tests, critiques the diff, and loops until green; or a research pipeline that fans out to parallel retrievers and reduces results.

Hybrid and gateway note

The two are not mutually exclusive. Some teams use LangGraph for outer orchestration and call OpenAI Agents SDK inside a single node for sub-tasks. If you abstract the model client, point both at a single OpenAI-compatible endpoint that addresses 240+ models and honors client routing directives. That keeps your framework choice decoupled from provider availability.

Pick the SDK when convention beats configuration. Pick LangGraph when you need to own the graph. Both ship real agents; the difference is who controls the control flow.