What is Google ADK? The Agent Development Kit Explained for 2026

ADK stands for Agent Development Kit, Google’s open-source, code-first framework for building, evaluating, and deploying AI agents. Google released it on April 9, 2025, and it now ships in Python, TypeScript, Go, Java, and Kotlin under Apache 2.0. ADK 2.0, generally available for Python since May 19, 2026, adds graph-based workflows to the agent loop.

Picture a team building an internal support agent. It reads a ticket, picks the order, shipping, or refund tool, drafts a reply, and asks a sub-agent to grade the draft for tone. The team runs a small eval set on every commit and deploys to Google Cloud when the pass rate clears the bar. ADK is the framework that holds the loop, sub-agents, evals, and deploy command together.

TL;DR

• ADK is Google’s open-source, code-first agent framework.
• It ships in Python, TypeScript, Go, Java, and Kotlin; ADK 2.0 graph workflows are GA for Python, Go, and TypeScript.
• Optimized for Gemini, it also runs Claude, OpenAI, Ollama, vLLM, and LiteLLM models.
• Built in: typed and MCP tools, A2A, sessions, callbacks, adk eval, and the adk web dev UI.
• Deploy to Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine), Cloud Run, or GKE, or self-host.

Why Google built ADK

Three things pushed Google to ship a first-party SDK rather than rely on third-party frameworks like LangChain or CrewAI.

First, the production agents Google runs internally have a specific shape. They live behind Google Cloud, they need session continuity, they need memory across turns, they need observability that flows into Google Cloud Trace, and they need to scale to many concurrent users. A framework optimized for tinkering on a laptop is not the framework that runs Google’s own production agents.

Second, the agent space had no first-party Google primitive. OpenAI shipped its Agents SDK in March 2025, a month before ADK. For Gemini-first builders, the choices were LangChain, CrewAI, AutoGen, or roll-your-own. ADK closes the gap with a first-party framework optimized for Gemini and Google Cloud deployment.

Third, ADK is the framework Google’s own teams already used. Google’s launch post said ADK is the same framework powering agents in Google products like Agentspace and the Customer Engagement Suite. The internal-and-external duality is why the SDK is opinionated: it solves problems Google teams hit, not generic problems a community wishlist might prioritize.

The ADK stack

ADK is one piece of a larger Google agent stack. Knowing where ADK sits tells you what it owns and what it leaves to Google Cloud.

• Vertex AI infra, now Gemini Enterprise Agent Platform, is the cloud substrate: GPUs, model serving, storage, networking. ADK does not manage this layer; it consumes it.
• Gemini foundation model is the default model. ADK can also call OpenAI, Anthropic, Cohere, Mistral, Bedrock, and any LiteLLM-compatible provider.
• Tools and memory is the layer where ADK gives you typed functions in the supported SDK language (Python, TypeScript, Go, Java, or Kotlin) plus a session state primitive. ADK ships built-in tools (Google Search, Code Exec) and lets you compose your own.
• ADK agent layer is the SDK itself: the agent loop, the sub-agent composition primitives, the evaluation framework, and the deployment command.

What Changed in Google ADK 2.0

ADK 2.0 adds the Workflow Runtime, a graph-based execution engine. Agents, tools, and plain functions run as nodes in a workflow graph, with routing, fan-out and fan-in, loops, retries, state, human-in-the-loop pauses, and nested workflows. Google lists 2.0 as generally available for Python on May 19, 2026, Go on June 30, 2026, and TypeScript on August 21, 2026.

from google.adk import Agent, Workflow

generate_fruit_agent = Agent(
    name="generate_fruit_agent",
    instruction="Return the name of a random fruit. Return only the name.",
)

generate_benefit_agent = Agent(
    name="generate_benefit_agent",
    instruction="Tell me a health benefit about the specified fruit.",
)

root_agent = Workflow(
    name="root_agent",
    edges=[("START", generate_fruit_agent, generate_benefit_agent)],
)

Upgrading from 1.x has breaking changes. BaseAgent now subclasses BaseNode, events carry new fields that rigid custom session tables must store, and a broad except block inside a tool disables the new automatic retries. Teams not ready can stay on 1.x with pip install "google-adk~=1.0".

Latest Google ADK versions

