From OpenAI’s browser and code interpretation capabilities to Anthropic’s Claude, we are on a thrilling journey as AI moves from single-agent models to complex collaborative multi-agent systems.

However, developing these complex systems has traditionally required deep AI knowledge, significant development time, and complex coordination efforts.

Until Google launched the Agent Development Kit (ADK) at the Google Cloud NEXT conference in 2025. ADK is an open source framework that enables users to quickly build agents and multi-agent systems, covering intuitive and advanced application scenarios.

ADK is an important step in the democratization of Agent technology.

It provides developers with a wide range of tools and techniques for implementing, testing, and deploying intelligent agents that can solve complex tasks independently or in collaboration with other agents.

What’s particularly exciting about ADK is that it’s the same framework that powers Agents inside Google products, like Agentspace and Google Customer Engagement Suite (CES).

In this article, we will focus on the practical aspects of ADK and how developers can use this toolkit to implement powerful multi-agent applications.

We will walk you through the process of building your first agent, explore the rich ecosystem of available tools and models, and highlight real-world applications where the ADK can have an immediate impact.

By the end, you'll have a solid understanding of how the ADK can revolutionize the way you develop intelligent systems!

Understanding ADK: Core Capabilities

1. Flexible and combinable : Freely select components and structured assemble agent systems without model/method restrictions.

2. Multi-agent architecture : supports collaboration and task delegation among agents to achieve complex goals (such as professional AI teams).

3. Model independence : compatible with multiple source models (Gemini/Claude/Llama, etc.), integrated with Vertex AI and LiteLLM.

4. Rich tool ecosystem : built-in common tools (search/code execution), support for external libraries such as LangChain, and support for Agent nesting (layered architecture).

5. Two-way streaming support : built-in audio and video streaming to achieve multi-modal natural interaction.

6. Flexible orchestration : Combines structured workflow (sequential/parallel/cyclic) with LLM dynamic routing to balance reliability and adaptability.

Building ADKAgent

Let's dive into a real-world example built using the ADK. The easiest way to understand the power of the ADK is to create a basic agent. We'll start with a simple question-answering agent that is able to answer queries using Google Search.

Setting up your environment

Before you write any code, you need to set up your development environment. The ADK is a Python framework, so you'll need Python 3.8+ installed. Here's how to get started:

# Create a virtual environment
python -m venv adk-env


# Activate the environment
source adk-env/bin/activate # On Windows: adk-env\Scripts\activate


# Install ADK
pip install google-adk


# Verify installation
adk --version

A simple question-answering agent

Now, let's create a basic Agent that can answer questions using Google Search. This demonstrates the simplicity of the ADK while also showing its integration with external tools:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search


# Define our question-answering Agent
qa_agent = LlmAgent(
    model="gemini-2.0-flash-exp", # Specify which LLM to use
    name="question_answer_agent", # Give our Agent a unique name
    description="A helpful assistant agent that can answer questions using search.",
    instruction="""Use Google Search to respond to user queries requiring factual information.
    Be brief, direct, and to the point in your responses. """,
    tools=[google_search], # Provide search tools
)


# Save this as a file called agent.py
# You can run it with the following command: adk web

This code creates a simple Agent powered by Gemini 2.0 Flash that searches the web to answer questions. The simplicity of the ADK is apparent - with just a few lines of code, we have created an Agent with web search capabilities.

Agent Interaction

The ADK provides multiple ways to interact with the Agent. The fastest way is to use the CLI or the Web UI. To start the Web UI, run:

# Run Agent using the web interface
adk web

This will start a local web server with a chat interface where you can interact with your Agent. The Web UI also provides debugging tools that allow you to see exactly what is happening under the hood, including state transitions, tool calls, and a full execution trace.

Building a multi-agent system

While single agents are useful, the real strength of the ADK is in building multi-agent systems where specialized agents collaborate. Let’s now build a more flexible and advanced setup where multiple agents are able to delegate parts of the conversation to each other.

Weather Assistant System

We will build a weather assistant system with three specialized agents: the main weather agent will answer weather queries, the greeting agent will respond to welcome messages, and the farewell agent will respond to farewell messages. The main agent will hand off tasks to the specialized agents when appropriate. Here is the sample Python code that illustrates how these agents are set up:

from  google.adk.agents  import  Agent
from  google.litellm  import  LiteLlm


# First, let's define a tool to get weather data
def get_weather (city: str)  -> dict: 

    print( f"Get weather: {city} " )


    # Simulate weather data (in a production environment, you would call the real weather API)
    mock_weather_db = {
        "newyork" : { "status" :  "success" ,  "report" :  "New York is sunny and the temperature is 25°C." },
        "london" : { "status" :  "success" ,  "report" :  "Cloudy, 15°C in London." },
        "tokyo" : { "status" :  "success" ,  "report" :  "Tokyo is experiencing light rain and the temperature is 18°C." },
    }


    city_normalized = city.lower().replace( " " ,  "" )


    if  city_normalized  in  mock_weather_db:
        return  mock_weather_db[city_normalized]
    else :
        return  { "status" :  "error" ,  "error_message" :  f"Sorry, I don't have weather information for ' {city} '." }


