Exploring Features and Tools of Google’s Agent Development Kit (ADK)

As autonomous AI gains momentum, Google’s Agent Development Kit (ADK) stands out as a flexible, modular framework for building intelligent agents, especially when paired with the Gemini model family. Designed for developers and enterprises alike, ADK simplifies the journey from prototype to production. 

In our previous blog on Google’s ADK, we introduced its powerful framework aimed at helping enterprises build, deploy, and manage AI agents at scale. With its promise of production-ready orchestration, native cloud integrations, and modular architecture, ADK marked a significant shift in how businesses can approach AI-driven automation. Now, in the second part of our series, we move beyond the headlines to explore the toolkit itself, unpacking the core features, built-in tools, and extensibility options that make ADK a compelling choice for enterprise-grade agent development. 

What Is ADK? 

ADK is a Python-based toolkit for creating, orchestrating, and deploying AI agents. Whether you're building a basic chatbot or a multi-agent system, ADK offers robust tools, workflows, and deployment capabilities, all installable via: 

bash 

CopyEdit 

pip install google-adk 

Why ADK Matters in 2025 

1. The Shift Toward Agentic AI 

The idea of autonomous, goal-oriented software agents has moved from academic theory into mainstream development. According to a 2024 report by McKinsey, 70% of enterprise AI applications are expected to feature agent-based architectures by 2026, highlighting the growing shift toward systems that can plan, reason, and act autonomously. 

2. AI Toolchains Need Flexibility 

Developers are no longer content with rigid, black-box AI solutions. They want composability, modularity, and the freedom to integrate tools across ecosystems. ADK answers this call with a design that encourages experimentation, hybrid workflows, and system-level control—all while offering out-of-the-box support for Gemini, LangChain, CrewAI, and other third-party libraries. 

Key Features 

• Workflow Agents: Deterministic agents (SequentialAgent, ParallelAgent, LoopAgent) enable testable pipelines. LlmAgent allows dynamic decision-making. 
• Multi-Agent Design: Compose specialized agents for complex workflows—ideal for use cases like travel planning, retail, or internal automation. 
• Tool Ecosystem: Use built-in tools, integrate custom or third-party ones, or even call other agents as tools. 
• Easy Deployment: Move from local dev to production via Docker, Cloud Run, and Vertex AI integration—no major rewrites needed. 
• Responsible AI: Built-in evaluation, guardrails, and reasoning transparency support safe deployment in regulated industries. 

Agent Types

These can be combined to build intelligent, adaptable workflows. 

What Are Tools in ADK? 

Tools in the Agent Development Kit (ADK) are predefined, executable units of logic that let AI agents perform actions like: 

• Querying databases or APIs 
• Searching the web 
• Running code 
• Conducting RAG lookups 
• Interacting with external systems (e.g., calendars, booking engines) 

 Core Characteristics 

• Action-Oriented: Tools are purpose-built to carry out specific tasks. 
• Capability Extenders: They give agents access to real-world, real-time data and let them trigger side effects (like sending emails). 
• Logic Executors: Tools are not intelligent—they execute logic defined by developers. The LLM decides which tool to use, when, and how. 

How Agents Use Tools 

1. Reasoning: The agent’s LLM analyzes the user request and determines which tool to use. 
2. Selection: Based on the analysis, the LLM picks a tool and generates the necessary input arguments. 
3. Invocation: The selected tool is triggered, executing the task. 
4. Observation: The agent receives the tool's output and incorporates it into its response. 
5. Finalization: The agent processes the result and decides the next action, continuing the flow of conversation or task execution. 

Tool Types in ADK 

Function Tools 

Agents are only as powerful as the tools they use. While ADK includes built-in tools, real-world applications often need custom logic and proprietary data access. That’s where Function Tools come in, allowing developers to embed custom Python functions directly into the agent runtime. 

1. Function Tool 

At its core, a Function Tool is a standard Python function turned into an ADK-compatible tool. It’s the easiest way to expose custom logic to your agent. 

Key Concepts: 

• Parameters: Stick to JSON-serializable types (str, int, list, etc.). Avoid default values, they’re not well understood by the LLM. 
• Return Type: Always prefer a dictionary. If you return something else, ADK wraps it under "result". 
• Docstring Matters: The function's docstring becomes the tool’s instruction to the LLM. A good one makes all the difference. 

2. Long Running Function Tool 

Some operations—like document processing or human approvals—just take time. Enter the LongRunningFunctionTool, which lets your function yield intermediate updates without freezing the agent. 

