Google ADK 2.0 Stable Solidifies the Multi-Agent Protocol Split

The simultaneous stable releases of Google's Agent Development Kit (ADK) 2.0.0 and the a2a-sdk 1.0.3 mark a quiet but permanent fork in how developers build agentic systems. This is not just another minor version bump. By jumping from 1.29 to 2.0, Google has committed to a stable API surface, signaling that its multi-agent orchestration framework is ready for production workloads.

This release matters because of the architectural split it exposes. In March 2026, OpenAI declined a 1,200-line pull request to support the Agent-to-Agent (A2A) protocol within their agents SDK. While the request remains open in the community, the rejection was a clear statement of intent. OpenAI is betting on highly capable, autonomous, single-agent sandboxes. Google is betting on a standardized, multi-agent protocol layer where specialized agents discover and collaborate with each other.

For developers, this means the honeymoon phase of generic agent wrappers is over. You now have to choose between two fundamentally different architectural paths.

The Architectural Fork: Monolith vs. Protocol

To understand the split, look at what each ecosystem is optimizing for.

OpenAI's Agents SDK focuses on maximizing the capability of a single agent. Their Sandbox Agents run code, operate virtual filesystems, and persist snapshots. When multiple agents are needed, OpenAI uses an SDK-internal handoff model. The coordination logic is tightly coupled to the SDK itself. If Agent A wants to hand off to Agent B, both must exist within the same runtime context, and the handoff is negotiated through model-specific instructions.

Google's ADK 2.0 takes a distributed, protocol-first approach. Instead of building a single, massive agent that tries to do everything, Google relies on the A2A protocol. A2A is a standardized protocol that allows agents to discover, call, and share context across network boundaries.

Under this model, agents are treated like microservices. They can be written in different languages, run on different infrastructure, and be managed by different teams. A Go-based agent running on Google Cloud Run can discover and call a Python-based agent running locally, as long as both speak A2A.

How ADK 2.0 Structures Workflows

ADK 2.0 moves away from the probabilistic chat loops of the 1.0 era, where developers simply gave an LLM a system prompt and some tools and hoped for the best. Instead, it introduces deterministic, graph-based workflows.

To build a reliable system, ADK 2.0 enforces a strict three-layer split:

1. Tool Layer (MCP): Handles raw actions like database queries or API calls. This layer contains no business logic.
2. Agent Layer (A2A): Houses domain expertise (e.g., a specialized document retriever or a code executor). It reasons but does not manage the overall user session.
3. Orchestrator Layer (ADK): Manages user intent, planning, global memory, and human-in-the-loop approvals.

Within the orchestrator, workflows are modeled as graphs with explicit nodes and edges. ADK 2.0 provides three core orchestration patterns to manage these graphs:

• SequentialAgent: Executes a linear pipeline of tasks.
• ParallelAgent: Spawns concurrent sub-tasks, which is highly effective for gathering data from multiple sources simultaneously.
• LoopAgent: Iteratively refines outputs until a specific termination condition or quality gate is met.

According to Google Cloud data, moving from manual information gathering to a parallelized multi-agent search using ParallelAgent drastically reduces execution time for complex research tasks.

xychart-beta
title "Research Brief Creation Time (Minutes)"
x-axis [Manual, ADK ParallelAgent]
y-axis "Time in Minutes" 0 --> 240
bar [240, 45]

The Code: Handoffs vs. A2A Discovery

The difference between these two approaches is obvious when looking at the code.

With OpenAI's handoff model, the coordination is internal to the SDK. The agents must be defined together, and the handoff is a tool-like mechanism:

from openai.agents import Agent

agent_a = Agent(
    model="gpt-4-turbo",
    tools=[retrieve_docs],
)

agent_b = Agent(
    model="gpt-4-turbo",
    tools=[reason_and_execute],
)

# Coordination is SDK-internal; Agent A must explicitly hand off to Agent B
response = agent_a.run("Get docs and hand off to agent_b to reason about them")

With Google ADK 2.0 and the A2A SDK, the agents are decoupled. They do not need to know about each other's implementation details, only their A2A interfaces:

from google.genai.adk import Agent
from a2a_sdk import A2AClient

agent_a = Agent(
    name="document_retriever",
    model="gemini-2.0-pro",
    tools=[retrieve_docs],
)

# Agent B can discover and call Agent A over the network
client = A2AClient()
retriever = client.discover("document_retriever")
response = retriever.call(query="Get docs for Q4", context={})

Because this interaction happens over a network boundary, you can write agent_a in Python and agent_b in Go using the Go Packages distribution of ADK, without breaking the coordination logic.

Developer Trade-offs and Caveats

Choosing between these frameworks requires evaluating your team's infrastructure and the complexity of your workload.

When to choose OpenAI Agents:

• You are building a single, highly autonomous agent that needs deep access to a local environment (e.g., a coding assistant that needs to run tests and modify files locally).
• Your team is entirely Python or TypeScript-based and does not want to manage network protocols between agents.
• You want to use OpenAI's native real-time voice and text-to-speech capabilities.

When to choose Google ADK 2.0:

• You are building enterprise systems where different teams own different domain agents (e.g., an HR agent and a Finance agent that need to talk to each other).
• You require multi-language support. ADK is available in Python, TypeScript, Go, Java, and Kotlin.
• You need deterministic control flows, parallel execution, and strict state isolation to prevent context pollution in long-running tasks.

The Gotchas:

While ADK 2.0 is stable, it is not without friction. Its built-in evaluation tool, AgentEvaluator, is helpful for pre-deployment testing but does not extend to production monitoring. You will still need a third-party observability provider for live traffic.

Additionally, while models like Gemini 2.5 Flash offer massive 1M token context windows, reasoning quality can degrade past 200K tokens. If you are using ParallelAgent to aggregate massive amounts of data, you must design your orchestrator to keep individual sub-agent contexts focused and clean.

The Verdict

OpenAI's rejection of the A2A protocol makes sense for their strategy. They want to build the most capable, human-like reasoning models, and wrapping those models in highly autonomous sandboxes is the fastest way to get there.

But for enterprise developers building complex, multi-departmental workflows, monolithic agents are an operational bottleneck. Google's stable ADK 2.0 and A2A SDK release provides the tooling needed to build distributed, language-agnostic agent networks. If your architecture requires interoperability and strict control, the protocol-first path is now stable enough to build on.