Google Agent Development Kit (ADK): Build Multi-Agent AI Systems

1. What Is Google ADK?

The Agent Development Kit (ADK) is an open-source framework from Google designed to simplify the full-stack development of AI agents and multi-agent systems. Introduced at Google Cloud NEXT 2025, ADK provides a code-first approach to building agents that can reason, use tools, collaborate with other agents, and execute complex workflows. While optimized for Gemini and the Google Cloud ecosystem, ADK is explicitly model-agnostic and deployment-agnostic -- you can use it with other LLMs and deploy anywhere.

ADK addresses the gap between prototyping an AI agent and running it in production. It provides a structured agent hierarchy (parent agents delegating to sub-agents), a rich tool ecosystem (pre-built tools, MCP tools, third-party library tools), built-in evaluation and debugging, and multiple deployment targets from local development to fully managed cloud infrastructure. The framework follows a roughly bi-weekly release cadence, with the first community meeting held in October 2025.

The core design philosophy is code-first with optional configuration. You define agents, tools, and orchestration logic in code using Python, TypeScript, Java, or Go. For simpler cases, ADK also supports agent definition via YAML configuration files (Agent Config), enabling workflows without writing code. This dual approach lets teams start with configuration and graduate to full code control as complexity grows.

2. Multi-Language Support

ADK is available in four languages, each with its own SDK repository and release cycle. Python was the first SDK and remains the most feature-complete. TypeScript, Java 1.0, and Go 1.0 reached general availability in early 2026, bringing feature parity across all supported languages.

3. Agent Architecture

ADK's agent architecture centers on the LlmAgent class (also aliased as Agent), which wraps an LLM with instructions, tools, and optional sub-agents. Each agent has a name, a model reference, system instructions, a list of tools it can call, and an optional list of child agents it can delegate to. The ADK engine orchestrates the reasoning loop: the LLM decides whether to call a tool, delegate to a sub-agent, or return a final response.

Tools are defined using decorators (Python) or annotated functions (TypeScript, Java, Go). The @tool decorator in Python automatically extracts the function signature, docstring, and type hints to generate the tool's JSON Schema. Tools can perform any operation: API calls, database queries, file operations, code execution, or invoking external services. ADK also provides pre-built tools for Google Search, code execution (via Vertex AI sandbox), and more.

# Python: Define an agent with tools and sub-agents
from google.adk import Agent

def get_weather(city: str) -> dict:
    """Get current weather for a city."""
    # Call weather API
    return {"city": city, "temp": 22, "condition": "sunny"}

def book_restaurant(name: str, party_size: int) -> str:
    """Book a table at a restaurant."""
    return f"Booked {name} for {party_size} guests"

# Sub-agent for restaurant tasks
restaurant_agent = Agent(
    name="restaurant_agent",
    model="gemini-2.0-flash",
    instruction="You help with restaurant bookings.",
    tools=[book_restaurant]
)

# Root agent that delegates
root_agent = Agent(
    name="travel_assistant",
    model="gemini-2.0-flash",
    instruction="You are a travel assistant. Delegate "
                "restaurant tasks to the restaurant agent.",
    tools=[get_weather],
    sub_agents=[restaurant_agent]
)

Sub-agent orchestration is a first-class concept. A parent agent can delegate tasks to specialized sub-agents, each with their own tools and instructions. The ADK engine and model guide the agents to work together: a coordinator agent breaks down user requests, delegates sub-tasks to specialized agents, and synthesizes their responses. This enables modular, maintainable multi-agent systems where each agent has a focused responsibility.

Session state is managed through pluggable backends. ADK maintains conversation history and state variables per session. State can be stored in memory (for development), or in persistent backends like Cloud Firestore, Redis, or custom stores for production. The session state supports rewinding to a previous invocation point, allowing debugging and replay of agent interactions.

4. A2A Protocol Support

ADK natively supports the Agent-to-Agent (A2A) Protocol, the open standard for inter-agent communication across different frameworks and vendors. A2A enables ADK agents to discover and communicate with agents built in LangGraph, CrewAI, or any other A2A-compatible framework. This is critical for enterprise environments where different teams build agents using different tools.

The integration works through Agent Cards -- JSON metadata files that describe an agent's capabilities, supported interaction modes, and endpoint URL. An ADK orchestrator agent can use discovery and delegation functions as tools, with system instructions that guide the LLM on how to use these tools to break down user requests and coordinate with remote agents. You can create both specialized A2A-compatible agents and powerful orchestrators that leverage them, forming collaborative multi-agent systems.