How It Works: 

• Wrap a generator function with LongRunningFunctionTool. 
• Use yield to send progress updates. 
• Use return to finish and send the final result. 
• The ADK framework handles the streaming of FunctionResponse objects to keep the LLM and user in the loop. 

3. Agent-as-a-Tool 

Sometimes, one agent just isn’t enough. With Agent-as-a-Tool, you can wrap an entire agent as a callable tool, perfect for modular architectures and task delegation. 

When to Use It: 

• Delegate summarization to a dedicated agent 
• Offload specialized tasks (e.g., compliance checks, language translation) 

How It’s Different from Sub-Agents: 

• Agent-as-a-Tool: The calling agent retains control. It invokes another agent and uses the result in its response. 
• Sub-Agent: The called agent takes over entirely, responding to user inputs directly from that point on. 

Built-in Tools in ADK 

ADK provides pre-built tools like Google Search, code execution, and Vertex AI Search that agents can use without extra setup. These tools enhance agents with common capabilities, such as retrieving information from the web, executing code, or querying private data stores. 

How to Use Built-in Tools 

1. Import the desired tool from the agents.tools module. 
2. Configure the tool with required parameters. 
3. Register the tool in your agent’s tools list, allowing it to be invoked as needed. 

Built-in Tools in ADK 

Using Multiple Tools 

Currently, only one built-in tool can be used per agent. You cannot use multiple built-in tools within the same root agent or sub-agent. For example, mixing google_search and built_in_code_execution in a root agent or sub-agent is not supported. 

Limitations 

• One built-in tool per agent: You cannot combine multiple built-in tools in a single root agent. 
• No built-in tools in sub-agents: Built-in tools cannot be used within sub-agents. 

These built-in tools streamline agent development, making it easier to integrate advanced functionalities like web search and code execution. 

• Third Party Tools in ADK 

 The ADK (Agent Development Kit) allows seamless integration of third-party tools from popular AI agent frameworks like LangChain and CrewAI. This interoperability enables faster development and allows you to leverage existing tools from these ecosystems. 

Common Integration Steps 

1. Install required third-party package 
2. Set API key as an environment variable 
3. Import & wrap tool using ADK's wrapper (LangchainTool or CrewaiTool) 
4. Add wrapped tool to your agent's tool list 
5. Run and query your agent 

 These integrations streamline the development of AI agents by tapping into the power of established third-party tools like LangChain and CrewAI, making the process quicker and more efficient while offering advanced capabilities to your agents. 

• Google Cloud Tools 

 Google Cloud provides several tools to connect your agents with various services, including custom APIs, prebuilt enterprise connectors (Salesforce, Workday, SAP), automation workflows, and databases (Spanner, AlloyDB, Postgres, etc.). 

• Model Context Protocol (MCP) Tools 

 One can integrate the Model Context Protocol (MCP) with the Agent Development Kit (ADK) in two primary ways: 

1. Using Existing MCP Servers with ADK: In this pattern, an ADK agent acts as an MCP client. It connects to external MCP servers to access tools and services provided by the server. 
2. Exposing ADK Tools via an MCP Server: Here, you wrap ADK tools inside an MCP server, making them available to any MCP client. This pattern allows you to expose your ADK tools as services that can be called by other systems or applications using MCP. 

 Key Concepts 

• MCPToolset Class: This class helps ADK agents interact with MCP servers. It allows for connecting, discovering available tools, adapting them for the ADK environment, proxying calls, and managing connections. 
• MCP Server and Client Architecture: MCP operates using a client-server model. The MCP client (e.g., ADK agent) communicates with the MCP server to call tools and receive responses. The server exposes resources (like functions and tools), and the client consumes them. 

Deployment Options 

1. Vertex AI Agent Engine 
   Ideal for production—managed, auto-scaled, native to Google Cloud. 
2. Cloud Run 

If you prefer full control or are containerizing custom backends. 

Google’s Agent Development Kit (ADK) brings together a powerful runtime, modular architecture, and a rich set of developer tools to enable the creation of intelligent, scalable, and production-ready agents. With built-in support for orchestration, third-party integrations, declarative tooling, and seamless deployment across surfaces, ADK simplifies the complexities of agent development while offering the flexibility to build both user-facing and system-driven workflows. Whether you're designing a simple tool agent or a multi-surface orchestrator, ADK has specific set of features and tools that provides the structure and scalability needed to bring sophisticated agent experiences to life.