What Is Google ADK (Agent Development Kit)? A 2026 Guide

---

Google ADK is the open-source framework a team picks when it wants agent logic written in code: which node runs next, which tool fires, what lives in session state. What ADK does not supply is the business meaning behind the data those agents read. Atlan is the Context Layer for AI, and its MCP server plugs into an ADK agent as a tool, so definitions, lineage, ownership, and certification arrive under the permissions already set in Atlan.

What it is	An open-source framework for building, debugging, and deploying agents, with SDKs in Python, TypeScript, Go, Java, and Kotlin
Current version	ADK 2.0: Python v2.0.0 reached GA on May 19, 2026, Go v2.0.0 on June 30, 2026, and TypeScript v2.0.0 on August 21, 2026. Java and Kotlin have no GA date listed
Core idea in 2.0	A Workflow Runtime that treats agents, tools, and functions as nodes in a graph
Models	Gemini first, plus adapters for other providers, including locally running models
Where agents run	Locally, on Agent Runtime, on Cloud Run, on GKE, or in any container environment
What it leaves to you	The enterprise context an agent needs, which arrives through MCP tools and other external systems

---

What are the core components of Google ADK?

Google ADK is described by its own documentation as an open-source agent development framework for building, debugging, and deploying agents at enterprise scale. Four groups of components cover everything from the agent definition to the process that runs it.

Component group	What it covers	Where the docs go deeper
Agents and models	LlmAgent, workflow agents, custom agents, and the models behind them	LlmAgent
Tools	Function tools, MCP toolsets, agent tools, OpenAPI tools, skills, plugins, and callbacks	MCP tools
Agent context	Session, state, events, memory, artifacts, compaction, and caching	Sessions
Runtime	The event loop, the Workflow Runtime, and the ways to run an agent	Event loop

1. Agents and models

An LlmAgent is the core unit. According to the ADK documentation, it combines a model, an instruction, and tools, with an optional planner and an optional code executor. The model is a string identifier such as gemini-flash-latest.

ADK says it can work with almost any generative AI model: it gives easy access to Gemini and provides adapters for other providers, including locally running models (see the ADK overview). The models documentation lists Gemini and Gemma alongside Claude, OpenAI models, Ollama, vLLM, and LiteLLM. Google’s own Gemini Enterprise Agent Platform documentation describes ADK as open source and available in Python, TypeScript, Go, and Java, and says you can run agents locally or scale them on Agent Runtime, Cloud Run, or GKE.

ADK 1.x shipped three template workflow agents, all deterministic and none steered by a model:

• SequentialAgent runs sub-agents in list order and passes the same invocation context to each, so they share session state. An output_key is how one agent’s result reaches the next.
• ParallelAgent starts all sub-agents at once. The documentation states there is no automatic sharing of conversation history or state between the branches.
• LoopAgent repeats its sub-agents until it hits a maximum iteration count or a sub-agent escalates. It does not decide when to stop on its own, so you build the exit.

Anything beyond those templates meant a custom agent that inherits from BaseAgent. Sub-agents do not have to call a model at all. A custom BaseAgent can check state, run a script, or run tests inside a larger workflow, which is how teams keep the predictable steps predictable.

2. Tools

Tools control how an agent acts outside the model conversation. ADK documents these types:

• A function tool: assign a Python function to an agent’s tools list and ADK wraps it, reading the signature and docstring to build the schema the model sees.
• An McpToolset, which connects the agent to an MCP server. The MCP tools page documents stdio and Streamable HTTP connections, and to_mcp_server for exposing ADK tools to other MCP clients.
• An AgentTool, which wraps an LlmAgent as a tool for a parent orchestrator. For agents running elsewhere, ADK documents the Agent2Agent protocol for exposing and consuming remote agents; the Google A2A protocol explainer covers how it works.
• OpenAPI tools, which generate callable tools from an OpenAPI 3.x specification.
• Skills, which are based on the open Agent Skills specification and load in three levels so they use little of the context window until needed. The agent skills explainer and the comparison of agent skills and MCP show where each fits.
• Plugins and callbacks. Callbacks are functions that fire before and after agent, model, and tool calls. Plugins register once on the runner and apply to every agent, tool, and model call it manages.

Every tool call becomes an event the agent receives, and the output becomes context for the next step. That makes tool use the main route for external knowledge to enter an ADK agent.

3. Agent context

ADK splits an agent’s working context across five constructs. They differ in scope and lifetime:

