Google ADK — The Open-Source Framework for Building Production AI Agents

Posted on: 5/7/2026 3:21:58 AM

As the AI Agent wave exploded throughout 2025–2026, every vendor and framework offered their own approach: LangChain/LangGraph for the Python community, Semantic Kernel for the .NET ecosystem, CrewAI for role-based agents. The common problem? Each framework manages context, tools, memory and orchestration differently — and they're virtually incompatible with each other. Google Agent Development Kit (ADK) launched in mid-2025 with a bigger ambition: not just another framework, but an open platform natively integrating both MCP (tool access) and A2A (agent-to-agent communication), supporting multiple languages (Python, TypeScript, Go, Java) and deploying from local to Google Cloud with a single command.

This article dives deep into ADK's architecture, agent type system, tool integration, context management and production patterns — the framework rapidly becoming the top choice for teams building enterprise multi-agent systems.

1. What is Google ADK and Why Should You Care?

Agent Development Kit (ADK) is Google's open-source framework for building, debugging and deploying AI agents at enterprise scale. Unlike frameworks focused on a single language or model, ADK is designed with a model-agnostic and protocol-native philosophy:

• Model-agnostic: Supports Gemini, Claude, Ollama, vLLM, LiteLLM — switch models with a single config line
• Protocol-native: Integrates MCP for tool/data access and A2A for agent-to-agent communication directly in the core, no third-party plugins needed
• Multi-language: Official SDKs for Python (google-adk), TypeScript (@google/adk), Go (google.golang.org/adk), Java (com.google.adk:google-adk)
• Deployment-ready: From local dev (Web UI, CLI, API Server) to Google Cloud (Agent Runtime, Cloud Run, GKE) without changing code

2. ADK Core Architecture

ADK is built on four pillars: Agents (processing units), Tools (external interaction capabilities), Sessions (conversation context) and Memory (long-term knowledge). Each pillar is modular — you can replace any component with a custom implementation without affecting the rest.