# Convert an ADK agent to an A2A-compatible server
from google.adk.a2a import A2AServer

# The A2A server exposes the agent via the A2A protocol
a2a_server = A2AServer(
    agent=root_agent,
    agent_card={
        "name": "travel-assistant",
        "description": "Helps with travel planning",
        "capabilities": ["weather", "restaurants"],
        "url": "https://my-agent.run.app/a2a"
    }
)

# Remote agents can now discover and call this agent
# using the standard A2A protocol, regardless of their
# own framework (LangGraph, CrewAI, OpenAI SDK, etc.)

The A2A Protocol enables agents across different ecosystems to communicate irrespective of the framework or vendor they are built on. ADK's native support means you do not need additional libraries or adapters -- A2A is built into the core SDK across Python, TypeScript, Java, and Go.

5. MCP Tool Integration

ADK integrates with the Model Context Protocol (MCP) ecosystem, allowing agents to use any MCP-compatible tool server as a tool source. This means your ADK agents can connect to the 50+ community MCP servers for databases, cloud platforms, development tools, and communication services without writing custom integration code.

The integration supports both Stdio (local MCP servers) and HTTP-based transports (remote MCP servers). You can also use third-party library tools from LangChain and LlamaIndex, or wrap other agent frameworks (LangGraph, CrewAI) as tools. This composability means ADK agents can leverage the entire existing tool ecosystem rather than requiring purpose-built integrations.

# Using MCP tools in an ADK agent
from google.adk import Agent
from google.adk.tools.mcp import MCPToolset

# Connect to an MCP server (e.g., GitHub)
github_tools = MCPToolset(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
    env={"GITHUB_TOKEN": "..."}
)

agent = Agent(
    name="code_reviewer",
    model="gemini-2.0-flash",
    instruction="Review pull requests using GitHub tools.",
    tools=[github_tools]
)

6. Evaluation Framework

ADK includes a built-in evaluation framework for testing agent behavior before deployment. The framework operates at two levels: local evaluation via the ADK Web UI for fast, interactive testing during development, and scaled evaluation via Vertex AI Gen AI Evaluation Service for running comprehensive test suites with richer metrics.

Built-in rubric metrics include FINAL_RESPONSE_QUALITY (overall answer quality), TOOL_USE_QUALITY (whether the agent selected the right tools with correct parameters), HALLUCINATION (factual grounding), and SAFETY (harmful content detection). You can also define custom metrics -- for example, a response_follows_trajectory_metric that assesses whether the agent's response logically follows from its tool choices.

The evaluation workflow follows a five-step inner loop: (1) define test cases with expected outcomes, (2) run the agent against test inputs, (3) compare actual behavior to expected trajectories, (4) inspect tool calls and reasoning steps in the Web UI, (5) iterate on agent instructions and tool definitions. For production, Vertex AI adds LLM-as-a-judge evaluation, where a separate model scores agent responses against rubrics, enabling automated quality gates in CI/CD pipelines.

7. Deployment Options

ADK agents can be deployed across a range of infrastructure targets, from local Docker containers to fully managed Google Cloud services. The framework is deployment-agnostic by design -- the same agent code runs everywhere without modification.

8. ADK Web UI

ADK ships with a built-in web-based development interface (ADK Web UI) for interactive agent testing and debugging. When you start the ADK development server, the Web UI is accessible in your browser, providing a chat interface to interact with your agents, inspect tool calls, view reasoning steps, and debug multi-agent interactions in real time.

The Web UI is designed for the development inner loop: make a code change, test it immediately in the UI, inspect what happened, and iterate. It shows the full agent execution trace -- which tools were called, what arguments were passed, which sub-agents were invoked, and what each component returned. This visibility is essential for debugging complex multi-agent workflows where understanding the orchestration flow is critical.

# Start the ADK development server with Web UI
adk web

# The Web UI is accessible at http://localhost:8000
# Features:
# - Chat interface for agent interaction
# - Tool call inspection with arguments and results
# - Sub-agent delegation visualization
# - Session state viewer
# - Execution trace timeline
# - Built-in evaluation test runner

ADK also supports bidirectional audio and video streaming, enabling human-like conversations with agents. This is unique among agent frameworks and enables voice-based agent interfaces, video analysis workflows, and multimodal interactions directly through the development UI.

9. Framework Comparison

The agent framework landscape in 2026 has four major contenders. Each has distinct strengths tied to its ecosystem. This comparison covers Google ADK, Claude Agent SDK, OpenAI Agents SDK, and LangGraph.