Google's A2A protocol turned one year old on April 9. One hundred fifty organizations signed on. Twenty-two thousand GitHub stars. Five production SDKs. IBM's competing ACP merged into it under the Linux Foundation. Azure AI Foundry and Amazon Bedrock AgentCore both embed it.

By every metric except the one that matters, A2A won.

The metric that matters: zero major agent SDKs ship native A2A support today. Not one. The protocol that was supposed to let any AI agent discover and delegate tasks to any other agent — regardless of vendor — spent its entire first year collecting logos while the SDKs developers actually use went in the opposite direction.

Thirteen days, four moats

Between April 3 and April 15, 2026, four companies shipped their own multi-agent delegation features. None of them interoperate.

On April 3, Microsoft released Agent Framework v1.0 — the only framework that even attempts multi-vendor coordination, with connectors for Claude, GPT, Gemini, and Bedrock. A2A support? "Coming soon." On April 8, Anthropic launched Managed Agents in public beta: sandbox execution, state persistence, multi-agent coordination — Claude-only, no A2A mention. On April 9, A2A itself hit its one-year milestone with a press release full of numbers and no SDK integrations. Then on April 15, OpenAI shipped Agents SDK v0.14 with Sandbox Agents and handoff primitives — model-agnostic in theory, no A2A in practice.

Four vendors. Thirteen days. Four incompatible dialects of the same idea. And the one protocol designed to unify them sat in the corner with its 150 organizational supporters and watched.

What "no adoption" looks like in code

Here's Anthropic's delegation model. You create a managed agent via their REST API — it runs in Anthropic's sandbox — and your coordinator delegates through sessions:

import anthropic

client = anthropic.Anthropic()

# Create a managed agent (runs in Anthropic's cloud sandbox)
agent = client.agents.create(
    model="claude-sonnet-4-20260514",
    instructions="You are a research specialist.",
    tools=[{"type": "web_search"}],
)

# Start a session — the coordinator sends a subtask
session = client.sessions.create(
    agent_id=agent.id,
    messages=[{"role": "user", "content": "Analyze A2A adoption metrics"}]
)

Now here's OpenAI's approach — different runtime, different philosophy entirely:

from openai_agents import Agent, handoff

research_agent = Agent(name="researcher", model="gpt-4.1")
coding_agent = Agent(name="coder", model="gpt-4.1")

# Handoff: research_agent transfers full control to coding_agent
research_agent.handoffs = [handoff(coding_agent)]

Two code blocks. Two ecosystems. Zero shared interface surface. Your Claude agent can't handoff() to an OpenAI agent, and your OpenAI agent can't sessions.create() on Anthropic's infra. They literally don't share a single method call.

A2A defines AgentCards for discovery, a task lifecycle for delegation, and streaming — all vendor-neutral. It was built to be the layer that makes the two snippets above unnecessary. Instead, both SDKs shipped without acknowledging it exists.

Why 150 logos didn't translate

A2A has everything a standard needs except the thing that makes standards stick: friction-free integration at the point of use. No pip install a2a drops into an Anthropic or OpenAI project. No middleware auto-translates a handoff() into an A2A task. The protocol lives in its own repository, with its own SDKs, requiring developers to build and maintain translation shims between their actual orchestration framework and A2A's task model.

If you try bridging vendor SDKs through A2A today, you hit the classic N-squared problem: every pair of vendor SDKs needs a custom bridge. Three vendors means six bridges. Four means twelve. This scales about as well as fax machines.

Then there's latency. Every protocol translation hop adds measurable overhead — enough that chaining three agents through bridge layers burns noticeable wall-clock time before any thinking starts. For agentic loops that iterate repeatedly through reasoning and tool use, this compounds fast.

And governance remains a blind spot across the board. Your coordinator agent can't inspect the reasoning of a sub-agent running on another vendor's infrastructure. You're trusting output you fundamentally cannot audit. A2A's spec doesn't address this either.

Microsoft's bet — and why it's interesting

Microsoft's Agent Framework v1.0 is the outlier worth watching. It's the only shipping framework that coordinates across Claude, GPT, Gemini, and Bedrock in a single delegation graph. It doesn't use A2A yet — that "coming soon" disclaimer is doing a lot of work — but it proves multi-vendor orchestration is technically feasible when one vendor controls the routing layer.

The catch: someone has to own the routing layer. Microsoft volunteers. That's not interop — that's a different kind of lock-in, one tier up.

The pragmatic architecture

The decision for anyone building today is straightforward but bitter: pick single-vendor orchestration and use MCP tools as the interop escape valve. One vendor's agent framework owns the delegation graph, MCP handles external data and tool access. It's exactly the lock-in the multi-model promise was supposed to prevent.

MCP proved that tool access could be standardized — one protocol, every vendor adopted it within months. Agent-to-agent delegation is the same problem one layer up, and A2A is the obvious candidate to solve it. The spec is sound. The governance is real. The organizational support is broad.

But a protocol that isn't embedded in the SDKs developers reach for is a protocol that exists only on paper. A2A turned one. It has everything except the only thing that counts: a line in someone else's import statement.