Construct	What it holds	Lifetime
Session	One conversation thread, its events, and its state	One conversation; durable with the database or Vertex AI session service, lost on restart with the in-memory one
State	A key-value scratchpad with user:, app:, and temp: prefixes	temp: keys are discarded after the invocation; the others persist only with a persistent session service
Events	Messages, tool calls, tool results, state changes, control signals, and errors	Appended to the session history
Memory	A searchable archive of past sessions, reached through MemoryService	Across sessions
Artifacts	Named, versioned binary data such as files, scoped to a session or a user	Versioned on every save

Two features keep long runs inside the model’s window. Context compaction summarizes older history, triggered by token volume or by a sliding window of turns. Context caching reuses large instructions or data across requests and works with Gemini 2.0 and higher models.

This is the agent’s own working memory. It is separate from the knowledge an agent pulls from external systems, which is a context management problem in its own right. The same split shows up in agent memory architectures and in the difference between a context window and a context store.

4. Runtime

The runtime event loop is a back-and-forth between the Runner and your execution logic. An agent yields an event, the runner processes its actions, such as state changes, and only then does the agent resume. ADK documents four ways to start an agent:

• The web interface, launched with adk web, for testing and debugging. The documentation says ADK Web is not meant for production deployments.
• The command line, with adk run, which the documentation describes as useful for quick tests, scripted interactions, and CI/CD pipelines.
• The API server, with adk api_server, which exposes agents through a REST API for programmatic testing and integration.
• Ambient agents, which run as background processes that respond to events from Cloud Pub/Sub or Eventarc without human intervention.

---

What changed in ADK 2.0?

ADK 2.0 introduced the Workflow Runtime. In the words of the ADK 2.0 overview, it moves ADK “from a hierarchical agent executor to a graph-based execution engine,” with agents, tools, and functions evaluated as nodes in a workflow graph. Three workflow patterns sit on top of it:

Workflow type	How you define it	Use it when
Graph-based	Nodes (agents, code functions, tools, other workflows) joined by edges	The process is fixed and you want it defined in code instead of in a prompt
Dynamic	Your language’s own loops, conditionals, and recursion	The execution order depends on data and is awkward to draw as a static graph
Collaborative	A coordinator agent delegating to bounded sub-agents	Several specialists share one task

Graph workflows are available in Python, TypeScript, and Go v2.0.0. Collaborative sub-agents run in one of three modes: chat, task, or single-turn, which differ in how much the user can interact and how control returns to the coordinator.

The practical effect is that a team can mix deterministic code with model reasoning in one graph. The wider single-agent versus multi-agent decision and the multi-agent coordination patterns behind collaborative workflows apply here as they do in any framework.

---

How do you define and run an agent in Google ADK?

The minimum is a model, a name, and an instruction. This example follows the pattern in the LlmAgent documentation:

from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    model="gemini-flash-latest",
    name="research_agent",
    instruction=(
        "You are a research expert. Research any topic you are given "
        "and return a report with your findings."
    ),
)

The Python quickstart shows the project layout: a folder holding agent.py, __init__.py, and .env, with root_agent defined in agent.py as the only required element. Run adk run research_agent or adk web from the parent directory of that folder.

Before deploying, evaluate the agent. The documentation notes that deterministic pass/fail assertions are often unsuitable for model-driven agents, so ADK evaluates both the final response and the trajectory of steps taken, using test files, evalsets, and CLI tools that fit into CI/CD. Teams that want evaluation of the context itself can read about context testing for AI agents.

Deployment targets are documented on the deployment page: Agent Runtime, a fully managed auto-scaling service on Google Cloud; Cloud Run, where Python uses adk deploy cloud_run; Google Kubernetes Engine; or any container-friendly infrastructure. Whatever you pick, observability for AI agents and agent governance need to be in place before real users arrive.

---

How do you ground ADK agents in enterprise context?

ADK gives an agent several sources of context. Instructions and skills define the job. Artifacts carry files and generated output. Session state holds working data. The source that reaches enterprise systems is the MCP tool: an McpToolset lets an agent call any MCP server, including those that expose data lineage and business definitions.

The weak point is scale. Each team that wires its own MCP connections repeats the setup, and teams running more than one framework repeat it again, whether the second framework is Microsoft Agent Framework, CrewAI, the Claude Agent SDK, or Strands Agents. Both of the last two document MCP support. The Microsoft Agent Framework comparison and the broader guide to choosing an agentic framework cover how teams decide. A single context layer that every framework reads from moves the repeated work out of each agent project. See also the difference between an agent harness and an agent framework, since the two often get confused when teams scope this work, and how the same question plays out in the Databricks Omnigent meta-harness and on Databricks Omnigent and in the Omnigent agent runtime.