Core primitives

The framework reduces to a small set of primitives.

Agent

An agent is a class with a model, an instruction, optional tools, and optional sub-agents. A minimal example:

from google.adk import Agent


def get_weather(city: str) -> dict:
    """Return the weather for a city. Replace this stub with your weather API call."""
    return {"city": city, "forecast": "sunny", "temp_c": 24}


root_agent = Agent(
    name="weather_agent",
    model="gemini-3.8-flash",
    instruction="You answer weather questions for cities.",
    tools=[get_weather],
)

The instruction is the system prompt. The tools are Python functions; ADK introspects type hints and docstrings to build the function-calling schema. A Runner invokes the agent, manages the conversation, and dispatches tool calls. In ADK 2.0 the same Agent class also runs as a node inside a Workflow graph.

Tool

A tool is a typed function or method in the supported SDK language (Python examples below; TypeScript, Go, Java, and Kotlin follow the same shape). ADK supports these tool types:

• FunctionTool. A regular function. ADK builds the schema from type hints and the docstring.
• LongRunningFunctionTool. A wrapper for functions that start external long-running work, return an initial status or operation id, pause the run, and let the calling app resume with intermediate or final responses; useful for human-in-the-loop and background jobs.
• AgentTool. Wraps another agent so a parent can call a child as if it were a tool.
• MCP tools. McpToolset loads the tools from any MCP server, and ADK can also expose an agent as an MCP server.
• Built-in tools. google_search, url_context, and VertexAiSearchTool, plus code execution through BuiltInCodeExecutor.

Sub-agents and workflow agents

Composition is a first-class concern. ADK defines three workflow agents that compose other agents; ADK Python 2.x still runs them but has deprecated them in favor of Workflow since v2.0.0:

• SequentialAgent. Runs a list of agents in order; each receives the previous output.
• ParallelAgent. Runs agents concurrently and collects all outputs.
• LoopAgent. Repeats an agent until a stop condition holds, useful for refinement loops.

A multi-agent setup composes these. A planner agent dispatches to a sub-agent for retrieval, then to a sub-agent for drafting, then to a sub-agent for grading, all wired through a Workflow (or a 1.x SequentialAgent). The pattern is similar to AutoGen’s GroupChat or CrewAI’s crew composition; ADK’s twist is that workflow agents are themselves agents, so they nest.

For teams already on LangGraph, ADK exposes a LangGraph integration path so existing graphs can be wrapped and called from inside an ADK agent. For agents that run as separate services, ADK supports the A2A protocol, both to expose an agent and to consume a remote one.

Session and memory

Sessions hold conversation state. Memory holds long-term state across sessions. ADK provides in-memory implementations for development and Agent Platform Sessions and Memory Bank for production. State is keyed by user id and session id; reading and writing state happens through tools or via callbacks on the agent loop.

Callbacks

Callbacks fire at agent, model, and tool boundaries: before/after agent, before/after model call, and before/after tool. Use cases include input validation, output redaction, custom logging, and dynamic instruction modification. The OpenAI Agents SDK calls these “lifecycle hooks”; the shape is similar.

The agent loop

The loop matches most agent SDKs.

1. Runner.run(user_message) is called.
2. ADK formats the conversation history plus instruction plus tool schemas and calls the model.
3. The model returns either a final answer or one or more tool calls.
4. ADK executes the tool calls (Python functions, sub-agents, or built-in tools), captures the results.
5. The results append to the conversation; back to step 2.
6. The loop ends when the model returns a final answer, when a callback signals stop, or when the step budget is exceeded.

What ADK adds on top of the bare loop:

• Token streaming through the runner’s run_async interface.
• Trace emission to OpenTelemetry exporters; spans carry gen_ai.* attributes that any OTel backend can ingest.
• Step budgets that cap runaway tool loops.
• Callback injection at the three lifecycle points above.

The evaluation framework

Built-in evals set ADK apart from minimalist agent SDKs. An evalset is a JSON file containing test trajectories: input messages, expected tool calls, expected final responses. ADK runs the agent against each trajectory and scores it with criteria such as:

• Tool trajectory match. Did the agent call the expected tools with the expected arguments?
• Response match. Does the final response match the reference, scored by ROUGE-1 (response_match_score) or an LLM judge (final_response_match_v2)? The ADK evaluation criteria page lists both.
• Custom metrics. Plug in your own scorer.

