open-agency.io
Back to all guides
Getting Started with Google ADK: Build Your First AI Agent thumbnail
Guidebeginner#google-adk#ai-agents#open-source

Getting Started with Google ADK: Build Your First AI Agent

Google's Agent Development Kit is an open-source framework for building AI agents. Here's what it does, why it matters, and how to run your first agent in under 10 minutes.

Published
Jun 7, 2026
Reading time
8 min read

Getting Started with Google ADK: Build Your First AI Agent

AI agents are having a moment. Every week there is a new framework, a new SDK, another company announcing their agent platform. If you are just starting out, the noise is overwhelming. Google's Agent Development Kit cuts through some of it.

ADK is open-source, works with multiple AI models, and lets you define agents in code instead of dragging boxes around a GUI. It was announced at Google Cloud NEXT 2025 and reached version 2.0 in May 2026. The same framework runs Google's own products like Agentspace and the Customer Engagement Suite. That is a strong signal that it is built for real use, not just demos.

Here is what you need to know to get started.

What ADK Actually Is

Think of ADK as a toolkit for building software that can make decisions, use tools, and collaborate with other agents. Instead of wiring up API calls to a language model and hoping for the best, you define agents with clear instructions, tools, and boundaries.

A single ADK agent is simple. You give it a name, pick a model, write an instruction, and optionally attach tools. The framework handles the rest: calling the model, managing conversation context, executing tool calls, and keeping state.

typescriptShiki server render
from google.adk import Agent

root_agent = Agent(
    name="greeting_agent",
    model="gemini-2.5-flash",
    instruction="You are a helpful assistant that answers questions clearly.",
)

That is a working agent. Four lines of code.

Why Agents Are Different From Chatbots

You have probably used ChatGPT or Gemini. Type a question, get an answer. That is a chat interaction. An agent does more.

Agents can use tools. They can search the web, run code, query databases, or call APIs. They can remember what happened across multiple conversations. They can delegate tasks to other agents that specialize in different areas.

A chatbot answers. An agent acts.

Here is a slightly more useful example. An agent with a search tool:

typescriptShiki server render
from google.adk import Agent
from google.adk.tools import google_search

research_agent = Agent(
    name="researcher",
    model="gemini-2.5-flash",
    instruction="Research topics thoroughly using web search. Cite your sources.",
    tools=[google_search],
)

This agent can search the web in real time. When you ask a question, it decides whether to call the search tool, reads the results, and incorporates them into its answer. You did not write any search API code. ADK provides the tool.

How Multi-Agent Systems Work

The real power of ADK is not single agents. It is what happens when you combine multiple agents into a team.

Instead of building one agent that tries to do everything, you create specialists. A travel booking system might have a FlightAgent, a HotelAgent, and a SightseeingAgent. A coordinator agent routes requests to the right specialist.

typescriptShiki server render
flight_agent = Agent(
    name="FlightAgent",
    model="gemini-2.5-flash",
    instruction="You handle flight bookings and flight information only.",
    description="Handles flight booking and information",
)

hotel_agent = Agent(
    name="HotelAgent",
    model="gemini-2.5-flash",
    instruction="You handle hotel bookings and hotel information only.",
    description="Handles hotel booking and information",
)

root_agent = Agent(
    name="TripPlanner",
    model="gemini-2.5-flash",
    instruction="Coordinate the trip planning. Delegate to specialists.",
    sub_agents=[flight_agent, hotel_agent],
)

When a user says "Book a flight to Paris and find a hotel near the Eiffel Tower," the root agent sends the flight part to the FlightAgent and the hotel part to the HotelAgent. Each specialist focuses on what it does best.

This pattern scales. You can add more specialists, run tasks in parallel, or add a review step where one agent checks another agent's output.

Running Your Agent

ADK gives you three ways to run your agent:

  • adk web opens a browser UI where you can chat with your agent and inspect every step
  • adk run starts a terminal chat session
  • adk api exposes your agent as a REST API

The web UI is particularly useful when you are learning. You can see exactly what the model decided, which tools it called, and how it routed tasks between sub-agents.

bashShiki server render
pip install google-adk
adk create my_first_agent
cd my_first_agent
adk web

