I’ve been building Generative AI-powered Agentic AI Systems since April 2024. Over the course of this time, I’ve worked hands-on with a variety of frameworks – including AutoGen, LangGraph, CrewAI, and others – and I have seen both the potential and the pain points of designing real-world agentic applications.
So, when Google announced the Agent Development Kit (ADK) at Google Cloud NEXT 2025, it immediately caught my attention.
Google ADK is a brand-new, open-source framework built to simplify the end-to-end development of both single and multi-agent systems. And after diving deep into it, I have to say: it’s an exciting new contender in the agentic AI space.
From its modular architecture and workflow orchestration tools to its streamlined developer experience and native support for evaluation, ADK brings a lot to the table, stringing together best-in-class concepts from across the Agentic AI landscape. In this post, I’ll scratch the surface and walk through the standout features that make Google ADK a powerful ally for developers building robust, scalable Agentic AI systems.
Multi-Agent by Design
Google’s ADK (Agent Development Kit) is built from the ground up to support Multi-Agent Systems (MAS) – a design approach where multiple agents, each with a specific role or capability, work together to solve a larger, more complex problem. This design brings clear benefits like improved modularity (you can break systems into smaller parts), specialization (each agent does one thing well), reusability, and easier maintenance.
At the core, ADK offers essential building blocks called primitives – think of them as the foundation pieces used to design how agents interact and collaborate.
Using these primitives, you can implement well-known collaboration patterns such as:
- Coordinator/Dispatcher: One agent delegates work to others.
- Sequential Pipeline: Tasks flow step-by-step through agents.
- Parallel Fan-Out/Gather: Run tasks in parallel, then combine the results.
- Hierarchical Task Decomposition: Break down a complex task into subtasks managed by different agents.
- Review/Critique (Generator-Critic): One agent generates output, another critiques it.
- Iterative Refinement: Agents improve results over multiple cycles.
- Human-in-the-Loop: Integrates human feedback into the workflow.
ADK makes orchestration straightforward. You can build predictable flows using workflow agents like Sequential, Parallel, or Loop, or go dynamic with LLM-powered routing, where the system adapts in real time based on the environment it is operating in.
Rich Model Ecosystem
Google’s ADK is designed to work seamlessly with a wide variety of AI models – whether you’re using Google’s own offerings or looking beyond. For models tightly integrated with Google Cloud – like Gemini models accessed through Google AI Studio or Vertex AI – you simply pass the model name or the endpoint’s resource string directly to the agent. It’s plug-and-play for those already using Google’s AI infrastructure.
ADK also supports a broader ecosystem of models from providers like Anthropic, Meta, Mistral AI, AI21 Labs, and even models running locally using tools like Ollama! This allows you to leverage Small Language Models (SLM’s) and combine multiple models with a specific model to a solve specific problem!
This flexibility is made possible through first-class integration with LiteLLM, a lightweight library that acts as a unified interface for many LLM providers. In simple terms, LiteLLM lets you swap in the models you want without having to write new integration code every time.
Need full control, lower costs, improved data privacy, or offline capabilities? ADK + LiteLLM lets you run open-source models locally or self-host them – giving you the freedom to architect your systems the way you want.
Rich Tool Ecosystem
What really sets agentic AI systems apart (from regular Generative AI applications) is their ability to interact with their environment – both by observing (sensing) and taking action (affecting) their environment. This is made possible through Tool Calling, a core feature that allows agents to use external functions or services.
Google’s ADK stands out with broad and flexible support for tools across several categories:
Built-in Tools
These are ready-to-use tools like Google Search and code executors that give agents basic powers out of the box.
Note: Currently, there’s a limitation – only one built-in tool can be attached per root agent, and they can’t be freely used inside sub-agents (agents nested within others).
Third-Party Tools
ADK makes it easy to plug in tools from popular frameworks like CrewAI, LlamaIndex, or LangChain.
MCP Servers
ADK offers first-class support for MCP (Model Context Protocol), allowing agents to act as MCP clients. In simple terms, this means an ADK agent can use tools exposed by external MCP servers.
For the uninitiated, MCP follows a client-server architecture, defining how data (resources), interactive templates (prompts), and actionable functions (tools) are exposed by an MCP server and consumed by an MCP client (which could be an LLM host application or an AI agent).
OpenAPI as a Tool
This one’s a game changer. ADK can auto-generate tools from an OpenAPI spec, turning REST APIs into callable functions – no need to manually define each endpoint as a tool!
Example: Got a custom API for an internal microservice? Just point ADK to its OpenAPI spec, and you’re good to go.
Custom Function Tools
If your use case doesn’t fit the mold, you can create your own tools – perfect for specialized logic or even long-running tasks so that while these run in the background, the agent can continue working on other tasks.
Agents as Tools
ADK lets you invoke an agent as a tool – essentially delegating a task to another agent.
The difference between using an agent as a tool vs. a sub-agent:
- Agent-as-a-Tool: When Agent A calls Agent B as a tool, Agent B’s answer is passed back to Agent A, which then summarizes the answer and generates a response to the user. Agent A retains control and continues to handle future user input.
- Sub-agent: When Agent A calls Agent B as a sub-agent, the responsibility of answering the user is completely transferred to Agent B. Agent A is effectively out of the loop. All subsequent user input will be answered by Agent B.
Rich Conversational Context Support
For agents to hold meaningful, multi-turn conversations, they need to remember what’s already been said – just like a human would. Without that, conversations become repetitive or disconnected. Google’s ADK gives structured ways to manage this conversational context with three key layers:
- Session: Represents one ongoing interaction between a user and the agent. It keeps track of the full chronological timeline of messages and actions during that exchange.
- State: Stores temporary data that’s only relevant to the current conversation thread
- Memory: A searchable knowledge base that helps the agent recall facts or context from past sessions
ADK goes a step further with a unique concept called Artifacts. An Artifact is a piece of binary or large data (like a file or report), identified by a unique filename within a session or user scope.
While state is perfect for lightweight data like strings, booleans, or small config objects, artifacts are ideal for handling larger blobs or complex data structures. Some practical use cases include:
- An agent generates a report that a user can request later
- A user uploads a file, and an agent processes it during or after the session
- Persisting user-specific config or data that’s too rich for basic key-value state – enabling personalized, stateful experiences across time
ADK Supports Callbacks!
Callbacks in Google’s ADK are a powerful way to hook into an agent’s lifecycle – giving you visibility and control at key points in its execution, without having to change the core framework.
They’re implemented as regular Python functions, which the ADK automatically calls at specific stages like:
- Before or after the agent runs its main logic
- Before sending a request to the LLM, and after receiving the response
- Before a tool executes, and after it completes
This opens the door to a wide range of advanced use cases, such as:
- Logging and monitoring: Capture detailed traces of what your agents are doing, which helps with debugging and observability.
- Custom logic: Modify inputs or outputs, skip unnecessary steps, or dynamically adapt behavior based on business rules.
- Implement Guardrails: Enforce safety rules, validate inputs/outputs, or prevent disallowed operations.
- Dynamic state updates: Read or update session state on the fly during execution.
- Trigger external actions: Call external APIs, send alerts, or implement features like caching and audit trails.
In essence, callbacks give you deep control without deep changes – ideal for production-grade systems that need customization, safety, and flexibility.
Events: The Backbone of Agent Execution
In Google’s ADK, events are at the heart of everything. An event is an immutable (unchangeable) record that represents a specific moment in an agent’s lifecycle. Think of it as a snapshot of what happened – capturing not just actions, but the context around them.
Events capture:
- User inputs (messages)
- Agent responses
- Tool function calls and their results
- Changes to state or memory
- Control signals
- Errors or exceptions
Every interaction in ADK – between the UI, the Runner, agents, LLMs, or tools – is expressed as an Event.
This offers several key benefits:
- Consistency: Everything flows in a standard format, making it easier to reason about interactions.
- Traceability: Since events are recorded in sequence, you get a complete, chronological history of every conversation – down to the smallest detail.
- Debugging & Auditing: Need to figure out why an agent made a certain decision? Just walk through the event trail step-by-step.
- Transparency: With events logged, you can inspect, analyze, or replay conversations to understand and improve behavior over time.
Bottom line: Events give you a transparent, structured view of everything that happens inside the system – crucial for building reliable, maintainable Agentic AI Systems.
Agent Evaluations: From Prototype to Production
Moving from a cool demo to a reliable, production-grade AI agent? You’ll need more than just functional output – you’ll need robust evaluation. And with agents, evaluation isn’t just about what they say, it’s about how they arrive at their answers.
Unlike traditional model evaluations that focus on output quality alone, agent evaluations dive deeper into:
- The steps the agent takes and decisions it makes
- Tool choices and how efficiently they’re used by the agent
- The strategy the agent applies to solve a task
- And of course, the quality, relevance, and accuracy of the final result
ADK provides two evaluation strategies, depending on the stage of development:
1. Test Files (Unit Test Style)
You write individual test files, each one modeling a single, simple agent-model interaction (a session).
- Fast feedback during development
- Testing edge cases or specific tool behaviors
- Iterating quickly on agent logic
2. Evalsets (Integration Test Style)
An evalset is a structured dataset that contains multiple, potentially lengthy sessions, making it ideal for simulating complex, multi-turn conversations.
- Simulating real-world, production-like conversations
- Validating end-to-end behavior
- Ensuring agents perform well across varied scenarios
Think of it like this: Test files = unit tests. Evalsets = integration tests. Together, they help ensure your agents are not only working, but working right.
Other Notable Capabilities
Beyond its core features, ADK offers several developer-friendly capabilities that make building and scaling agents smoother than ever:
Built-in Streaming (Audio + Video)
Go beyond plain text. ADK supports bi-directional audio and video streaming, enabling natural, human-like conversations with agents. With just a few lines of code, you can bring multimodal interaction to life – perfect for hands-free workflows, assistive agents, or immersive interfaces.
Integrated Developer Experience
ADK ships with a rich CLI and a visual Web UI, making it easy to:
- Build and run agents locally
- Inspect events, state, and execution steps in real time
- Debug behavior without guesswork
It’s the kind of end-to-end dev workflow that helps teams stay productive.
Ready to Ship
These agents and Agentic AI Systems built using ADK are ready to ship. Containerize your agents and deploy them anywhere – on-prem or in the cloud.
Conclusion
Google’s ADK is a powerful new open-source framework for building production-ready agentic AI systems. It offers robust multi-agent orchestration, rich tool and model support, deep evaluation capabilities, and a great developer experience.
From local development to scalable deployment, ADK covers the full lifecycle of agent development. But that’s just one part of Google’s vision for open, interoperable agents. In my next post, I’ll dive into Agent2Agent (A2A) – a new open protocol that could redefine how agents collaborate across platforms and providers. Stay tuned!
