# Google ADK (Python): features, protocols, quickstart

## TL;DR

Google's Agent Development Kit (ADK) is an Apache-2.0, code-first Python framework for building, evaluating and deploying agents; sibling SDKs cover TypeScript, Go, Java and Kotlin. Version 2.0 added a graph-based workflow runtime alongside LLM agent teams. It is optimized for Gemini but model-agnostic, and suits teams deploying on Google Cloud.

## Key facts

| Field | Value |
| --- | --- |
| Type | Framework |
| Languages / SDKs | Python |
| License | Apache-2.0 |
| Pricing model | [Open core](https://cloud.google.com/products/gemini-enterprise-agent-platform/pricing) |
| Orchestration pattern | Graph |
| GitHub stars | 21,683 (as of 2026-09-30) |
| GitHub forks | 4,083 |
| Last push | 2026-09-30 |
| Latest release | v2.10.0 |
| Repository | [google/adk-python](https://github.com/google/adk-python) |
| Website | [adk.dev](https://adk.dev/) |
| Documentation | [adk.dev](https://adk.dev/) |
| Last verified | 2026-09-30 |

## Key features

- `Workflow` runtime (ADK 2.0): a graph of nodes and edges with routing, fan-out/fan-in, loops, retries and nested workflows. ([source](https://adk.dev/graphs/))
- Coordinator agents that delegate to subagents running in chat, task or single-turn mode. ([source](https://adk.dev/workflows/collaboration/))
- Template workflow agents for fixed sequential, parallel and loop execution over a set of agents. ([source](https://adk.dev/agents/workflow-agents/))
- Sessions, session state and a searchable cross-session memory service. ([source](https://adk.dev/sessions/))
- `McpToolset` for consuming MCP servers, and `to_mcp_server()` to publish an agent as an MCP server. ([source](https://adk.dev/tools-custom/mcp-tools/agent-as-server/))
- A2A: `to_a2a()` exposes an agent with an auto-generated agent card and `RemoteA2aAgent` calls remote agents (experimental). ([source](https://adk.dev/a2a/quickstart-exposing/))
- Tool confirmation that pauses a tool call for a yes/no or structured human response (experimental). ([source](https://adk.dev/tools-custom/confirmation/))
- CLI and dev web UI (`adk run`, `adk web`), built-in evaluation (`adk eval`) and deploy commands for Docker and Cloud Run. ([source](https://github.com/google/adk-python/blob/main/README.md))

## Architecture and orchestration pattern

Pattern: Graph.

ADK 2.0 moved from a hierarchical agent executor to a graph-based execution engine. Agents, tools and plain functions are nodes in a `Workflow`, and edges define routing, parallel branches, loops and retries. An agent is itself a node, so graphs can mix deterministic code steps with LLM reasoning and can be nested.

For less structured work, a coordinator agent can delegate to subagents, each set to a collaboration mode: chat (full user interaction), task (asks for clarification, then returns to the parent) or single-turn (no user interaction, can run in parallel). Older template agents (sequential, parallel, loop) remain available.

Conversation context is split into a `Session` (the event history of one conversation), `State` (data scoped to that session) and a `Memory` service that can be searched across sessions, with in-memory, database and Vertex AI backed implementations. Resumable apps can pick up an interrupted workflow where it stopped.

### Human in the loop

Three documented routes. Tool confirmation (experimental) wraps a tool with `require_confirmation=True` for a yes/no answer, or requests a structured response with a prompt; the answer can come from the ADK web UI dialog or be posted remotely through the ADK server's REST API. Known limitation: it does not work with `DatabaseSessionService` or `VertexAiSessionService`. In ADK 2.0 graph workflows, a node can yield `RequestInput` to pause until a person replies, and the reply becomes the next node's input. Subagents in task mode can also stop to ask the user for clarification before returning to their coordinator.

### Harnesses it can drive

- Claude Code ([evidence](https://adk.dev/tools-custom/mcp-tools/agent-as-server/))

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://adk.dev/tools-custom/mcp-tools/agent-as-server/) | Client and server: `McpToolset` connects agents to MCP servers, and `to_mcp_server()` wraps an agent as a FastMCP server for clients such as Claude Code. |
| A2A | Partial (checked 2026-09-30) | [link](https://adk.dev/a2a/) | Client (`RemoteA2aAgent`) and server (`to_a2a()`) exist, but the docs label A2A support in ADK Python as Experimental. |
| AG-UI | Partial (checked 2026-09-30) | [link](https://adk.dev/integrations/ag-ui/) | ADK docs show an AG-UI app built with CopilotKit; the server adapter (`ag-ui-adk`) lives in the AG-UI repository rather than adk-python. The AG-UI README lists Google ADK as 1st party. |

## Best for

- Teams deploying agents on Google Cloud (Cloud Run, GKE or Agent Runtime)
- Workflows that mix deterministic code steps, LLM agents and human input nodes in one graph
- Publishing an agent as an MCP server so Claude Code or other MCP clients can call it
- Gemini-based applications that need built-in evaluation and a local dev UI

## Not for

- Projects that need stable A2A or tool-confirmation APIs today; both are marked experimental in the Python docs
- ADK 1.x deployments with custom session storage or overridden executor methods that cannot absorb 2.0 migration work
- Teams that want to avoid any Google Cloud dependency for managed hosting

## Quickstart

```sh
pip install google-adk
```

Install not yet verified by this site.

```python
# my_agent/agent.py (project from `adk create my_agent`); run: adk run my_agent
from google.adk import Agent, Workflow
from google.adk.tools import FunctionTool

def refund(order_id: str) -> dict:
    """Issue a refund for an order."""
    return {"status": "refunded", "order_id": order_id}

triage = Agent(name="triage", model="gemini-2.5-flash",
               instruction="Summarize the customer's problem in one line.")
resolver = Agent(name="resolver", model="gemini-2.5-flash",
                 instruction="Resolve the issue; call refund only when needed.",
                 tools=[FunctionTool(refund, require_confirmation=True)])

root_agent = Workflow(
    name="root_agent",
    edges=[("START", triage, resolver)],
)
```

### Common pitfalls

- Python 3.10 or later is required; the README recommends installing with its constraints file for your Python version.
- Gemini models need `GOOGLE_API_KEY` (or Vertex AI settings) in the project's `.env`.
- ADK 2.0 changed the event schema (`node_info`, `output`) and made agents graph nodes; custom session stores and overrides of `_run_async_impl()` need migration, and old overrides are silently ignored.
- Broad `except Exception` blocks in tools disable 2.0 automatic retries, and catching `BaseException` breaks HITL pauses.
- Tool confirmation is experimental and unsupported with `DatabaseSessionService` and `VertexAiSessionService`.
- To stay on 1.x, install with the compatible-release pin `pip install "google-adk~=1.0"`.

Official quickstart: https://adk.dev/get-started/python/

## Pros

- One framework covers deterministic graph workflows and LLM-driven agent teams. ([source](https://adk.dev/2.0/))
- MCP in both directions, including a one-line conversion of an agent into an MCP server. ([source](https://adk.dev/tools-custom/mcp-tools/agent-as-server/))
- Ships a CLI, a local web UI and an evaluation runner with the package. ([source](https://github.com/google/adk-python/blob/main/README.md))
- Model-agnostic even though it is optimized for Gemini. ([source](https://github.com/google/adk-python/blob/main/README.md))
- Resumable workflows can continue after crashes or dropped connections. ([source](https://adk.dev/runtime/resume/))

## Cons

- ADK 2.0 has breaking changes for 1.x users: new event fields, agents as graph nodes, and silently ignored legacy overrides. ([source](https://adk.dev/2.0/))
- Tool confirmation is experimental and does not work with database or Vertex AI session services. ([source](https://adk.dev/tools-custom/confirmation/))
- A2A support in Python is labelled experimental. ([source](https://adk.dev/a2a/))
- Subagent task mode is disabled inside graph-based workflows in ADK Python 2.0. ([source](https://adk.dev/workflows/collaboration/))
- The managed Agent Runtime on Google Cloud is a paid service beyond its no-cost tier. ([source](https://adk.dev/deploy/agent-runtime/))

## Alternatives

- [LangGraph](https://multiagentguide.top/tools/langgraph.md)
- [OpenAI Agents SDK (Python)](https://multiagentguide.top/tools/openai-agents-sdk.md)
- [Microsoft Agent Framework](https://multiagentguide.top/tools/microsoft-agent-framework.md)

## FAQ

### Does Google ADK support MCP?

Yes. `McpToolset` lets agents use MCP server tools, and `to_mcp_server()` turns an agent into an MCP server that clients such as Claude Code can call.

### Does ADK support A2A?

Partly. Python has `to_a2a()` for exposing agents and `RemoteA2aAgent` for calling remote ones, but the docs mark A2A support as experimental.

### Is ADK free?

The framework is Apache-2.0. Deploying to Google Cloud's managed Agent Runtime is a paid service once usage exceeds its no-cost tier.

### Does ADK only work with Gemini?

No. The README says ADK is optimized for Gemini but model-agnostic and deployment-agnostic.

### What changed in ADK 2.0?

Python 2.0 (GA on 2026-05-19) added a graph-based `Workflow` runtime and collaborative agent modes, and made agents nodes in the graph, with some breaking changes for 1.x code.

## Sources

- [Google ADK Python GitHub repository](https://github.com/google/adk-python)
- [Agent Development Kit documentation](https://adk.dev/)
- [ADK Python README](https://github.com/google/adk-python/blob/main/README.md)
- [Python quickstart for ADK](https://adk.dev/get-started/python/)
- [Welcome to ADK 2.0 (breaking changes)](https://adk.dev/2.0/)
- [Graph-based agent workflows (ADK docs)](https://adk.dev/graphs/)
- [Human input for agent workflows (ADK docs)](https://adk.dev/graphs/human-input/)
- [Build collaborative agent teams (ADK docs)](https://adk.dev/workflows/collaboration/)
- [Template workflow agents (ADK docs)](https://adk.dev/agents/workflow-agents/)
- [Session, State and Memory (ADK docs)](https://adk.dev/sessions/)
- [Model Context Protocol tools (ADK docs)](https://adk.dev/tools-custom/mcp-tools/)
- [Configure ADK agents as MCP servers (ADK docs)](https://adk.dev/tools-custom/mcp-tools/agent-as-server/)
- [ADK with Agent2Agent (A2A) Protocol](https://adk.dev/a2a/)
- [A2A quickstart: exposing an agent (ADK docs)](https://adk.dev/a2a/quickstart-exposing/)
- [AG-UI user interface for ADK](https://adk.dev/integrations/ag-ui/)
- [Tool action confirmation (ADK docs)](https://adk.dev/tools-custom/confirmation/)
- [Resume stopped agents (ADK docs)](https://adk.dev/runtime/resume/)
- [Deploy to Agent Runtime (ADK docs)](https://adk.dev/deploy/agent-runtime/)
- [Gemini Enterprise Agent Platform pricing (includes Agent Runtime)](https://cloud.google.com/products/gemini-enterprise-agent-platform/pricing)
- [AG-UI README, supported integrations](https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md)
- [ag-ui-adk middleware (AG-UI repository)](https://github.com/ag-ui-protocol/ag-ui/tree/main/integrations/adk-middleware/python)

---

Data as of 2026-09-30. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/google-adk