# Define specialized Agents for different tasks
greeting_agent = Agent(
    model=LiteLlm(model= "anthropic/claude-3-sonnet-20240229" ),
    name = "greeting_agent" ,
    instruction = "You are the Greeting Agent. Your only task is to provide a friendly greeting to the user."
               "Do not participate in any other conversations or quests." ,
    description = "Handles simple greetings and hellos" ,
)


farewell_agent = Agent(
    model=LiteLlm(model= "anthropic/claude-3-sonnet-20240229" ),
    name = "farewell_agent" ,
    instruction = "You are the Farewell Agent. Your only task is to deliver a polite farewell message."
                "Do not perform any other actions." ,
    description= "Handle simple farewells and goodbyes" ,
)


# Define the main weather agent that can be delegated to professional agents
root_agent = Agent(
    name = "weather_agent" , 
    model= "gemini-2.0-flash-exp" ,
    description= """You are the lead Weather Agent, coordinating a team.
    - Your main task: Use the `get_weather` tool to provide weather. Handle its 'status' response ('report' or 'error_message').
    - Delegation rules:
      - If the user gives a simple greeting (like 'hi', 'hello'), delegate to `greeting_agent`.
      - If the user gives a simple farewell (like 'goodbye', 'see you next time'), delegate to `farewell_agent`.
      - Handle weather requests yourself using `get_weather`.
      - For other queries, clearly state if you are unable to handle them. """ ,
    tools=[get_weather],
    sub_agents=[greeting_agent, farewell_agent]
)


# Save as weather_agent.py
# Run with the following command: adk web --agent weather_agent.py

How Agent Delegation Works

The advantage of this system lies in the automatic delegation mechanism of ADK.

When receiving a user message, the LLM uses the query, the current agent's description, and the descriptions of related agents to perform processing. If it finds another agent that is more competent, it initiates the transfer.

For example, if the user types "hi", the root agent recognizes that "hi" is not a weather query and automatically passes control to the greeting agent. In contrast, when the user asks about the weather, the root agent directly manages it through its get_weather tool.

This ability to decompose complex systems into specialized agents with well-defined roles makes the system easier to maintain and debug. This allows each agent to focus on doing one thing well, rather than trying to handle every possible interaction.

Tool Ecosystem: Expanding Agent Capabilities

Agents need tools to interact with the world and perform useful tasks. The ADK provides a rich ecosystem of tools that can significantly expand the capabilities of your agents. Let's explore some real-world examples of how tools can enhance your agents.

Built-in tools

The ADK comes with several built-in tools that you can use right out of the box:

• Google Search: Accessing Information on the Web

• Code Execution: Safely Running Python Code

• File operations: reading, writing, and manipulating files

• HTTP Requests: Make API calls and retrieve data

Creating Custom Tools

One of the strengths of the ADK is its ability to facilitate the production of custom tools. Essentially, a tool is just a Python function with a descriptive docstring. For example, let's build a custom tool that translates text between two languages:

def translate_text(text: str, target_language: str) -> str:
    """Translates the provided text into the target language.

    Args:
        text: The text to translate
        target_language: The language code to translate to (eg, 'es', 'fr', 'ja')

    Returns:
        The translated text or an error message
    """
    # In a real application, you'd call a translation API here
    # For this example, we'll use a simple mock
    mock_translations = {
        ('hello world', 'es'): 'hola mundo',
        ('hello world', 'fr'): 'bonjour le monde',
        ('hello world', 'ja'): 'こんにちは世界',
    }

    key = (text.lower(), target_language.lower())
    if key in mock_translations:
        return mock_translations[key]
    else:
        return f"Translation not available for '{text}' to {target_language}"


# Using this tool with an agent
from google.adk.agents import LlmAgent


translator_agent = LlmAgent(
    model="gemini-2.0-flash-exp",
    name="translator_agent",
    description="A helpful assistant that can translate text between languages.",
    instruction="You are a translation assistant. Use the translate_text tool to translate text into different languages.",
    tools=[translate_text],
)

Using third-party integrations

In addition to built-in capabilities, ADK also supports integration with popular AI/ML frameworks and libraries.

# Example of integration with LangChain
from langchain.tools import Tool
from langchain.utilities import WikipediaAPIWrapper


# Create a LangChain tool for Wikipedia
wikipedia = WikipediaAPIWrapper()
wikipedia_tool = Tool(
    name="wikipedia",
    description="Search for information on Wikipedia",
    func=lambda query: wikipedia.run(query)
)


# Package it for use with ADK
from google.adk.tools import wrap_langchain_tool
adk_wikipedia_tool = wrap_langchain_tool(wikipedia_tool)