Choosing among frameworks is a decision with its own filters. The skill above walks through them for one team’s stack. For a head-to-head view, see how ADK compares with LangGraph and AutoGen and the framework roundup.

---

How does Atlan give ADK agents an enterprise context layer?

Atlan connects to the systems an enterprise already runs and organizes what it learns about them into an Enterprise Data Graph, an Active Ontology, and Context Repos. Teams assemble those repos in Context Engineering Studio. According to the Atlan documentation, a context repository is the unit of work there: the canonical definition of what your data means for one use case. The studio autogenerates an evaluation set to test it and publishes it to engines including Snowflake Cortex Analyst, Databricks Genie, dbt, and Claude.

An ADK agent reaches all of it through one connection. The MCP documentation describes a hosted server at https://mcp.atlan.com/mcp that lets an agent search enterprise context, traverse end-to-end lineage, read governed definitions, and run SQL. It lists Google ADK among the supported clients.

The result is a clean division of labor. The agent team keeps building agents and workflows in ADK, and the work of assembling, curating, and maintaining enterprise context sits in one place. Context engineering for AI agents describes that split, and a model-agnostic context layer matters most for a framework that is itself model-agnostic.

---

What does the MCP connection mean for permissions and setup?

Authentication decides what the agent can see. With OAuth, each person signs in with their own account, so tools run with their own permissions and their actions are attributed to them. An API key is a single static token that acts as one shared identity, which the documentation recommends for automation, agents, or service accounts. For an unattended ADK agent, the permissions of that one service identity apply to everything the agent reads, so scope it deliberately.

The documented example for ADK uses McpToolset with a stdio connection that bridges the hosted server through mcp-remote, and OAuth opens a browser sign-in on first run. ADK’s MCP documentation also supports Streamable HTTP for remote servers, so confirm the current connection method in both sets of docs before wiring a production agent.

For the build-out, see how to implement an enterprise context layer, the MCP architecture deep dive, and the guide to building MCP servers for enterprise data. When several agents share one MCP surface, an MCP gateway is the next question. The agent interoperability protocols page and MCP vs A2A cover how agents talk to each other. Teams coding agents against a warehouse can also read how to connect an AI coding agent to a data warehouse over MCP, and teams on AWS can compare Amazon Bedrock Knowledge Bases with an external data catalog.

---

Moving forward with Google ADK

Google ADK is an open-source framework for building agents as code, now in its 2.0 generation, with graph, dynamic, and collaborative workflows on a Workflow Runtime. Its depth shows in the pieces around the model: tools, callbacks, session state, memory, artifacts, an event loop, evaluation, and several ways to deploy.

Start with the smallest agent that proves the model and tool choices, add evaluation early, and decide before launch how the agent will get enterprise context. An agent that cannot tell a certified metric from a stray column will answer confidently and wrong, whatever framework runs it. Whether one MCP connection to a context layer is enough for your agents, or whether you need gateway, registry, and policy layers around it, is a question your own deployment will answer.

---

FAQs about Google ADK

1. What is Google ADK (Agent Development Kit)?

Google ADK is an open-source agent development framework for building, debugging, and deploying AI agents in code. It has SDKs for Python, TypeScript, Go, Java, and Kotlin. ADK 2.0 added a Workflow Runtime that runs agents, tools, and functions as nodes in a graph, and it reached GA for Python, Go, and TypeScript between May and August 2026.

2. Where can you run agents built with Google ADK?

You can run ADK agents locally, on Agent Runtime in Google Cloud, on Cloud Run, on Google Kubernetes Engine, or on any infrastructure that runs container images. The ADK web interface is for development and debugging only, and its documentation says it is not meant for production deployments.

3. Which models can Google ADK use?

ADK gives easy access to Gemini and provides adapters for other models and providers, including locally running models. Its documentation lists Gemini, Gemma, Claude, OpenAI models, Ollama, vLLM, and LiteLLM as model options. Context caching in ADK works with Gemini 2.0 and higher models.

4. How does ADK work with an MCP server?

ADK connects an agent to an MCP server through McpToolset, over stdio for local servers or Streamable HTTP for remote ones. ADK can also expose its own tools to other MCP clients through to_mcp_server. Each tool the server offers becomes a tool the agent can call during a run.

5. How do you connect an ADK agent to Atlan?

Point an McpToolset at the Atlan MCP server at https://mcp.atlan.com/mcp. Atlan’s documentation shows an example that bridges the hosted server through mcp-remote over stdio, with OAuth sign-in in the browser on first run. OAuth runs tools with each person’s own Atlan permissions, while an API key acts as one shared identity for automation and service accounts.

---

Sources

