Google ADK: Agent Development Kit with Native A2A Support

Google ADK (Agent Development Kit) is Google's open-source framework for building single- and multi-agent systems with native support for the A2A protocol (agent-to-agent) and MCP (Model Context Protocol). It is optimized for Gemini models and Vertex AI and is aimed primarily at teams with a Google Cloud foundation. In production, the agents run on Vertex AI, Cloud Run, GKE or in your own containers. The tight coupling with Vertex AI and Gemini is both a strength and a lock-in risk.

• What it is: Google's agent framework on the provider SDK layer, tightly integrated with Vertex AI and Gemini.
• Strength: native A2A and MCP support for cross-vendor agent cooperation.
• When it makes sense: an existing Google Cloud / Gemini stack and a need for agent-to-agent interoperability via A2A.

Positioning in the agent stack

In a layered model of the agent landscape, Google ADK sits on the provider SDK layer, where the OpenAI SDK and the Anthropic SDK are also located. Above it lie the agent runtime, framework and orchestration / platform layers, and below it the foundation models, in the Google context primarily Google Gemini. Cutting across these layers are the open protocols: MCP for vertical tool connectivity (agent to tool) and A2A for horizontal agent-to-agent communication. Alongside these, AGENTS.md exists as a repo convention and AP2 as an extension for agent payments.

In practical terms, this means: with ADK you define agents as composable units of instruction, tools and model, orchestrate several of them, and expose them via A2A to other agents, including those from foreign stacks. As its technical foundation, ADK uses, like many other frameworks and SDKs (OpenAI SDK, Anthropic SDK, LangChain, LlamaIndex, CrewAI), Pydantic validation as the substrate for type-safe data structures.

Native A2A support: Google's own protocol

A2A is Google's contribution to agent interoperability. The protocol was unveiled by Google in April 2025 (with around 50 partners at launch) and handed over to the Linux Foundation in June 2025. In doing so, Google donated the specification together with its tooling. Via the version milestone v0.3 (July 2025), which introduced signed Agent Cards, A2A reached version 1.0 (GA) on March 12, 2026, its first stable specification. On April 9, 2026, marking the protocol's first year, the Linux Foundation reported over 150 backing organizations, more than 22,000 GitHub stars and five SDK languages (Python, JS, Java, Go, .NET).

For ADK, native A2A support is built in, since A2A is Google's own protocol: agents can cooperate across vendors instead of remaining within a closed Google ecosystem. MCP and A2A are complementary here, not competing: MCP standardizes tool access (agent to tool), A2A the communication between agents (agent to agent). ADK covers both axes natively.

Multi-agent setup and deployment

ADK supports building single agents as well as multiple cooperating agents. The typical patterns (sequential chains, parallel execution and hierarchical or supervisor-worker structures) can be modeled and, via A2A, also wired together across stack boundaries. As a managed runtime, Google offers Agent Runtime, called Vertex AI Agent Engine until April 2026. Since then, Vertex AI itself has been part of the Gemini Enterprise Agent Platform. ADK agents also run on Cloud Run, GKE or in any container of your own, locally in Docker or Podman as well as with EU hosting providers. ADK is optimized for Gemini. In Python, you connect other models, such as those from OpenAI, Anthropic or self-hosted open models, via LiteLLM.

For DACH-relevant workloads, the hosting path is central: Gemini via Vertex AI can be run in EU regions, which can support EU data residency. As Google is a US vendor, however, the CLOUD Act debate remains, as it does for other US cloud providers. On this path, the vendor lock-in profile is high (Google-native). Self-hosting ADK with other models cuts lock-in sharply but gives up the advantage of its Vertex AI and Gemini integration. A2A and MCP remain. DACH relevance is medium: real, but lower than for Microsoft- or Salesforce-centric DACH estates.

Differentiation from LangGraph, CrewAI and others

The following table positions Google ADK against the most widely used code-first alternatives. As of 2026; version and maturity levels are snapshots and should be checked before a project begins.

The differences can be condensed into three points. LangGraph is the low-level orchestration framework for stateful, long-running multi-step workflows with durable execution, checkpointing and mature observability (LangSmith); it is regarded as the most widespread open-source orchestration runtime in DACH engineering teams and is provider-agnostic. CrewAI scores on the fastest role-based multi-agent prototype, but is Python-only and less strict around durable state. Google ADK draws its advantage not from deeper graph logic, but from native integration with Vertex AI, Gemini and the A2A / MCP protocol world. Anyone without a Google Cloud foundation rarely gains with ADK over the provider-agnostic alternatives.

Brief example: multi-agent pipeline with A2A

Suppose an agency builds a research-and-report pipeline on Google Cloud for a B2B client. The setup in pseudocode:

```text
research_agent = Agent(
model = "gemini", # foundation layer
tools = [web_search_mcp], # tool access via MCP
instruction = "Research market X, summarize sources."
)

report_agent = Agent(
model = "gemini",
instruction = "Produce a structured report from the findings."
)

pipeline = SequentialAgent([research_agent, report_agent])

Deployment: Vertex AI

deploy(pipeline)

Exposure to foreign agents via A2A (Signed Agent Card)

expose_via_a2a(pipeline)
```

The decisive step is the last line: via A2A, the pipeline becomes discoverable and callable as a cooperating peer for external agents (say one from the Microsoft Agent Framework or the CrewAI stack) without that counterpart needing to know any Google-specific code. This very decoupling is the point of the protocol layer: the choice of framework becomes secondary to interoperability.

For agencies and B2B decision-makers

For agencies, Google ADK is relevant when clients are already anchored in Google Cloud or Gemini is set strategically. The fastest lever then lies not in proprietary pipelines, but in the consistent use of A2A and MCP. This keeps prompts, tools and eval suites framework-agnostic and a later switch realistic. For B2B decision-makers, the rule is: assess ADK along language stack, sovereignty requirements and multi-agent needs, not along GitHub stars.

If provider agnosticism or strict DACH sovereignty without a US cloud is the goal, ADK can also be self-hosted and run with other models. You then lose the advantage of its Vertex AI and Gemini integration, while A2A and MCP remain. In that case, a self-hosted LangGraph setup (for instance on STACKIT, IONOS or OVHcloud), self-hosted Pydantic AI or n8n (Berlin) is usually the more viable choice. Note that the EU region of Logfire, Pydantic's observability service, runs on Google Cloud in the Netherlands. The notes on GDPR and the EU AI Act are informational and do not replace legal advice. Blck Alpaca supports framework selection, A2A / MCP interop design and the sovereign hosting path. Talk to us for a well-founded evaluation.