# Google Agent Development Kit (ADK) — Open-source framework for building, evaluating and deploying AI agents in Python, TypeScript, Go, Java or Kotlin.

> Source: The Agents Index — https://theagentsindex.com/google-adk (structured, researched, re-verified)
> Facts last verified: 2026-09-15

Google's Agent Development Kit is a framework for building agents and multi-agent systems, published as libraries for Python, TypeScript, Go, Java and Kotlin. It bundles the runtime, a local developer UI, an evaluation harness and deployment commands that carry an agent from script to production.

| Fact | Value |
| --- | --- |
| Website | https://adk.dev |
| Price | ADK is the open-source agent development framework that lets you build, debug, and deploy reliable AI agents at enterprise scale. |
| Free tier | Yes |

The framework itself is free and open source under Apache 2.0, installed from package managers with no account, no seats and no usage metering by Google. Costs arrive only from the model provider whose API key you supply and, if you deploy there, from Google Cloud: the vendor notes Agent Runtime is a paid service with a no-cost access tier above which you incur costs.

## What it does

**Writes code** · Partly — ADK does not write application code for you, but its Visual Builder inside the local web UI generates agent projects from a graphical design with an AI assistant, and the vendor marks that builder experimental and Python-only.

> The Visual Builder allows you to design, build, and test agents in a beginner-friendly graphical interface, and includes an AI-powered assistant to help you build agents.
> — https://adk.dev/visual-builder/ · Use the Visual Builder, opening paragraph

**Debugs and fixes** · Partly — The bundled web UI and event/trace inspection let a developer diagnose why an agent failed, but landing the code fix is left to the developer or to a separate AI coding tool; ADK ships no repair agent.

> The ADK web interface lets you test your agents directly in the browser. This tool provides a simple way to interactively develop and debug your agents.
> — https://adk.dev/runtime/web-interface/ · Use the Web Interface, opening paragraph

**Writes tests** · Partly — What it generates are agent evaluation sets captured from real sessions, not unit tests; the evaluation tooling is documented as Python-only, so other language bindings do not get it.

> Creating evalsets manually can be complex, therefore UI tools are provided to help capture relevant sessions and easily convert them into evals within your evalset.
> — https://adk.dev/evaluate/ · Evaluate with an Evalset File section

**Reviews code** · Partly — Review is not a built-in behaviour: you assemble an agent with the documented GitHub MCP toolset and your own access token, and the vendor frames reviewing changes as something the AI can help with.

> Issue & PR Automation: Create, update, and manage issues and pull requests. Let AI help triage bugs, review code changes, and maintain project boards.
> — https://adk.dev/integrations/github/ · GitHub MCP tool for ADK, Use cases list

**Whole-codebase work** · Partly — The documented route across an existing repository is Agents CLI skills driving your own coding agent through an incremental migration; ADK itself carries no repository-wide refactor engine.

> Instead of manually rewriting state objects, node graphs, and execution loops line by line, you can use Agents CLI to plan and execute the migration with your coding agent.
> — https://adk.dev/get-started/migrate/ · Migrate with Agents CLI section

**Ships it** · Yes — Deployment is part of the framework: one command pushes an agent to Google Cloud, and the same agent can be containerised and run on infrastructure you control instead.

> You can containerize and run ADK on your own infrastructure, or take advantage of our native, one-command deployment to Google Cloud.
> — https://adk.dev/ · Frequently Asked Questions, How does ADK deploy to production?

**Done-for-you service** · No — Nobody builds or runs the agent for you: this is a library you install and operate yourself, and the site's 235-page sitemap carries no services, retainer or consulting offer.

> ADK is the open-source agent development framework that lets you build, debug, and deploy reliable AI agents at enterprise scale.
> — https://adk.dev/ · Homepage hero paragraph

## How much it does unattended

**Runs autonomously** · Yes — Agents can be triggered by events, queues or a schedule and run as background processes with no person in the loop, which the vendor documents as ambient agents.

> These agents can run as background processes to process data, monitor events, and respond asynchronously without human intervention.
> — https://adk.dev/runtime/ambient-agents/ · Trigger actions with ambient agents, opening paragraph

**Multi-agent** · Yes — Multi-agent composition is the headline design: hierarchies of specialised agents that delegate sub-tasks, plus sequential, parallel and loop workflow agents for deterministic orchestration.

> Multi-Agent System Design: Easily build applications composed of multiple, specialized agents arranged hierarchically.
> — https://adk.dev/get-started/about/ · Key Capabilities, item 1

**Agent permissions** · Yes — Autonomy is set per tool by the developer: a tool can be configured to pause and ask a human or a supervising system before it runs, though the vendor labels this confirmation feature experimental.