graph TB
    subgraph ADK["Google ADK Framework"]
        direction TB
        subgraph Agents["Agent Layer"]
            LLM["LlmAgent
Reasoning + Tool calling"]
            SEQ["SequentialAgent
Step-by-step execution"]
            PAR["ParallelAgent
Concurrent execution"]
            LOOP["LoopAgent
Iterate until done"]
            CUSTOM["CustomAgent
Custom logic"]
        end
        subgraph Tools["Tool Layer"]
            FT["FunctionTool
Python/TS/Go functions"]
            MCPT["MCPTool
MCP Servers"]
            A2AT["AgentTool
A2A Protocol"]
            OAPI["OpenAPI Tool
REST APIs"]
            GS["GoogleSearchTool"]
        end
        subgraph Context["Context Layer"]
            SESS["Sessions
Conversation + State"]
            MEM["Memory
Cross-session learning"]
            ART["Artifacts
Large files & data"]
        end
    end
    Agents --> Tools
    Agents --> Context
    style ADK fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50
    style Agents fill:#fff,stroke:#e94560,color:#2c3e50
    style Tools fill:#fff,stroke:#4CAF50,color:#2c3e50
    style Context fill:#fff,stroke:#2196F3,color:#2c3e50
    style LLM fill:#e94560,stroke:#fff,color:#fff
    style SEQ fill:#f8f9fa,stroke:#e94560,color:#2c3e50
    style PAR fill:#f8f9fa,stroke:#e94560,color:#2c3e50
    style LOOP fill:#f8f9fa,stroke:#e94560,color:#2c3e50
    style CUSTOM fill:#f8f9fa,stroke:#e94560,color:#2c3e50
    style FT fill:#f8f9fa,stroke:#4CAF50,color:#2c3e50
    style MCPT fill:#4CAF50,stroke:#fff,color:#fff
    style A2AT fill:#4CAF50,stroke:#fff,color:#fff
    style OAPI fill:#f8f9fa,stroke:#4CAF50,color:#2c3e50
    style GS fill:#f8f9fa,stroke:#4CAF50,color:#2c3e50
    style SESS fill:#f8f9fa,stroke:#2196F3,color:#2c3e50
    style MEM fill:#2196F3,stroke:#fff,color:#fff
    style ART fill:#f8f9fa,stroke:#2196F3,color:#2c3e50

Figure 1: Google ADK's three-layer architecture — Agents, Tools and Context

2.1. Agent Type System

ADK provides five built-in agent types, each serving a different orchestration pattern:

2.2. Tool System — MCP, A2A and Function Tools

ADK supports five tool types, with three particularly noteworthy:

FunctionTool — Turns any Python/TypeScript/Go/Java function into an agent-callable tool. ADK auto-generates JSON Schema from type annotations and docstrings, no manual schema writing needed:

from google.adk import Agent, FunctionTool

def get_weather(city: str, unit: str = "celsius") -> dict:
    """Get current weather for a city."""
    return {"city": city, "temp": 28, "unit": unit}

agent = Agent(
    model="gemini-2.5-flash",
    name="weather_agent",
    instructions="You are a weather assistant.",
    tools=[FunctionTool(get_weather)]
)

MCPTool — Connects directly to any MCP Server (filesystem, database, GitHub, Slack...). Instead of writing wrappers for each API, agents use MCPTool to access hundreds of existing MCP servers in the ecosystem:

from google.adk.tools.mcp import MCPTool

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

AgentTool (A2A) — Allows agents to call other agents via the A2A protocol, even agents built with different frameworks (LangGraph, CrewAI, Semantic Kernel). This is what makes ADK unique — it doesn't lock you into a single ecosystem:

from google.adk.a2a import A2AClient

# Call an external pricing agent via A2A
pricing_client = A2AClient("https://pricing-agent.example.com")
result = await pricing_client.send_task(
    "Check wholesale price for 500kg Robusta coffee"
)

graph LR
    ADK_AGENT["ADK Agent
(Orchestrator)"]
    ADK_AGENT -->|"FunctionTool"| LOCAL["Local Functions
Python/TS/Go"]
    ADK_AGENT -->|"MCPTool"| MCP_S["MCP Servers
GitHub, DB, Slack..."]
    ADK_AGENT -->|"AgentTool (A2A)"| EXT["External Agents
LangGraph, CrewAI..."]
    ADK_AGENT -->|"OpenAPI Tool"| REST["REST APIs
Any endpoint"]
    ADK_AGENT -->|"GoogleSearchTool"| SEARCH["Google Search
Real-time web data"]
    style ADK_AGENT fill:#e94560,stroke:#fff,color:#fff
    style LOCAL fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50
    style MCP_S fill:#4CAF50,stroke:#fff,color:#fff
    style EXT fill:#2196F3,stroke:#fff,color:#fff
    style REST fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50
    style SEARCH fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50

Figure 2: Five tool types in ADK — from local functions to remote agents via A2A

2.3. Session, Memory and Artifacts

ADK handles context across three distinct tiers:

Session — Represents an ongoing conversation. Each session contains message history, state (temporary key-value store) and an event list. ADK supports rewind (rollback to previous state) and migrate (transfer session to another agent) — extremely useful for handoff scenarios between specialized agents.

Memory — Long-term knowledge spanning multiple sessions. ADK allows configurable memory strategies (in-memory, file-based, or external store). Agents can learn from previous sessions without stuffing the entire history into the context window — solving the Context Rot problem many other frameworks face.

Artifacts — Manages large files and data (images, PDFs, datasets). Instead of stuffing binaries into context, ADK lazy-loads artifacts only when the agent actually needs them — saving tokens and keeping the context window clean.

3. Multi-Agent Orchestration Patterns

ADK's true power emerges when building systems with multiple coordinating agents. Here are the three most common production patterns:

3.1. Hierarchical Delegation

An orchestrator agent receives user requests, analyzes them and delegates to specialized agents. This pattern suits complex systems like customer support, code generation, or research:

graph TD
    USER["User Request"] --> ORCH["Orchestrator Agent
(LlmAgent)"]
    ORCH -->|"Technical question"| TECH["Tech Support Agent
Tools: docs, codebase"]
    ORCH -->|"Orders/billing"| BILL["Billing Agent
Tools: payment API, CRM"]
    ORCH -->|"Feedback/complaint"| FEED["Feedback Agent
Tools: ticket system"]
    TECH --> RESP["Aggregated Response"]
    BILL --> RESP
    FEED --> RESP
    RESP --> USER
    style USER fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50
    style ORCH fill:#e94560,stroke:#fff,color:#fff
    style TECH fill:#2c3e50,stroke:#fff,color:#fff
    style BILL fill:#2c3e50,stroke:#fff,color:#fff
    style FEED fill:#2c3e50,stroke:#fff,color:#fff
    style RESP fill:#4CAF50,stroke:#fff,color:#fff

Figure 3: Hierarchical Delegation — orchestrator distributes work to specialized agents

3.2. Pipeline (Sequential)

Data flows through a chain of agents, each processing and enriching before passing forward. Example content creation pipeline:

from google.adk import Agent, SequentialAgent

researcher = Agent(name="researcher", model="gemini-2.5-pro",
    instructions="Research the topic and gather facts.",
    tools=[google_search, web_scraper])

writer = Agent(name="writer", model="gemini-2.5-flash",
    instructions="Write an article from research notes.",
    tools=[])

reviewer = Agent(name="reviewer", model="gemini-2.5-pro",
    instructions="Review the article, suggest improvements.",
    tools=[])

pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[researcher, writer, reviewer]
)

3.3. Fan-out / Fan-in (Parallel)

When you need to gather information from multiple sources simultaneously — calling multiple APIs, searching across databases, or analyzing documents in parallel:

from google.adk import Agent, ParallelAgent

price_checker = Agent(name="price_checker", ...)
review_analyzer = Agent(name="review_analyzer", ...)
inventory_checker = Agent(name="inventory_checker", ...)

market_research = ParallelAgent(
    name="market_research",
    sub_agents=[price_checker, review_analyzer, inventory_checker]
)
# Three agents run concurrently, results aggregated when all complete

4. Skills — On-Demand Expertise

One of ADK's most distinctive features is SkillToolset — an on-demand expertise loading system using a progressive disclosure model across three tiers, reducing baseline token usage by approximately 90% per agent.

SkillToolset automatically creates three tools for the agent: list_skills (browse L1 menu), load_skill (load L2 instructions) and load_skill_resource (load L3 reference docs). The agent decides when it needs which skill — no hard-coded logic required.

Skills follow the agentskills.io specification — the same format supported by Gemini CLI, Claude Code, Cursor and 40+ other products. This means skills you write for ADK can be reused in other tools without modification:

# skills/seo-checker/SKILL.md
---
name: seo-checker
description: Check and suggest SEO optimizations for blog posts
---

## Instructions
1. Read the article content from context
2. Check: title length, meta description, heading hierarchy, internal links
3. Score SEO from 0-100
4. Suggest specific improvements for each failing criterion

5. Deployment and Evaluation

5.1. Deployment Options

ADK supports deployment at multiple levels, from development to enterprise production:

Local Development: ADK includes a Web UI (visual debugging interface), CLI chat interface and API Server for integration. The Web UI lets you inspect each reasoning step, view tool calls, state changes and token usage — invaluable during development.

Google Cloud — Agent Runtime: Deploy with a single command; agents automatically receive managed infrastructure, built-in authentication, Cloud Trace observability and enterprise-grade security. No code changes needed compared to the local version.

Containerized (Cloud Run / GKE): Package agents as Docker containers and deploy to Cloud Run (serverless, auto-scaling) or GKE (Kubernetes, maximum control). This pattern suits teams with existing CI/CD pipelines.

Ambient Agents: A new ADK pattern — agents running in the background, listening to events (webhooks, message queues, cron) and reacting automatically. Example: an agent monitoring a Slack channel, auto-detecting and answering technical questions when tagged.

5.2. Evaluation Framework

ADK integrates an evaluation framework for testing agents before production deployment:

• Custom Criteria: Define custom evaluation criteria (accuracy, relevance, format compliance...)
• User Simulation: Create synthetic users to test conversation flows
• Environment Simulation: Mock external services for deterministic testing
• Metrics Dashboard: Token usage, latency, success rate, tool call patterns

6. ADK vs Other AI Agent Frameworks

7. ADK in the Protocol Stack — MCP + A2A = Complete Ecosystem

One of the key reasons ADK stands out is how it integrates both standard protocols of the AI Agent ecosystem:

graph TB
    subgraph Stack["Protocol Stack for AI Agents"]
        direction TB
        A2A_L["A2A Protocol
Agent ↔ Agent Communication"]
        MCP_L["MCP Protocol
Agent ↔ Tool/Data Access"]
        ADK_L["Google ADK
Agent Framework + Orchestration"]
        INFRA["Infrastructure
Cloud Run · GKE · Local"]
    end
    A2A_L --> ADK_L
    MCP_L --> ADK_L
    ADK_L --> INFRA
    style Stack fill:#f8f9fa,stroke:#e0e0e0,color:#2c3e50
    style A2A_L fill:#2196F3,stroke:#fff,color:#fff
    style MCP_L fill:#4CAF50,stroke:#fff,color:#fff
    style ADK_L fill:#e94560,stroke:#fff,color:#fff
    style INFRA fill:#2c3e50,stroke:#fff,color:#fff

Figure 4: Protocol stack — ADK is the orchestration layer connecting MCP (tool access) and A2A (agent communication)

MCP solves "how do agents access tools/data" — a single connection standard for hundreds of data sources (databases, file systems, APIs, SaaS tools). A2A solves "how do agents talk to other agents" — enabling agents from different frameworks and vendors to discover, delegate tasks and coordinate work. ADK is the orchestration layer in between, turning both protocols into tools any agent can use immediately.

8. Getting Started with ADK

Installation and running your first agent takes just a few minutes:

# Install ADK
pip install google-adk

# Create a new project
adk init my-first-agent
cd my-first-agent

# Launch Web UI for debugging
adk web

# Or chat directly via CLI
adk chat

Sample agent.py for a simple agent:

from google.adk import Agent

def search_products(query: str, max_results: int = 5) -> list:
    """Search products by keyword."""
    # Actual search logic here
    return [{"name": f"Product {i}", "price": 100 + i * 10} for i in range(max_results)]

root_agent = Agent(
    model="gemini-2.5-flash",
    name="shopping_assistant",
    instructions="""You are a smart shopping assistant.
    Help customers find products matching their needs and budget.""",
    tools=[search_products]
)

Deploy to Cloud Run:

# Single command for production deployment
adk deploy cloud-run \
    --project my-gcp-project \
    --region asia-southeast1 \
    --service-name shopping-agent

9. Conclusion

Google ADK isn't the only AI Agent framework, but it is the first to natively integrate both MCP and A2A, support multiple languages, and provide a seamless deployment path from local to cloud. Its progressive disclosure philosophy — simple for single agents, expandable to complex multi-agent orchestration without re-architecting — makes ADK suitable for both rapid prototyping and enterprise production systems.

With support from over 150 organizations in the A2A ecosystem, multi-language SDKs, and a Skills system following the agentskills.io standard, ADK is shaping how we build and deploy AI Agents in the second half of 2026 and beyond.

References

• Google ADK — Official Documentation
• ADK Python SDK — GitHub Repository
• Developer's Guide to Building ADK Agents with Skills — Google Developers Blog
• A2A Protocol — Official Specification
• Developer's Guide to AI Agent Protocols — Google Developers Blog
• A2A Protocol Upgrade Announcement — Google Cloud Blog