Google Agent Development Kit (ADK): Complete Guide

Open Source Foundation

ADK is fully open source under the Apache 2.0 license, hosted on GitHub with separate repositories for the Python framework (google/adk-python) and documentation (google/adk-docs). This distinguishes it from the Claude and OpenAI SDKs, which are open source in their client libraries but depend on proprietary cloud services for core functionality.

The open-source nature means developers can inspect the orchestration logic, modify the framework for their specific needs, and contribute improvements back to the community. It also means ADK can be run entirely on-premises without any dependency on Google Cloud, though the deepest integrations and easiest deployment paths go through Google's infrastructure.

ADK is available on PyPI as google-adk and supports Python 3.10 and later. The framework is designed to be written by both humans and AI, with developer Skills and AI-aware resources that allow coding assistants to generate agent configurations quickly.

Multi-Agent Architecture

Where other SDKs treat multi-agent coordination as an advanced feature built on top of single-agent primitives, ADK designs for multi-agent systems from the ground up. The framework natively supports composing specialized teams of agents that collaborate, delegate tasks, and share context through structured interfaces.

Two orchestration modes are available. Workflow agents provide predictable pipeline execution where the sequence of agent activities is defined in advance. This is suitable for processes with known steps, like document review pipelines or data processing workflows. Dynamic routing uses agent-coordinated decision making where agents autonomously determine which specialist should handle each part of a task. This is better for open-ended problems where the optimal workflow emerges from the task itself.

The combination of both modes within a single system is one of ADK's strongest features. A workflow agent can handle the deterministic parts of a process while delegating ambiguous decisions to dynamically routed sub-agents, giving teams the best of both structured and adaptive approaches.

Graph-Based Workflow Runtime

ADK 2.0 introduced a graph-based execution engine that represents agent workflows as directed graphs. Each node in the graph is an agent, tool, or decision point, and edges define the flow of execution between them. This architecture supports routing (directing execution down different paths based on conditions), fan-out (sending work to multiple agents simultaneously), fan-in (aggregating results from parallel agents), loops (repeating sections of the workflow until a condition is met), retry logic (automatically re-executing failed nodes), state management (persisting data across nodes), and nested workflows (embedding sub-graphs within larger graphs).

The graph-based approach provides several advantages over pure LLM-driven orchestration. Workflows are deterministic and reproducible, meaning the same input always produces the same execution path. They are debuggable because each node's inputs and outputs can be inspected individually. They are optimizable because bottlenecks can be identified through execution traces. And they are governable because compliance and audit requirements can be enforced at the graph level.

Task API and Delegation

The Task API provides structured agent-to-agent delegation with clearly defined interfaces. When one agent delegates a task to another, the Task API specifies what information is passed, what output format is expected, and how the result is integrated back into the delegating agent's workflow.

Four delegation patterns are supported. Multi-turn task mode allows extended conversations between the delegating agent and the specialist. Single-turn controlled output constrains the specialist to a single response in a specific format. Mixed delegation combines both patterns within a workflow. Task agents as workflow nodes embed delegation directly into graph-based workflows, treating each specialist as a node that receives inputs and produces outputs.

Human-in-the-loop is built into the Task API as a first-class concern. Any task can require human approval before execution, human review after execution, or human input at specific decision points. This makes ADK well-suited for enterprise processes where full automation is not appropriate or not yet trusted.

Context Management

Managing context across multiple agents working on related tasks is a significant engineering challenge. ADK addresses this through automatic context management that filters irrelevant events from each agent's context window, summarizes older conversational turns to preserve essential information within token limits, lazy-loads artifacts so that large data objects are only retrieved when an agent actually needs them, and tracks token usage across the entire agent team to prevent unexpected cost spikes.

The context management system is aware of the multi-agent topology, meaning it understands which agents need which information. A research agent's detailed findings might be summarized before being passed to a decision-making agent that only needs the key conclusions. This intelligent context routing reduces token consumption and improves agent performance by keeping each agent's context focused on relevant information.

Google Cloud Deployment

While ADK can run anywhere Python runs, its deepest deployment integrations are with Google Cloud. When deploying via Agent Runtime (part of the Gemini Enterprise Agent Platform), Cloud Run, or GKE, agents automatically inherit managed infrastructure that handles scaling, load balancing, and failure recovery. Built-in authentication integrates with Google's IAM system. Cloud Trace provides distributed tracing across the entire agent team. And enterprise-grade security features including VPC Service Controls and data loss prevention are available through standard Google Cloud configurations.

For organizations already invested in Google Cloud, ADK deployment requires minimal additional infrastructure setup. The framework handles containerization, service mesh configuration, and inter-agent communication automatically. For organizations using other cloud providers, ADK can be deployed on any Kubernetes cluster or as standalone Python processes, but the deployment experience is less polished.

Model Flexibility

ADK is designed to work with multiple model providers, though its primary integration and best performance come from pairing with Gemini models. The framework supports using different models for different agents within the same system, which is useful for cost optimization. A triage agent might use the affordable Gemini 3 Flash, while a complex reasoning agent uses Gemini 3.1 Pro, and a simple formatting agent uses an even cheaper model.

MCP support was added in early 2026, allowing ADK agents to connect to the standard ecosystem of MCP tool servers. The tool system also supports Google Cloud-specific integrations (BigQuery, Cloud Storage, Vertex AI) and custom Python functions as tools.

Evaluation and Testing

ADK includes built-in evaluation tools that let developers test agent behavior systematically. Test cases can be defined as input-output pairs with expected behaviors, and the evaluation framework runs the agent against these cases while measuring accuracy, latency, cost, and tool usage patterns. This is particularly valuable for enterprise deployments where agent behavior must be validated against compliance requirements before going to production.

The evaluation framework integrates with the graph-based workflow engine, allowing developers to test individual workflow nodes in isolation as well as end-to-end workflows. This granular testing approach makes it easier to identify which part of a complex multi-agent system is responsible for unexpected behavior, rather than debugging the entire system as a black box.

Limitations

ADK is Python-only with no TypeScript SDK currently available or announced. This limits its adoption among web development teams and organizations that standardize on JavaScript or TypeScript for their backend services.

The framework's sophistication comes with a steeper learning curve compared to the Claude or OpenAI SDKs. Understanding the graph-based workflow engine, Task API patterns, and multi-agent coordination model requires more upfront investment than defining a simple agent with tools. For straightforward single-agent use cases, ADK may be more framework than you need.

While ADK is open source and can theoretically use any model, the best performance and deepest feature integration comes from Gemini models. Teams committed to non-Google models may find that some ADK features work less smoothly or require additional configuration.