> The Tool Confirmation feature in the Agent Development Kit (ADK) allows an ADK Tool to pause its execution and interact with a user or other system for confirmation
> — https://adk.dev/tools-custom/confirmation/ · Get action confirmation for ADK Tools, opening paragraph

## Which models it runs on

**Claude** · Yes — Claude is supported in Python and Java, either through the registry wrapper on Google Cloud Agent Platform or directly against Anthropic with your own API key.

> You can use Anthropic's Claude models with ADK in both Python and Java. Choose the path that matches your language and backend below.
> — https://adk.dev/agents/models/anthropic/ · Claude models for ADK agents, opening paragraph

**GPT** · Yes — OpenAI models reach ADK two ways: a native Go package the vendor marks experimental, and the LiteLLM connector for Python, so the path depends on your language.

> You can use OpenAI models with ADK. How you connect depends on the language
> — https://adk.dev/agents/models/openai/ · OpenAI models for ADK agents, opening paragraph

**Open models** · Yes — Open-weight models run through LiteLLM against local hosts such as Ollama, with separate documented paths for vLLM and on-device LiteRT-LM serving.

> Ollama is a tool that allows you to host and run open-source models locally. ADK integrates with Ollama-hosted models through the LiteLLM model connector library.
> — https://adk.dev/agents/models/ollama/ · Ollama model hosting, opening paragraph

**Model choice** · Yes — You choose the model per agent, including a router that picks between several at runtime; Gemini is the default path but not a requirement of the framework.

> Agent Development Kit (ADK) is designed for flexibility, allowing you to integrate various Large Language Models (LLMs) into your agents.
> — https://adk.dev/agents/models/ · AI Models for ADK agents, opening paragraph

## Where you use it

**In your editor** · Partly — There is no ADK editor extension; instead Agents CLI installs ADK skills into existing AI coding environments, and a docs MCP server can be added to the same tools.

> The Agents CLI tool set lets you plug ADK agent expertise into your favorite AI-coding environments including Antigravity, Claude Code, Cursor, and other AI coding tools.
> — https://adk.dev/tutorials/coding-with-ai/ · Agents CLI section, opening paragraph

**On the command line** · Yes — A terminal surface is first-class: an interactive run command with session save, resume and replay flags in the Python CLI, and an embedded launcher for Go binaries.

> ADK provides an interactive terminal interface for testing your agents. This is useful for quick testing, scripted interactions, and CI/CD pipelines.
> — https://adk.dev/runtime/command-line/ · Use the Command Line, opening paragraph

**In your pipeline** · Partly — The CLI is documented for scripted and CI/CD use and evaluations run headless, but nothing on the site describes ADK acting on a pull request by itself without an agent you build.

> ADK provides an interactive terminal interface for testing your agents. This is useful for quick testing, scripted interactions, and CI/CD pipelines.
> — https://adk.dev/runtime/command-line/ · Use the Command Line, opening paragraph

**In a browser** · Partly — The browser UI exists but you run it locally and the vendor bars it from production, so there is no hosted web application unless you deploy your own agent service.

> ADK Web is not meant for use in production deployments. You should use ADK Web for development and debugging purposes only.
> — https://adk.dev/runtime/web-interface/ · Caution callout, ADK Web for development only

## Whose machine it runs on

**Self-hosted** · Yes — Self-hosting is a documented first-class path: package the agent as a container and run it anywhere, including locally in Docker or Podman with no Google Cloud connection.

> You can manually package your Agent into a container image and then run it in any environment that supports container images. For example you can run it locally in Docker or Podman.
> — https://adk.dev/deploy/ · Other Container-friendly Infrastructure section

**Open source** · Yes — The framework is published as open source under Apache 2.0 with language bindings distributed through the usual package managers, and the docs invite outside contributions.

> By contributing, you agree that your contributions will be licensed under the project's Apache 2.0 License.
> — https://adk.dev/community/contributing-guide/ · Contributing guide, License section

## What it costs to run

**How it meters** · Partly — The framework meters nothing. You pay the model provider whose key you supply, plus Google Cloud's Agent Runtime beyond its no-cost tier if you deploy there.

> Agent Runtime is a paid service and you may incur costs if you go above the no-cost access tier.
> — https://adk.dev/deploy/agent-runtime/ · Agent Runtime service on Google Cloud admonition

**Free tier** · Yes — You install it from a package manager and run it without an account, a sales call or a card; the site publishes no pricing page at all for the framework.