The CLI is adk eval <agent_module> <evalset.json>. The output is a per-trajectory pass-or-fail with diagnostics. Pre-commit hooks or CI gates can block merges on regression. ADK also reports tool call count, model call count, token usage, and invocation duration on every eval as informational values that never fail a case.

For richer evaluation, the spans ADK emits are OTel-compatible, so any LLM observability platform that consumes OTel works. Future AGI’s evaluators ship in agent-learning-kit (pip install agent-learning-kit, Apache-2.0), whose evals engine scores traces and task outputs as well as prompts. You can run both: ADK evalsets in CI and span-attached scoring on production traces.

Deployment paths

ADK’s deployment story is opinionated toward Google Cloud but not exclusive.

• Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine). The managed runtime. adk deploy agent_engine packages the agent, deploys it as a managed service, and exposes a REST endpoint with sessions, memory, autoscaling, and built-in tracing.
• Cloud Run. adk deploy cloud_run packages the agent as a container and deploys to Cloud Run, optionally with the --with_ui flag to include the dev UI. Less managed than Agent Runtime but a fit for low-traffic services.
• GKE. adk deploy gke builds the container, generates a Kubernetes manifest, and applies it with kubectl.
• Self-host. It is just Python, TypeScript, Go, Java, or Kotlin; run it inside any FastAPI service, Express app, Go service, or JVM service.

Dev UI

ADK ships a local web UI invoked by adk web. It shows the agent’s conversation, tool calls, model parameters, and a span-style trace tree of each turn. For a developer iterating on instructions or tool definitions, the dev UI is a tight feedback loop.

The dev UI is meant for local development. Cloud Run deployments can opt in to the UI via the --with_ui flag; Python deployments to Agent Runtime do not include the ADK API server or web UI. Production observability lives in Google Cloud Trace, in the Google Cloud console, or in any OTel backend you point ADK at via the standard OTLP exporter.

How ADK compares with other agent SDKs

A practical map:

• OpenAI Agents SDK. Closest in shape. Agent-as-class, handoffs, tool wrapping. Different model bias (GPT vs Gemini), different default deployment surface (none vs Agent Runtime), similar primitives.
• Claude Agent SDK. Lower-level. Anthropic’s SDK gives you a tool loop and lets you build the framework on top. ADK is one level up, with workflow agents and an eval framework built in.
• Microsoft Agent Framework. Closer parity. Both ship from a hyperscaler, both target managed runtimes (Microsoft Foundry vs Agent Runtime), and both run graph workflows with built-in OpenTelemetry tracing. Choose by cloud preference.
• LangGraph. State-machine first. ADK 2.0 runs graph workflows too, so choosing Google ADK vs LangGraph now comes down to focus: ADK bundles evals and a Google Cloud deploy path, LangGraph gives lower-level control over state. The two interoperate via LangGraphAgent.
• CrewAI. Role-based. ADK is class-based. Different mental model for the same multi-agent problem.
• AutoGen. Conversational multi-agent, now archived and no longer maintained by Microsoft, which points new projects to its successor, Microsoft Agent Framework. Closer to ADK than CrewAI but with a chat-first abstraction. ADK is more workflow-first.

Production patterns with ADK

Three patterns that show up commonly in ADK deployments.

1. Plan-and-execute hierarchy

A Workflow (or 1.x SequentialAgent) chains a planner (Gemini 4 Argon), a tool-calling worker (Gemini 3.8 Flash), and a grader (Gemini 3.8 Flash with an LLM-as-judge prompt). The planner emits a plan; the worker executes; the grader vetoes outputs that fail the rubric. The pattern survives in production because each stage has a clear role and a measurable failure mode.

2. Reflexion loop with draft and critic agents

A Workflow loop (or 1.x LoopAgent) wraps a draft agent and a critic agent. Each iteration: draft produces output, critic scores it, if score is below threshold the loop continues with the critic’s feedback appended. Stop condition is either threshold or max iterations. Used for code generation, long-form writing, and any workload where one-shot output quality is unreliable.

3. Long-running human-in-the-loop