The adk create command scaffolds a project with the right structure. Edit agent.py, set your Gemini API key in .env, and run adk web. Your agent is live at localhost:8000.

What You Can Connect

ADK agents are not limited to Google's platform. Through LiteLLM integration, you can use models from Anthropic, Meta, Mistral, OpenAI, or run local models with Ollama. The same agent code works with any supported model.

Tools are equally flexible. ADK supports:

  • Pre-built tools like Google Search and Code Execution
  • Custom Python functions that wrap any business logic
  • MCP servers for connecting to external data sources and services
  • OpenAPI specs that auto-generate tools from existing APIs
  • Sub-agents as tools using the Task API

The Model Context Protocol is particularly useful. It standardizes how agents connect to tools. A tool built as an MCP server works with ADK, Claude, and any other MCP-compatible framework without changes.

Where To Go Next

Running your first agent takes minutes. Building a production system takes more thought. Start with one agent and one tool. Get that working. Then add a second agent. Then add parallel execution. ADK grows with you.

The official documentation at google.github.io/adk-docs has quickstarts for all five languages. The ADK samples repository on GitHub has ready-to-run examples. The community call schedule and Discord are good places to ask questions when you get stuck.

Understanding Agent Context and Memory

One thing that surprises new ADK users is how the framework handles conversation context.

In a simple chatbot, every message goes into the prompt until you hit the token limit. ADK does something smarter. It automatically filters out irrelevant events, summarizes older conversation turns, and lazy-loads large artifacts. Your agent stays fast even after long conversations.

You can control this behavior. The context management system lets you set compaction intervals, choose summarization models, and decide what gets preserved. For most use cases the defaults work fine. When you build agents that process large documents or run long workflows, knowing how to tune context management becomes important.

The Evaluation Tooling

Shipping an agent without testing it is a bad idea. ADK ships with built-in evaluation tools that let you define test cases and measure whether your agent produces the right outputs.

You can create evaluation datasets, run them against your agent, and inspect which test cases passed or failed. This catches regressions when you change prompts, swap models, or add new tools. The evaluation runner works in the web UI and from the command line.

For a beginner project, start with five to ten test cases covering the main paths your agent should handle. Expand the test suite as your agent grows.

Deployment Options

When you are ready to share your agent, ADK gives you several options.

For personal use or internal tools, adk web sets up a local server that teammates can access. For production, you can deploy to Cloud Run with a single command, containerize for GKE, or use the Agent Runtime on Google Cloud for a fully managed experience.

Each deployment path adds different capabilities. Cloud Run gives you automatic scaling and a managed SSL certificate. GKE gives you Kubernetes-level control over resources, scaling policies, and security configuration. The Agent Runtime handles sessions, memory, and observability as a managed service.

You are not locked into Google Cloud. ADK is Apache 2.0 licensed. Containerize your agent and run it on any infrastructure.

A Note on Language Support

Most agent frameworks are Python-only. ADK ships stable SDKs for Go and Java alongside Python and TypeScript, with a Kotlin SDK in beta. If your team builds backend services in Go or Java, you can write agent logic in the same language as the rest of your stack.

The Go SDK is particularly relevant for teams running on GKE. Go agents compile to a single binary with minimal dependencies, which means smaller containers and faster startup times. The APIs are idiomatic for each language, not translated from Python patterns.

Wrapping Up

Start with one agent, one tool, one test case. Run it in the web UI and watch what happens. Then add a specialist agent. Then try parallel execution. ADK lets you grow gradually.

The quickest path to frustration is trying to build everything at once. A team of two specialized agents with one tool each beats a monolithic agent with ten tools and a thousand-word instruction.

One practical tip: keep your agent descriptions explicit. The root agent uses these descriptions to decide which sub-agent should handle a task. Vague routing leads to wrong answers. "Handles hotel booking and cancellation for standard and premium reservations" works much better than "Handles hotels."

ADK is not the simplest framework for a quick demo. CrewAI wins there. It does not have the widest integration library either. LangGraph holds that title. But for building agents that actually run in production, especially if your infrastructure runs on Google Cloud, ADK earns its place in your toolbox.