1. Agent Development Kit (ADK) overview, Google ADK Documentation, 2026. https://adk.dev/
2. Welcome to ADK 2.0, Google ADK Documentation, 2026. https://adk.dev/2.0/
3. Google Gemini models for ADK agents, Google ADK Documentation, 2026. https://adk.dev/agents/models/google-gemini/
4. Agent Development Kit, Google Cloud Documentation, 2026. https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/adk
5. Simple agents with LlmAgent, Google ADK Documentation, 2026. https://adk.dev/agents/llm-agents/
6. Sequential template workflow agent, Google ADK Documentation, 2026. https://adk.dev/agents/workflow-agents/sequential-agents/
7. Parallel template workflow agent, Google ADK Documentation, 2026. https://adk.dev/agents/workflow-agents/parallel-agents/
8. Loop template workflow agent, Google ADK Documentation, 2026. https://adk.dev/agents/workflow-agents/loop-agents/
9. Custom agent template workflows, Google ADK Documentation, 2026. https://adk.dev/agents/custom-agents/
10. Graph-based agent workflows, Google ADK Documentation, 2026. https://adk.dev/graphs/
11. Dynamic agent workflows, Google ADK Documentation, 2026. https://adk.dev/graphs/dynamic/
12. Build collaborative agent teams, Google ADK Documentation, 2026. https://adk.dev/workflows/collaboration/
13. Function tools, Google ADK Documentation, 2026. https://adk.dev/tools-custom/function-tools/
14. Model Context Protocol tools, Google ADK Documentation, 2026. https://adk.dev/tools-custom/mcp-tools/
15. Manage MCP with Sub-Agents, Google ADK Documentation, 2026. https://adk.dev/tools-custom/mcp-tools/agent-managed/
16. ADK and the A2A Protocol, Google ADK Documentation, 2026. https://adk.dev/a2a/
17. Integrate REST APIs with OpenAPI, Google ADK Documentation, 2026. https://adk.dev/tools-custom/openapi-tools/
18. Skills for ADK agents, Google ADK Documentation, 2026. https://adk.dev/skills/
19. Agent Skills specification, agentskills.io, 2026. https://agentskills.io/specification
20. Plugins, Google ADK Documentation, 2026. https://adk.dev/plugins/
21. Callbacks: Observe, Customize, and Control Agent Behavior, Google ADK Documentation, 2026. https://adk.dev/callbacks/
22. Session: Tracking individual conversations, Google ADK Documentation, 2026. https://adk.dev/sessions/session/
23. State: The Session’s Scratchpad, Google ADK Documentation, 2026. https://adk.dev/sessions/state/
24. Events, Google ADK Documentation, 2026. https://adk.dev/events/
25. Memory: Long-term knowledge with MemoryService, Google ADK Documentation, 2026. https://adk.dev/sessions/memory/
26. Artifacts, Google ADK Documentation, 2026. https://adk.dev/artifacts/
27. Compress agent context for performance, Google ADK Documentation, 2026. https://adk.dev/context/compaction/
28. Context caching with Gemini, Google ADK Documentation, 2026. https://adk.dev/context/caching/
29. Runtime Event Loop, Google ADK Documentation, 2026. https://adk.dev/runtime/event-loop/
30. Use the Web Interface, Google ADK Documentation, 2026. https://adk.dev/runtime/web-interface/
31. Use the Command Line, Google ADK Documentation, 2026. https://adk.dev/runtime/command-line/
32. Use the API Server, Google ADK Documentation, 2026. https://adk.dev/runtime/api-server/
33. Trigger actions with ambient agents, Google ADK Documentation, 2026. https://adk.dev/runtime/ambient-agents/
34. Python quickstart, Google ADK Documentation, 2026. https://adk.dev/get-started/python/
35. Why evaluate agents, Google ADK Documentation, 2026. https://adk.dev/evaluate/
36. Deploying Your Agent, Google ADK Documentation, 2026. https://adk.dev/deploy/
37. Deploy to Agent Runtime, Google ADK Documentation, 2026. https://adk.dev/deploy/agent-runtime/
38. Deploy to Cloud Run, Google ADK Documentation, 2026. https://adk.dev/deploy/cloud-run/
39. Set up Atlan MCP, Atlan Documentation, 2026. https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/remote-mcp-overview
40. What is Context Engineering Studio, Atlan Documentation, 2026. https://docs.atlan.com/platform/context-engineering-studio/what-is-context-engineering-studio
41. Agent SDK overview, Claude Code Documentation, Anthropic, 2026. https://code.claude.com/docs/en/agent-sdk/overview
42. Strands Agents, Strands Agents Documentation, 2026. https://strandsagents.com/