# Google ADK vs LangGraph vs OpenAI Agents SDK: how they differ

> ADK, LangGraph and the OpenAI Agents SDK compared on workflows, multi-agent design, state, human approval, MCP, models and tracing.

Source: https://www.honeyhive.ai/learn/google-adk-vs-langgraph-vs-openai-agents-sdk (updated 2026-11-08)

Google ADK, LangGraph and the OpenAI Agents SDK all turn model calls and tools into an agent system, but they start from different places. LangGraph gives you a graph and shared state to design yourself. ADK gives you a larger toolkit with several workflow types, sessions, evaluation and deployment targets. The Agents SDK gives you a handful of primitives (agents, handoffs, guardrails) and a runner loop. The OpenAI docs describe the SDK as a [lightweight package](https://openai.github.io/openai-agents-python/) with "very few abstractions".

Each framework has its own page: [Google ADK](/learn/google-adk-framework), [LangGraph](/learn/langgraph-framework) and [OpenAI Agents SDK](/learn/openai-agents-sdk-framework). The table below puts the same criteria side by side. For the older LangGraph, CrewAI and AutoGen comparison, see [LangGraph vs CrewAI vs AutoGen](/learn/langgraph-vs-crewai-vs-autogen).

## Side by side

| | Google ADK | LangGraph | OpenAI Agents SDK |
|---|---|---|---|
| What it is | "The open-source agent development framework that lets you build, debug, and deploy reliable AI agents" ([docs](https://adk.dev/)) | "A low-level orchestration framework and runtime for long-running, stateful agents" ([docs](https://docs.langchain.com/oss/python/langgraph/overview)) | "Agentic AI apps in a lightweight, easy-to-use package" ([docs](https://openai.github.io/openai-agents-python/)) |
| License | Apache 2.0 ([GitHub](https://github.com/google/adk-python)) | MIT ([GitHub](https://github.com/langchain-ai/langgraph)) | MIT ([GitHub](https://github.com/openai/openai-agents-python)) |
| Languages | Python, TypeScript, Go, Java and Kotlin ([docs](https://adk.dev/)) | Python, plus LangGraph.js ([GitHub](https://github.com/langchain-ai/langgraph)) | Python, plus a separate JavaScript/TypeScript SDK ([GitHub](https://github.com/openai/openai-agents-python)) |
| Core abstraction | Agents composed in graph, dynamic, collaborative or template workflows ([workflows](https://adk.dev/workflows/)) | Graph of nodes and edges over shared state ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | Agents, agents as tools or handoffs, and guardrails, run by a runner loop ([docs](https://openai.github.io/openai-agents-python/)) |
| Who writes the control flow | You or the framework, depending on the workflow type; graph and dynamic workflows need ADK 2.0 or later ([workflows](https://adk.dev/workflows/)) | You. It "does not prescribe prompts or agent architecture" ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | Mostly the model, through handoffs and tool calls ([handoffs](https://openai.github.io/openai-agents-python/handoffs/)) |
| Multi-agent | A coordinator agent with specified sub-agents, or sequential, loop and parallel templates ([workflows](https://adk.dev/workflows/)) | LangChain lists subagents, handoffs, skills, routers and custom workflows built with LangGraph ([multi-agent](https://docs.langchain.com/oss/python/langchain/multi-agent)) | Agents as tools or handoffs that "allow agents to delegate to other agents" ([docs](https://openai.github.io/openai-agents-python/)) |
| State and memory | Sessions, state and memory; in-memory options for local testing, database and cloud options for persistence ([sessions](https://adk.dev/sessions/)) | Checkpointed thread state plus longer-term memory across sessions ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | Sessions with SQLite, Redis, SQLAlchemy, MongoDB, Dapr and OpenAI-hosted backends ([sessions](https://openai.github.io/openai-agents-python/sessions/)) |
| Human approval | Action confirmations for function tools and human input in graph workflows ([docs](https://adk.dev/)) | `interrupt()` pauses the graph and `Command(resume=...)` continues it ([interrupts](https://docs.langchain.com/oss/python/langgraph/interrupts)) | `needs_approval` on a tool pauses the run; the serialized run state can be stored and resumed ([human in the loop](https://openai.github.io/openai-agents-python/human_in_the_loop/)) |
| MCP | `McpToolset` as a client; ADK tools can be exposed as an MCP server ([MCP tools](https://adk.dev/tools-custom/mcp-tools/)) | Through LangChain's `MCPAdapter` ([docs](https://docs.langchain.com/oss/python/langchain/mcp)) | Hosted, Streamable HTTP, SSE (a deprecated MCP transport) and stdio servers ([MCP](https://openai.github.io/openai-agents-python/mcp/)) |
| Models | Gemini built in, adapters for other providers, local models ([docs](https://adk.dev/)) | Does not require LangChain; model integrations usually come from LangChain ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | Responses API by default; Chat Completions and 100+ other LLMs ([GitHub](https://github.com/openai/openai-agents-python)) |
| Tracing | "Logging, metrics, and traces" built in ([observability](https://adk.dev/observability/)) | Tracing and deployment are separate hosted LangChain products ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | On by default, viewed in the OpenAI Traces dashboard ([tracing](https://openai.github.io/openai-agents-python/tracing/)) |
| Evaluation | Built-in criteria, user and environment simulation, custom metrics and optimization ([docs](https://adk.dev/)) | Evaluation is in LangChain's separate hosted product ([overview](https://docs.langchain.com/oss/python/langgraph/overview)); a [testing guide](https://docs.langchain.com/oss/python/langgraph/test) covers testing nodes and edges with pytest | Traces feed OpenAI's evaluation tools ([docs](https://openai.github.io/openai-agents-python/)) |
| Deployment | Containers, or Google Cloud via Agent Runtime, Cloud Run or GKE ([docs](https://adk.dev/)) | LangChain's hosted deployment ([overview](https://docs.langchain.com/oss/python/langgraph/overview)), or inside your own application as an MIT-licensed library ([GitHub](https://github.com/langchain-ai/langgraph)) | No hosted deployment documented; it runs inside your own application ([docs](https://openai.github.io/openai-agents-python/)) |
| Install | `pip install google-adk` (Python 3.11 or later, [GitHub](https://github.com/google/adk-python)) | `pip install -U langgraph` ([overview](https://docs.langchain.com/oss/python/langgraph/overview)) | `pip install openai-agents` (Python 3.10 or newer, [GitHub](https://github.com/openai/openai-agents-python)) |

Install lines and Python versions come from the repositories and docs linked in the table.

## How each one handles control flow

LangGraph is the most explicit. You declare nodes, edges and state, and the framework runs and checkpoints it. That is more code up front and gives you exact control over branches, loops and pauses.

ADK offers a range. Its [workflows page](https://adk.dev/workflows/) lists graph workflows that mix agents and deterministic nodes, dynamic workflows written in plain code, collaborative workflows where one agent coordinates sub-agents, and template workflows (sequence, loop, parallel). The first three are marked ADK 2.0 or later, and agent routing is marked experimental.

The Agents SDK leaves the most to the model. Per the [handoffs guide](https://openai.github.io/openai-agents-python/handoffs/), handoffs are represented to the model as tools, so a handoff to a refund agent is a tool call. You steer with instructions, tools and guardrails rather than a graph.

## Limits worth knowing before you choose

- **Agents SDK guardrails are scoped.** The [guardrails guide](https://openai.github.io/openai-agents-python/guardrails/) says input guardrails run only for the first agent in the chain and output guardrails only for the agent that produces the final output.
- **Agents SDK tracing and data retention.** Tracing is on by default, and the [tracing guide](https://openai.github.io/openai-agents-python/tracing/) says it is unavailable for organizations under a Zero Data Retention policy.
- **LangGraph resumes re-run the node.** After an `interrupt()`, the [docs](https://docs.langchain.com/oss/python/langgraph/interrupts) say the node restarts from its beginning, so code before the call runs again. A checkpointer is required, and the docs recommend a durable one in production.
- **ADK's in-memory sessions are for local testing.** The [sessions page](https://adk.dev/sessions/) says data in the in-memory options is lost when the application restarts; persistence needs a database or cloud service.
- **Non-OpenAI models in the Agents SDK.** The [models guide](https://openai.github.io/openai-agents-python/models/) lists the LiteLLM and Any-LLM adapters as best-effort and beta, and warns about feature differences between providers.
- **Stored approval state is not authenticated.** The [human in the loop guide](https://openai.github.io/openai-agents-python/human_in_the_loop/) says the loaders for serialized run state do not authenticate the snapshot, so load only trusted ones.

## Which to choose

| Your situation | Start with |
|---|---|
| You want to define every step, branch and pause, and resume after a crash | LangGraph |
| You build on Google Cloud, or want ready-made workflow types, sessions and evals | Google ADK |
| You need Java, Go or Kotlin | Google ADK (LangGraph and the Agents SDK cover Python and JavaScript/TypeScript) |
| You use OpenAI models and want the smallest API for handoffs, guardrails and tracing | OpenAI Agents SDK |
| You need voice agents | OpenAI Agents SDK, which documents [realtime and voice agents](https://openai.github.io/openai-agents-python/) |
| You want to mix model providers freely | Check each framework's provider notes first; none is limited to one vendor, but each documents gaps |
| A plain function could do the job | None of them |

This table is a judgement from the vendors' docs, not a benchmark. The docs describe features, not how each framework performs on your task, so test on your own data before committing. See [testing AI agents](/learn/testing-ai-agents) and [LLM evaluation](/learn/llm-evaluation).

For the ideas behind the columns, see [multi-agent systems](/learn/multi-agent-systems), [agent orchestration](/learn/agent-orchestration), [human-in-the-loop AI](/learn/human-in-the-loop-ai) and the [Model Context Protocol](/learn/model-context-protocol). OpenAI's visual builder is covered in [OpenAI Agent Builder](/learn/openai-agent-builder).

## Tracing any of the three

Whichever you pick, multi-agent runs are hard to debug without traces of each agent step and tool call. For the method, see [agent tracing](/learn/agent-tracing) and [LLM observability](/learn/llm-observability). HoneyHive documents an integration for each framework, each set up with a few lines and an OpenInference instrumentor: [Google ADK](https://docs.honeyhive.ai/v2/integrations/google-adk), [LangGraph](https://docs.honeyhive.ai/v2/integrations/langgraph) and the [OpenAI Agents SDK](https://docs.honeyhive.ai/v2/integrations/openai-agents).

## FAQ

### Is Google ADK better than LangGraph?

Neither is better in general. LangGraph is a [low-level orchestration framework](https://docs.langchain.com/oss/python/langgraph/overview) where you define the graph and the state. ADK is an [agent development framework](https://adk.dev/) with ready-made workflow types, sessions, evaluation and Google Cloud deployment. Choose by how much structure you want supplied.

### Can the OpenAI Agents SDK use models other than OpenAI's?

Yes. The repository calls the SDK [provider-agnostic](https://github.com/openai/openai-agents-python), and the [models guide](https://openai.github.io/openai-agents-python/models/) warns that many providers do not support the Responses API and that feature differences between providers can cause errors.

### Do ADK, LangGraph and the OpenAI Agents SDK support MCP?

All three can use MCP tools. ADK has [`McpToolset`](https://adk.dev/tools-custom/mcp-tools/), the Agents SDK supports [hosted, Streamable HTTP, SSE and stdio servers](https://openai.github.io/openai-agents-python/mcp/), and LangChain's [`MCPAdapter`](https://docs.langchain.com/oss/python/langchain/mcp) turns MCP tools into tools for LangChain agents, which are [built on LangGraph](https://docs.langchain.com/oss/python/langchain/overview).

### Which of the three is open source?

All three. [ADK](https://github.com/google/adk-python) is Apache 2.0, while the [Agents SDK](https://github.com/openai/openai-agents-python) and [LangGraph](https://github.com/langchain-ai/langgraph) are MIT licensed.

### How do you trace an agent built with one of these frameworks?

Each framework emits its own traces, and OpenTelemetry-based tools can collect them. HoneyHive documents integrations for [Google ADK](https://docs.honeyhive.ai/v2/integrations/google-adk), [LangGraph](https://docs.honeyhive.ai/v2/integrations/langgraph) and the [OpenAI Agents SDK](https://docs.honeyhive.ai/v2/integrations/openai-agents).