Master Google Agent Development Kit (ADK) with our step-by-step tutorial, detailed feature walkthrough, and expert tips.
Install ADK Install via pip: `pip install google
adk`. Requires Python
9+. For Java, add the `google
adk` Maven dependency to your project. ##
Get a Gemini API Key Sign up at [Google AI Studio](https://aistudio.google.com) and generate a free API key. Set it as an environment variable: `export GOOGLE_API_KEY=your
here`. No credit card required for the free tier. ##
Create Your First Agent Create a Python file and define your agent: ```python from google.adk.agents import Agent my_agent = Agent( name="my_assistant", model="gemini
flash", instructions="You are a helpful assistant that answers questions clearly and concisely.", ) ``` ##
Add Tools Give your agent capabilities by defining tool functions: ```python def get_weather(city: str)
> dict: """Get the current weather for a city.""" return {"city": city, "temp": "72°F", "condition": "sunny"} agent = Agent( name="weather_agent", model="gemini
flash", instructions="Help users check the weather.", tools=[get_weather], ) ``` ##
Run and Test Locally Use the ADK CLI to start a local development server: `adk web` launches an interactive UI at localhost:8000 where you can chat with your agent, inspect tool calls, and debug behavior. ##
Evaluate Your Agent Define evaluation cases to test agent behavior: ```python from google.adk.evaluation import EvalSet eval_set = EvalSet(cases=[{"input": "Weather in NYC?", "expected_tools": ["get_weather"]}]) ``` Run evaluations with `adk eval` to score trajectories and catch regressions before deploying. ##
Deploy to Production For managed hosting, deploy to Vertex AI Agent Engine: `adk deploy cloud_run` or configure Vertex AI Agent Engine through the Google Cloud Console. For self
hosting, package your agent as a standard Python application and deploy to any container runtime.
💡 Quick Start: Follow these 15 steps in order to get up and running with Google Agent Development Kit (ADK) quickly.
Explore the key features that make Google Agent Development Kit (ADK) powerful for multi-agent builders workflows.
Define agents as Python (or Java) classes with instructions, tools, and sub-agents using clean, minimal APIs. Agents are standard code artifacts that live in your repository, go through code review, and run in your existing CI/CD pipeline. The class-based architecture supports inheritance and composition, letting teams build reusable agent templates and share tool libraries across projects.
Engineering teams that want agents to live alongside their existing codebase, version-controlled and testable like any other software component. Particularly valuable for organizations with established code review and deployment processes that want agents to follow the same workflows.
First-class SequentialAgent, ParallelAgent, and LoopAgent classes plus a coordinator/delegation pattern for building complex multi-agent systems. State is automatically passed between agents in a pipeline, error propagation is handled by the framework, and agents can delegate subtasks to specialized sub-agents. These primitives eliminate the custom glue code that teams typically write when orchestrating multiple agents in other frameworks.
Complex workflows where a research agent, analysis agent, and writing agent collaborate on a single deliverable, with each agent handling its specialty. Also suited for data processing pipelines where parallel agents gather information from multiple sources simultaneously before a synthesis agent combines the results.
Define evaluation sets with expected trajectories and final responses, then score agent runs locally or in CI. The framework captures tool call sequences, intermediate reasoning, and final outputs, comparing them against expected behavior to produce quantitative scores. Supports custom scoring functions and integrates with standard CI/CD systems for automated regression detection.
Production teams running CI/CD on agents who need regression detection before deploying new prompts, models, or tool configurations. Essential for teams iterating quickly on agent behavior who need confidence that changes improve target metrics without breaking existing functionality.
One-command deployment to a managed Google Cloud runtime with autoscaling, IAM-based access control, VPC Service Controls, audit logging via Cloud Trace, and enterprise SLAs. The deployment pipeline handles container packaging, load balancing, health checks, and scaling policies automatically. Supports staging and production environments with traffic splitting for gradual rollouts.
Enterprise teams that need SOC 2-grade infrastructure and don't want to spend engineering cycles on agent hosting, scaling, and security configuration. Ideal for organizations already on Google Cloud that want to deploy agents with the same governance controls as their other production services.
Native support for real-time streaming inputs and outputs over the Gemini Live API, enabling sub-second voice and video interactions. Agents can process audio input, generate spoken responses, and analyze video feeds in real time. The streaming architecture handles connection management, buffering, and fallback logic, allowing developers to focus on agent behavior rather than streaming infrastructure.
Voice-first customer support agents, real-time tutors, accessibility assistants, and live translation use cases. Any application where users expect natural, conversational interaction with sub-second response times rather than the latency of batch request-response patterns.
No. ADK is model-agnostic and supports OpenAI GPT, Anthropic Claude, Meta Llama, and any model accessible through LiteLLM's OpenAI-compatible interface. However, ADK is optimized for Gemini — features like native Google Search grounding, 1M-token context windows, and bidirectional audio/video streaming via the Live API only work with Gemini models. You can mix providers within a multi-agent system, using Gemini for some agents and other models for others.
LangChain has a much larger ecosystem with 700+ integrations and 90K+ GitHub stars, making it the safer pick for teams that need broad connector coverage and extensive community support. ADK's advantages are cleaner APIs, built-in evaluation tooling (LangChain requires separate LangSmith setup), first-class multi-agent orchestration primitives, and seamless Vertex AI deployment. For Google Cloud-native teams building structured multi-agent systems, ADK offers a more opinionated and integrated experience. For teams needing maximum flexibility and third-party integrations, LangChain remains stronger.
The framework itself is free under Apache 2.0. Real costs come from model API calls and infrastructure. Gemini 2.5 Flash is the most cost-effective option at $0.075 per 1M input tokens and $0.30 per 1M output tokens. Gemini 2.5 Pro costs $1.25 input and $10 output per 1M tokens. Vertex AI Agent Engine hosting starts at roughly $0.07 per vCPU-hour and scales with usage. A typical production agent handling 10,000 requests per day with Flash would cost approximately $15–$50/month in API fees plus infrastructure. Self-hosting on your own infrastructure eliminates the Vertex AI costs but requires managing scaling and reliability yourself.
Yes. ADK Python hit 1.0.0 stable in May 2025 and is the same framework Google uses internally to power agents in Agentspace and other products. The 1.0.0 designation signals API stability — breaking changes follow semantic versioning. Vertex AI Agent Engine provides enterprise-grade hosting with SLAs, IAM, VPC controls, and audit logging. That said, the framework is newer than LangChain and has less community-reported production usage outside Google. Teams adopting ADK for critical workloads should invest in the evaluation framework to catch regressions early.
Yes — multi-agent orchestration is a core design pillar, not an add-on. ADK ships with built-in primitives for SequentialAgent (step-by-step pipelines), ParallelAgent (concurrent execution), LoopAgent (iterative refinement), and a coordinator pattern for hierarchical delegation where a parent agent routes tasks to specialized sub-agents. State is passed between agents automatically, and the framework handles error propagation and communication. This is more structured than LangChain's approach, which requires custom code for most multi-agent patterns.
Now that you know how to use Google Agent Development Kit (ADK), it's time to put this knowledge into practice.
Sign up and follow the tutorial steps
Check pros, cons, and user feedback
See how it stacks against alternatives
Follow our tutorial and master this powerful multi-agent builders tool in minutes.
Tutorial updated March 2026