A LongRunningFunctionTool initiates external long-running work and returns an initial status or operation id when the agent wants to take a destructive action, such as a refund. The runner pauses the session and returns control to the calling app, which resumes the run with an intermediate or final function response once the human approves. The pattern lets ADK power workflows that span minutes or hours without holding a connection open.

Common mistakes

• Treating ADK as a drop-in LangChain replacement. Both build agents, but ADK is tuned for Gemini and Google Cloud deployment, while LangChain centers on a wide set of third-party model and tool integrations.
• Skipping the evalset. The eval framework is one of ADK’s better features. Skipping it means losing the easiest feedback loop.
• Not pinning model versions. Pin a stable id such as gemini-3.8-flash, not the gemini-flash-latest alias that Google hot-swaps with each release, and check the Gemini deprecations page for shutdown dates.
• Over-using ParallelAgent or parallel Workflow branches. Parallel runs save wall time but multiply token cost and make tracing harder. Use sequential by default.
• Forgetting to instrument tools. A tool that calls an external API without a span is invisible in traces. Wrap external calls in OTel spans or use OpenTelemetry auto-instrumentation for requests or httpx.
• Skipping callbacks. Input validation and PII redaction belong in the before_model callback, not scattered across tool implementations.
• Hard-coding to Agent Runtime. The deploy command is convenient but the agent should run anywhere. Test it in a generic Python (or TypeScript, Go, Java, or Kotlin) environment so you preserve portability.

How Future AGI implements Google ADK observability and evaluation

Future AGI is the production-grade observability and evaluation platform for Google ADK built around the closed reliability loop that other ADK stacks stitch together by hand. The platform has an Apache-2.0 core with an Enterprise edition and self-hosts with Docker Compose or Helm (see future-agi on GitHub):

• ADK tracing, traceAI (Apache 2.0) instruments ADK in Python (traceAI-google-adk, GoogleADKInstrumentor) and TypeScript (@traceai/fi-instrumentation-google-adk), so every agent call, tool call, and handoff becomes an OpenTelemetry span that the Future AGI platform stores in ClickHouse. The Google ADK multi-agent cookbook traces a four-agent ADK pipeline and reads its per-trace error analysis scores.
• Agent evals, custom evals plus built-ins such as Task Completion, Tool Call Accuracy, Groundedness, and Detect Hallucination score ADK spans; BYOK lets any LLM judge at $0 platform cost.
• Simulation, Future AGI Simulation runs ADK agents through persona-driven chat and voice scenarios before release and scores each conversation with your evals; agent-learning-kit’s local simulate engine ships a Google ADK adapter.
• Gateway and guardrails, the Agent Command Center is an OpenAI-compatible gateway with routing, failover, caching, and budgets, and its guardrails can block, monitor, or log a request before it reaches the model, next to ADK’s before_model callbacks.

Beyond the four axes, Future AGI also ships six prompt-optimization algorithms, with production traces feeding back as training data. Start on the free tier, then pay for usage. Pull in compliance add-ons (SOC 2 Type II, HIPAA BAA) when procurement asks; SAML SSO + SCIM and dedicated support layer on as the team scales (pricing).

Most teams running Google ADK in production end up running three or four tools alongside it: one for traces, one for evals, one for the gateway, one for guardrails. Future AGI is the recommended pick because tracing, evals, simulation, gateway, and guardrails all live on one platform; the loop closes without stitching. For workload-specific evaluation see the companion tutorial on evaluating Google ADK agents.

Shipping the Support Agent With Confidence

Back to the support agent from the top of this post. ADK gives that team the agent loop, the grading sub-agent, an evalset that runs on every commit, and one command to ship to Agent Runtime or Cloud Run. Once real tickets arrive, the team also needs a score on every production trace.

traceAI turns every ADK step into a span, Future AGI evals give each refund reply a task-completion score, and the team can replay a failing production conversation as the next simulation scenario. The team fixes the failure before the next deploy.

Trace your first ADK agent with the traceAI Google ADK guide.

Sources

• ADK official docs
• Agent Runtime docs on Gemini Enterprise Agent Platform
• LiteLLM provider list
• ADK Python releases
• ADK TypeScript releases
• ADK Go releases
• ADK Java releases
• ADK Kotlin releases