> ADK is the open-source agent development framework that lets you build, debug, and deploy reliable AI agents at enterprise scale.
> — https://adk.dev/ · Homepage hero paragraph

**API access** · Yes — A built-in server exposes your agents over REST for programmatic calls, and the same launcher serves the API alongside the web UI in the compiled languages.

> Use the API server in ADK to expose your agents through a REST API for programmatic testing and integration.
> — https://adk.dev/runtime/api-server/ · Use the API Server, opening paragraph

**MCP server** · Yes — MCP works in both directions: agents consume external MCP servers as tools, and you can wrap ADK tools in an MCP server that any other MCP client can call.

> Exposing ADK Tools via an MCP Server: How to build an MCP server that wraps ADK tools, making them accessible to any MCP client.
> — https://adk.dev/mcp/ · MCP Tools in ADK, second bullet

**Bring your own key** · Yes — Inference always runs on your own credentials: the quickstart has you write your own model API key into a local env file, and the runtime is yours to host.

> This project uses the Gemini API, which requires an API key. If you don't already have Gemini API key, create a key in Google AI Studio on the API Keys page.
> — https://adk.dev/get-started/python/ · Python Quickstart, Set your API key section

## Buying it for a team

**Admin controls** · Partly — Constraints exist but they are code, not a console: a plugin registered once on the runner applies its checks globally to every agent, tool and model call, and a developer must write it.

> Policy enforcement: Implement security guardrails, such as a function that checks if users are authorized to use a specific tool and prevent its execution if they do not have permission.
> — https://adk.dev/plugins/ · Plugins, typical applications list

**Audit log** · Partly — Execution is recorded in depth through built-in logging, metrics and traces, but this is telemetry about agent runs on infrastructure you own, not an administrative audit trail of who changed what.

> Agent Development Kit (ADK) provides built-in observability through logging, metrics, and traces to help you monitor and debug your agents.
> — https://adk.dev/observability/ · Observability for agents, opening paragraph

## What happens to your code

**Opt out of training** · Partly — ADK's own usage telemetry is off until you switch it on and explicitly excludes source files, prompts and credentials, but the site says nothing about what the model provider you route to may do with your data.

> Data collection is OFF by default until you explicitly choose to enable it.
> — https://adk.dev/runtime/command-line/ · Usage telemetry section

**Data residency** · Yes — Jurisdiction is whatever you choose, because you host the container: the vendor documents running it disconnected from Google Cloud entirely, and cloud deploys take an explicit region.

> This is a good option if you prefer to run offline or disconnected, or otherwise in a system that has no connection to Google Cloud.
> — https://adk.dev/deploy/ · Other Container-friendly Infrastructure section

**Getting out** · Yes — Conversation data is yours on disk: sessions save to a plain JSON file and can be pointed at your own database or storage service, and no credits exist to expire.

> You'll be prompted to enter a session ID, and the session will be saved to path/to/my_agent/<session_id>.session.json.
> — https://adk.dev/runtime/command-line/ · Save sessions section

_Not established: Certifications_

## Platform record (as of 2026-08-30)

Reported by the code-hosting platform, not by the vendor.

| Fact | Value |
| --- | --- |
| Licence | Apache-2.0 |
| Stars | 21331 |
| Forks | 3912 |
| Last push | 2026-08-30 |

## Provenance

1 of 33 sources behind the facts above are independent of the vendor.

## Coverage elsewhere

Pages about this product that the vendor does not control. The label states how independent each one is.

| Source | Kind | Read |
| --- | --- | --- |
| pypi.org | Platform record | 2026-08-23 |
| developers.googleblog.com | Independent source | 2026-08-23 |
| developers.googleblog.com | Independent source | 2026-08-23 |
| docs.litellm.ai | Independent source | 2026-08-23 |
| infoworld.com | Independent source | 2026-08-23 |
| betterclaw.io | Independent source | 2026-08-23 |

## What changed

- 2026-09-15 — Capabilities · Commercial terms · Free tier · Price
- 2026-09-02 — Capabilities · Commercial terms · Free tier
- 2026-08-31 — Capabilities · Commercial terms · Free tier
- 2026-08-23 — Alternatives · Documentation link · One-liner · Repository · Summary
- 2026-08-19 — Summary

## Correcting this record

Anything marked "Not established" is a question we have not answered — it is not a No. If you represent Google Agent Development Kit (ADK), or anything here is wrong or out of date, you can supply it with a source: the operations this site accepts from an agent are listed at https://theagentsindex.com/.well-known/agents.json — that catalogue needs no key to read, and each entry states its own auth.

Supplying evidence is free. Nothing that can be bought here changes what a field says, whether a gap is closed, or how this record is scored.