# Use in ADKAgent
from google.adk.agents import LlmAgent


research_agent = LlmAgent(
    model="gemini-2.0-flash-exp",
    name="research_agent",
    description="A research assistant that can look up information on Wikipedia.",
    instruction="You are a research assistant. Use Wikipedia to find information on the topic the user is asking about.",
    tools=[adk_wikipedia_tool],
)

This also means more flexibility to integrate tools from different ecosystems. Whether it can be natively integrated with the ADK or from other frameworks, you can use the tools that best suit any type of purpose.

System Evaluation

ADK comes with a built-in evaluation framework that enables you to thoroughly evaluate your agent using ready-made datasets. This is critical for maintainability and catching regressions before release.

// Example evaluation.test.json
[
  {
    "input": "What's the weather like in New York?",
    "expected_output": "The weather in New York will be sunny and the temperature will be 25°C."
  },
  {
    "input": "Hello!",
    "expected_output": "Hi! How can I help you today?"
  }
]

You can run the assessment programmatically or using the ADK CLI:

# Run the evaluation via the CLI
adk eval --agent-file weather_agent.py --test-file evaluation.test.json
# Or programmatically
from google.adk.eval import AgentEvaluator


evaluator = AgentEvaluator(agent=root_agent)
results = evaluator.evaluate("evaluation.test.json")
print(f"Accuracy: {results.accuracy * 100}%")
for test_case, result in zip(results.test_cases, results.results):
    print(f"Test: {test_case.input}")
    print(f"Expected: {test_case.expected_output}")
    print(f"Actual: {result.output}")
    print(f"Passed: {result.passed}")
    print("---")

Deployment options

ADK provides multiple options for deploying Agent to production environment:

Container deployment

You can containerize ADKAgent and deploy it anywhere Docker is hosted:

# Dockerfile for ADKAgent
FROM python:3.9-slim


WORKDIR /app


# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt


# Copy Agent code
COPY weather_agent.py .


# Exposed ports
EXPOSE 8080


# Run Agent
CMD ["adk", "server", "--agent", "weather_agent.py", "--port", "8080"]

Vertex AIAgent Engine

For production-grade deployments, the ADK integrates with the Vertex AIAgent engine and provides a fully managed, scalable runtime that includes enterprise-grade features such as monitoring and logging:

from google.cloud import aiplatform
from google.adk.vertex import deploy_to_vertex


# Deploy your agent to Vertex AI
deploy_response = deploy_to_vertex(
    agent_file="weather_agent.py",
    project_id="your-gcp-project",
    display_name="Weather Assistant",
    location="us-central1",
)


print(f"Agent deployed to Vertex AI: {deploy_response.resource_name}")

This deployment method is particularly beneficial for enterprise applications that need to handle large volumes of traffic while ensuring reliability and performance.

Practical Application

The flexibility of ADK makes it suitable for a variety of practical application scenarios. Let's explore several practical scenarios where ADK can bring immediate value:

1. Enterprise Knowledge Assistant

Build a multi-agent system that can search company documents, answer employee questions, and perform actions such as scheduling meetings or generating reports. This enables you to leverage the power of multiple agents (HR, IT, Finance, etc.) while maintaining a clear separation of concerns.

2. E-commerce shopping assistant

Build a shopping assistant that helps you find products, provides personalized recommendations, and guides you through the checkout process. One agent might learn product attributes, another might learn customer preferences, and a third might learn to handle the purchase process. The system can provide a smooth experience while keeping the code modular.

3. Data Analysis Workflow

Build a system of agents that enable data scientists to explore complex data sets. One agent could focus on data cleaning and preparation, another could run statistical analysis, and a third might generate visualizations and reports. By breaking down the complex data analysis process into discrete steps handled by specialized agents, a more powerful and maintainable system can be created.

4. Educational counselor

Develop an adaptive tutoring system where different agents handle different subjects or learning styles. Coordinator agents can assess students’ needs and assign them to the right professional tutors. This approach allows for personalized education at scale, with each business unit focusing on its area of ​​excellence.

in conclusion

Google's Agent Development Kit represents an important step in making multi-agent AI systems accessible to developers.

By providing a structured framework with built-in tools for building, testing, and deploying agents, the ADK removes many of the barriers that have traditionally made agent development challenging.

The practical benefits of the ADK are clear: faster development through high-level abstractions, more reliable systems through built-in evaluation tools, and flexible deployment options to suit different needs.

The ability to create modular, specialized agents that can collaborate effectively opens up new possibilities for AI applications across industries.

As the AI ​​landscape continues to evolve toward more agent-based systems, frameworks like the ADK will play a key role in democratizing access to these technologies.

Whether you are building a simple assistant or a complex multi-agent system, the ADK provides the building blocks you need to create intelligent, useful applications, reducing effort and increasing flexibility.