Google's open-source agent SDK with deep Vertex AI and Gemini integration.
GitHub Stars
19.7K
Contributors
281
npm / Week
—
PyPI / Month
7.9M
The Google Agent Development Kit (ADK) is an open-source, code-first framework for building, evaluating, and deploying AI agents at production scale. Maintained by Google and released in 2025 under the Apache 2.0 license, ADK serves as both an Agent Runtime and an Inference SDK. Its primary language is Python, but Google also publishes official SDKs in TypeScript, Go, and Java.
ADK is built for teams that want a structured path from local agent prototypes to managed production deployments on Vertex AI. It competes directly with frameworks like LangChain, CrewAI, and Pydantic AI, but differentiates through deep Gemini model integration, a built-in evaluation harness, and one-command deployment to Google Cloud infrastructure. Within a year of release it has accumulated 19,673 GitHub stars, 281 contributors, and nearly 8 million PyPI monthly downloads, signaling strong adoption among developers already operating in the Google Cloud ecosystem.
ADK is a code-first framework with an event-driven architecture. The core abstraction is the Agent, a unit that receives events, calls tools, and emits outputs. Agents are composed into hierarchies: a parent LlmAgent can delegate tasks to child agents via
What the framework gives you out of the box, in plain language.
The jobs this framework is best suited for.
Build, evaluate, and deploy agents to managed Vertex AI infrastructure.
Tight coupling with Gemini models, including thinking and tool-use features.
Evaluation harness and Vertex AI integration for regulated environments.
Side-by-Side
Add a second or third framework and see stars, downloads, and capabilities lined up next to each other.
Close alternatives worth a look before you decide.
sub_agentsRunnerControl flow is imperative and Pythonic. You define an agent by setting its model, instruction, and tool list. Multi-agent coordination uses explicit patterns: sequential, parallel, and loop patterns are supported through a small set of primitives. Session state is shared across agents, making it straightforward to maintain context across turns.
ADK is model-agnostic in theory but optimized for Google’s Gemini models, including Gemini Flash and Pro. Deployment is decoupled: you can run agents locally during development, then deploy to Vertex AI Agent Engine or alternative runtimes like Cloud Run or GKE.
Vertex AI deployment. One command deploys your agent to Vertex AI Agent Engine with managed infrastructure, autoscaling, and monitoring. This is the primary path to production for most ADK users.
Built-in evaluations. ADK ships with an evaluation harness that scores agents against golden answer sets directly from the SDK. This allows you to measure agent quality as part of your CI/CD pipeline, which is critical for regulated enterprise environments.
Multi-agent primitives. The framework supports sequential, parallel, and loop agent patterns with a shared session state. You can build specialized teams of sub-agents that collaborate and delegate.
Streaming, memory, and tracing. ADK supports token-level streaming from the agent, which matters for user-facing chat interfaces. Memory is built in via session state management. Tracing is available for debugging agent execution paths.
Tool ecosystem. Includes pre-built tools like Google Search, as well as a mechanism to wrap any Python function as a tool. Third-party integrations are growing.
Multi-language SDKs. Beyond Python, official Go, Java, and TypeScript SDKs allow teams to adopt ADK across different service boundaries.
Vertex AI production agents. Build an agent locally, evaluate it against test sets, then deploy it to Vertex AI Agent Engine with a single command. This pattern is common for customer support triage, internal knowledge assistants, and document processing pipelines.
Gemini-powered assistants. ADK’s tight coupling with Gemini models (including thinking mode and tool-use features) makes it the natural choice for teams already using Gemini APIs. Use cases include research assistants that search the web, code generation agents that invoke sandboxed interpreters, and multimodal assistants processing images and text.
Enterprise agent governance. The evaluation harness and Vertex AI integration provide the audit trail and reliability metrics required in regulated industries like healthcare, finance, and legal.
ADK is a poor fit for projects that need to be cloud-agnostic or that rely heavily on non-Google LLMs. Its ecosystem is smaller than LangChain’s, so if you need a specific community tool or integration that does not yet exist, you may have to build it yourself.
Install the Python SDK:
1pip install google-adk
The minimal agent in under 20 lines:
1from google.adk import Agent, Runner23agent = Agent(4 name="researcher",5 model="gemini-flash-latest",6 instruction="You help users research topics thoroughly.",7 tools=["google_search"]8)910runner = Runner(agent)11response = runner.run("What is the latest climate report about?")12print(response)
You will need a Gemini API key (or access to a Google Cloud project with Vertex AI enabled) to run the model. For local testing, any OpenAI-compatible endpoint can also be used, but the canonical path uses Gemini.
Official documentation is at [google.github.io/adk-docs](https://google.github.io/adk-docs/), with sample projects in the [adk-samples](https://github.com/google/adk-samples) repository. The community is active on the r/agentdevelopmentkit subreddit.
vs LangChain. LangChain offers a broader ecosystem of integrations and community recipes. ADK provides a more opinionated, Google-centric path with built-in evaluations and a single deployment target (Vertex AI). Choose ADK if you are already on Google Cloud and want a framework that ships with eval and production infrastructure out of the box. Choose LangChain if you need cloud-agnostic deployment or a larger variety of LLM providers.
vs CrewAI. CrewAI specializes in role-based multi-agent orchestration and is easier to get started with for simple prototype teams. ADK is more production-oriented: its evaluation harness, managed deployment, and enterprise governance features are absent in CrewAI. Use ADK when governance and reliability matter. Use CrewAI for rapid multi-agent demos or when you do not need Vertex AI.
vs Pydantic AI. Pydantic AI is a lightweight, Pythonic agent framework with strong typing and validation. It is excellent for single-agent, type-safe workflows. ADK scales to multi-agent systems and offers managed deployment. For sophisticated agent hierarchies on Google Cloud, ADK is the stronger choice. For simpler, stateless agents that need rigorous schema validation, Pydantic AI may be more appropriate.
One-command deploys to Vertex AI Agent Engine with managed infrastructure.
Score agents against golden sets directly from the SDK.
Sequential, parallel, and loop agent patterns with shared session state.
