---
title: "What Is Google ADK (Agent Development Kit)? A 2026 Guide"
url: "https://atlan.com/know/ai-agent/ai-agent-applications/what-is-google-adk/"
description: "Google ADK is an open-source framework for building, evaluating, and deploying AI agents. See its components, ADK 2.0 workflows, runtime, and Atlan fit."
author: "Kovid Rathee"
author_role: "Head of Solution Architecture, Data & AI, Nexifi"
published: "2026-10-06"
updated: "2026-10-06"
---

> Atlan is hosting Context Conference, bringing together the leaders and builders at the frontier of giving AI the context it needs to understand their business. It runs online on October 28, 2026, from 11:00 AM to 2:00 PM ET. Atlan co-founder Prukalpa Sankar opens and closes the day. Leaders from AstraZeneca, BNY and Verizon share why they invest in context and what they get from it. Registrants get early access to The AI Context Gap, a new study from MIT Technology Review Insights. Register: https://atlan.com/context-conference/

---

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](https://atlan.com/know/what-is-context-layer/), and its [MCP server](https://atlan.com/know/what-is-atlan-mcp/) plugs into an ADK agent as a tool, so definitions, lineage, ownership, and certification arrive under the permissions already set in Atlan.

### Shortlist Agent Frameworks for Your Stack

Takes your languages, orchestration style, protocols, hosting, state, and governance needs, and returns a ranked shortlist of up to three frameworks with the deciding trade-off for each and what each one leaves unsolved. [Read the skill](/skills/agent-framework-picker.md).

*Paste into a new chat*

```
Use the skill at https://atlan.com/skills/agent-framework-picker.md to shortlist agent frameworks for our stack. Ask me for whatever it needs.
```

*Run once in a terminal*

```
curl -fsSL --create-dirs \
  -o ~/.agents/skills/agent-framework-picker/SKILL.md \
  https://atlan.com/skills/agent-framework-picker.md
```

*For an agent*

```
curl -fsSL https://atlan.com/skills/agent-framework-picker.md
```


    Human
    Agent


  ClaudeChatGPTGeminiCursorOther
  Copy

.skp{margin:1.75rem 0;padding:1rem 1.125rem 1.125rem}
.skp h3{margin:0 0 .375rem!important;font-size:20px!important;line-height:24px!important;
 font-family:var(--font-funnel-display)!important;font-weight:600!important;color:#2B2B39!important}
.skp > p{margin:0 0 .875rem!important;font-size:14px!important;line-height:22px!important;color:#555572!important}
.skp > p a{color:#2026D2;text-decoration:underline}
.skp-box{margin-bottom:.75rem}
.skp-p em{display:block;font-size:10px;font-weight:700;letter-spacing:.06em;text-transform:uppercase;
 color:#F34D77;font-style:normal;margin-bottom:.25rem}
.skp-p > p{margin:0!important}
#seo-layout article .skp .skp-p pre{margin:0!important;overflow-x:auto}
#seo-layout article .skp .skp-p pre code{color:#2B2B39!important;font-size:12px!important;line-height:19px;
 white-space:pre-wrap;overflow-wrap:anywhere;background:none;padding:0;
 font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
.skp-p + .skp-p{margin-top:.625rem}
.skp-cs{display:flex;flex-wrap:wrap;align-items:center;gap:.375rem}
.skp-seg{display:inline-flex;flex:0 0 auto;border:1px solid #DDDDE3;border-radius:999px;overflow:hidden;background:#fff}
.skp-m{min-height:32px;padding:.25rem .75rem;border:0;background:transparent;font-family:inherit;color:#77778E;cursor:pointer}
.skp-m:hover{color:#2026D2}
.skp-m.on{background:#2026D2;color:#fff}
.skp-sep{flex:0 0 auto;width:1px;height:20px;background:#DDDDE3;margin:0 .25rem}
.skp-tools{display:inline-flex;flex-wrap:wrap;gap:.375rem;min-width:0}
.skp-cp{margin-left:auto;min-height:32px;padding:.25rem .75rem;border-radius:999px;background:#fff;
 font-family:inherit;color:#555572;cursor:pointer}
.skp-cp:hover{border-color:#2026D2!important;color:#2026D2}
.skp-cs .skp-c{display:inline-flex!important;width:auto;flex:0 0 auto;align-items:center;gap:.375rem;
 min-height:32px;padding:.25rem .625rem;border-radius:999px;background:#fff;font-family:inherit;
 color:#555572;cursor:pointer}
.skp-cs .skp-c img{display:block!important;width:14px!important;height:14px!important;
 max-width:14px!important;flex:0 0 auto;opacity:.55;margin:0}
.skp-c:hover img,.skp-c.on img{opacity:1}
.skp-cs .skp-c:hover{border-color:#797DE4!important;color:#2026D2}
.skp-cs .skp-c.on{border-color:#2026D2!important;background:#F4F4FD;color:#2026D2}
.skp-agent .skp-tools,.skp-agent .skp-sep{display:none}

(function(){
  var p=document.querySelector('.skp[data-skill="agent-framework-picker"]');if(!p)return;
  var panes=p.querySelectorAll('.skp-p');
  function show(id){panes.forEach(function(x){x.hidden=x.dataset.skp!==id;});}
  function cur(){var a=p.querySelector('.skp-p:not([hidden]) pre code');return a?a.textContent:'';}
  show('prompt');
  p.querySelectorAll('.skp-p em').forEach(function(e){
    var par=e.parentElement;
    ((par.tagName==='P'&&par.textContent.trim()===e.textContent.trim())?par:e).hidden=true;
  });
  p.querySelectorAll('.skp-c').forEach(function(b){
    b.addEventListener('click',function(){
      p.querySelectorAll('.skp-c').forEach(function(x){var on=x===b;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      show(b.dataset.skp);
    });
  });
  p.querySelectorAll('.skp-m').forEach(function(m){
    m.addEventListener('click',function(){
      var agent=m.dataset.skpMode==='agent';
      p.classList.toggle('skp-agent',agent);
      p.querySelectorAll('.skp-m').forEach(function(x){var on=x===m;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      if(agent){show('agent');}else{var s=p.querySelector('.skp-c.on');show(s?s.dataset.skp:'prompt');}
    });
  });
  var c=p.querySelector('[data-skp-copy]');
  c.addEventListener('click',function(){
    navigator.clipboard.writeText(cur()).then(function(){
      c.textContent='Copied';setTimeout(function(){c.textContent='Copy';},1600);
    });
  });
})();

| | |
|---|---|
| **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](https://adk.dev/) 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](https://adk.dev/agents/llm-agents/) |
| Tools | Function tools, MCP toolsets, agent tools, OpenAPI tools, skills, plugins, and callbacks | [MCP tools](https://adk.dev/tools-custom/mcp-tools/) |
| Agent context | Session, state, events, memory, artifacts, compaction, and caching | [Sessions](https://adk.dev/sessions/session/) |
| Runtime | The event loop, the Workflow Runtime, and the ways to run an agent | [Event loop](https://adk.dev/runtime/event-loop/) |

### 1. Agents and models

An `LlmAgent` is the core unit. According to the [ADK documentation](https://adk.dev/agents/llm-agents/), 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](https://adk.dev/)). The [models documentation](https://adk.dev/agents/models/google-gemini/) lists Gemini and Gemma alongside Claude, OpenAI models, Ollama, vLLM, and LiteLLM. Google's own [Gemini Enterprise Agent Platform documentation](https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/adk) 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`](https://adk.dev/agents/workflow-agents/sequential-agents/) 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`](https://adk.dev/agents/workflow-agents/parallel-agents/) starts all sub-agents at once. The documentation states there is no automatic sharing of conversation history or state between the branches.
- [`LoopAgent`](https://adk.dev/agents/workflow-agents/loop-agents/) 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](https://adk.dev/agents/custom-agents/) 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](https://adk.dev/tools-custom/function-tools/): 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](https://adk.dev/tools-custom/mcp-tools/) documents stdio and Streamable HTTP connections, and `to_mcp_server` for exposing ADK tools to other MCP clients.
- An [`AgentTool`](https://adk.dev/tools-custom/mcp-tools/agent-managed/), which wraps an `LlmAgent` as a tool for a parent orchestrator. For agents running elsewhere, ADK documents the [Agent2Agent protocol](https://adk.dev/a2a/) for exposing and consuming remote agents; the [Google A2A protocol](https://atlan.com/know/google-a2a-protocol/) explainer covers how it works.
- [OpenAPI tools](https://adk.dev/tools-custom/openapi-tools/), which generate callable tools from an OpenAPI 3.x specification.
- [Skills](https://adk.dev/skills/), which are based on the open [Agent Skills specification](https://agentskills.io/specification) and load in three levels so they use little of the context window until needed. The [agent skills explainer](https://atlan.com/know/ai-agent/ai-agent-skills/what-are-agent-skills/) and the comparison of [agent skills and MCP](https://atlan.com/know/ai-agent/ai-agent-skills/agent-skills-vs-mcp/) show where each fits.
- [Plugins](https://adk.dev/plugins/) and [callbacks](https://adk.dev/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](https://atlan.com/know/ai-agent/ai-agent-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](https://adk.dev/sessions/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](https://adk.dev/sessions/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](https://adk.dev/events/) | Messages, tool calls, tool results, state changes, control signals, and errors | Appended to the session history |
| [Memory](https://adk.dev/sessions/memory/) | A searchable archive of past sessions, reached through `MemoryService` | Across sessions |
| [Artifacts](https://adk.dev/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](https://adk.dev/context/compaction/) summarizes older history, triggered by token volume or by a sliding window of turns. [Context caching](https://adk.dev/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](https://atlan.com/know/ai-agent/ai-agent-context/agent-context-management/) problem in its own right. The same split shows up in [agent memory architectures](https://atlan.com/know/agent-memory-architectures/) and in the difference between a [context window and a context store](https://atlan.com/know/ai-agent/ai-agent-context/context-window-vs-context-store-ai-agents/).

### 4. Runtime

The [runtime event loop](https://adk.dev/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](https://adk.dev/runtime/web-interface/), launched with `adk web`, for testing and debugging. The documentation says ADK Web is not meant for production deployments.
- The [command line](https://adk.dev/runtime/command-line/), with `adk run`, which the documentation describes as useful for quick tests, scripted interactions, and CI/CD pipelines.
- The [API server](https://adk.dev/runtime/api-server/), with `adk api_server`, which exposes agents through a REST API for programmatic testing and integration.
- [Ambient agents](https://adk.dev/runtime/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](https://adk.dev/2.0/), 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](https://adk.dev/graphs/) | 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](https://adk.dev/graphs/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](https://adk.dev/workflows/collaboration/) | 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](https://atlan.com/know/single-agent-vs-multi-agent-systems/) decision and the [multi-agent coordination patterns](https://atlan.com/know/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](https://adk.dev/agents/llm-agents/):

```python
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](https://adk.dev/get-started/python/) 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](https://adk.dev/evaluate/). 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](https://atlan.com/know/ai-agent/ai-agent-evals/what-is-context-testing-for-ai-agents/).

Deployment targets are documented on the [deployment page](https://adk.dev/deploy/): [Agent Runtime](https://adk.dev/deploy/agent-runtime/), a fully managed auto-scaling service on Google Cloud; [Cloud Run](https://adk.dev/deploy/cloud-run/), where Python uses `adk deploy cloud_run`; Google Kubernetes Engine; or any container-friendly infrastructure. Whatever you pick, [observability for AI agents](https://atlan.com/know/ai-agent-observability/) and [agent governance](https://atlan.com/know/ai-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](https://atlan.com/know/mcp/mcp-for-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](https://atlan.com/know/ai-agent/microsoft/agent-framework/), [CrewAI](https://atlan.com/know/ai-agent/what-is-crewai/), the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview), or [Strands Agents](https://strandsagents.com/). Both of the last two document MCP support. The [Microsoft Agent Framework comparison](https://atlan.com/know/ai-agent/microsoft/microsoft-agent-framework-vs-other-agent-frameworks/) and the broader guide to [choosing an agentic framework](https://atlan.com/know/ai-agent/how-to-choose-agentic-framework-enterprise/) cover how teams decide. A single [context layer](https://atlan.com/know/agent-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](https://atlan.com/know/ai-agent/agent-harness-vs-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](https://atlan.com/know/ai-agent/databricks/what-is-databricks-omnigent-meta-harness/) and on [Databricks Omnigent](https://atlan.com/know/ai-agent/databricks/databricks-omnigent-vs-neutral-context-layer/) and in the [Omnigent agent runtime](https://atlan.com/know/ai-agent/databricks/databricks-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](https://atlan.com/know/ai-agent/ai-agent-applications/google-adk-vs-langgraph-vs-autogen/) and the [framework roundup](https://atlan.com/know/ai-agents-frameworks-compared/).

---

## 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](https://atlan.com/know/enterprise-data-graph/), an [Active Ontology](https://atlan.com/know/what-is-active-ontology/), and [Context Repos](https://atlan.com/know/ai-agent/context-repository-for-ai-agents/). Teams assemble those repos in **Context Engineering Studio**. According to the [Atlan documentation](https://docs.atlan.com/platform/context-engineering-studio/what-is-context-engineering-studio), 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](https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/remote-mcp-overview) 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](https://atlan.com/know/context-engineering-for-ai-agents/) describes that split, and a [model-agnostic context layer](https://atlan.com/know/ai-agent/context-layer/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](https://adk.dev/tools-custom/mcp-tools/) 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](https://atlan.com/know/how-to-implement-enterprise-context-layer-for-ai/), the [MCP architecture deep dive](https://atlan.com/know/ai-agent/mcp-architecture-deep-dive/), and the guide to [building MCP servers for enterprise data](https://atlan.com/know/ai-agent/how-to-build-mcp-servers-for-enterprise-data/). When several agents share one MCP surface, an [MCP gateway](https://atlan.com/know/ai-agent/what-is-an-mcp-gateway/) is the next question. The [agent interoperability protocols](https://atlan.com/know/agent-interoperability-protocols/) page and [MCP vs A2A](https://atlan.com/know/mcp/mcp-vs-a2a-protocol/) 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](https://atlan.com/know/ai-agent/how-to-connect-ai-coding-agent-to-data-warehouse-mcp/), and teams on AWS can compare [Amazon Bedrock Knowledge Bases with an external data catalog](https://atlan.com/know/ai-agent/aws/amazon-bedrock-knowledge-bases-vs-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/