Two Agents From Two Different Companies Can't Talk Unless They Share an Address Book

Here's the deal: when we argue about agents, we argue about intelligence. Reasoning benchmarks, tool-call success rates, context windows. But anybody who has actually shipped agents inside a company hits a wall somewhere else entirely. If your procurement agent wants to ask a supplier's logistics agent "when does this purchase order land," both agents need to speak the same language. Defining that language is what a protocol does.

On August 17, 2026, two of those languages moved into the same house. Google's A2A (Agent2Agent) protocol became a formally hosted project of the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation. AAIF already had MCP (Model Context Protocol) — Anthropic's donation — as one of its founding projects. So the rules for how an agent calls a tool and the rules for how agents talk to each other now sit under one roof, one governance structure, one technical committee process.

One clarification before we go further, because the coverage has been muddy. This is not the news that Google is releasing A2A, and it is not the news that Google is giving up ownership for the first time. A2A launched on the Google Developers Blog on April 9, 2025, and Google Cloud donated it to the Linux Foundation on June 23, 2025 at Open Source Summit North America. What happened last week is the next step down: a project that had been floating as a standalone Linux Foundation effort got reassigned into a specific fund. It is an administrative move-in. Some outlets dated the announcement to August 20, but the AAIF blog, the Axios exclusive, and Techzine all point to August 17. And since you're reading this on August 25, note that the news is eight days old — slightly outside our usual week.

"So it's just a change of address?" Half right. But in open source infrastructure, the address matters more than people expect. Which foundation, which fund, which technical steering committee determines who approves spec changes, how fast a security patch ships, who holds the trademark, and who arbitrates when two vendors disagree. If you watched how the cloud infrastructure fight played out over the last fifteen years, you already know why a change of address is news.

The Cast — Two Protocols, One Foundation, and a Row of Clouds Watching

A2A is the first character. Google Cloud shipped it in April 2025 with more than fifty launch partners, including Atlassian, Box, Intuit, MongoDB, and Workday. The core idea is disarmingly simple. Every agent publishes an Agent Card — a JSON business card sitting on the open web that says "here's what I can do, here's my endpoint, here's how you authenticate." Another agent reads that card, delegates a Task, and gets results back as Artifacts. Everything rides on boring, proven web plumbing. The v1.0.0 spec defines three protocol bindings: JSON-RPC, gRPC, and HTTP+JSON/REST.

MCP is the second character. Anthropic released it in November 2024, and it standardizes how an agent reaches down into files, databases, APIs, and internal systems. The direction is the whole point — MCP goes downward. It's the wiring that lets a model read your company wiki, write a record into your CRM, open a local file. As of December 2025, the MCP blog reported 97 million monthly SDK downloads and 10,000 active servers, with support across ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot, and VS Code.

AAIF is the third. The Linux Foundation announced its formation on December 9, 2025 with exactly three founding project contributions: Anthropic's MCP, Block's agent framework goose, and OpenAI's AGENTS.md. Governance runs on two tiers — a Governing Board handling strategy, budget, and member recruitment, and a Technical Committee that approves projects and runs technical review. The stated principle is that the Linux Foundation supplies neutral infrastructure (legal entity, trademark, CI, counsel) while individual project maintainers keep full technical autonomy.

Then there are the humans. AAIF CTO Manik Surtani — who previously led goose at Block — said A2A "represents an important step toward an open, interoperable future for AI agents." Google Cloud VP Rao Surapaneni framed it as a move that "further empowers enterprises to build and scale agentic systems on a truly open foundation." Linux Foundation Executive Director Jim Zemlin had already set the frame at AAIF's launch, saying the goal was to avoid a walled-off stack where agent connections and behavior stay locked behind one platform.

And behind all of them sit the clouds. AAIF's platinum members are AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Getting those eight names around one table tells you most of what you need to know about this market: nobody thinks they can set the standard alone anymore.

What Actually Happened — Not a Transfer of Ownership, a Transfer of Membership

The AAIF blog post on August 17, 2026 says A2A has moved from standalone Linux Foundation stewardship into AAIF's hosted project portfolio. The foundation's framing is that this consolidates governance of the entire agentic stack — "from context instructions to agent-to-agent communication" — under unified, vendor-neutral oversight.

The key detail is that the protocols were placed side by side, not merged. A2A and MCP remain distinct projects with separate technical steering committees. What changes is that their roadmaps get aligned. Forcing the two specs into one document would break both, because they solve genuinely different problems. What you align instead is release cadence, security response, and cross-referenced documentation.

By the numbers, A2A is well past the experiment phase. Per the Linux Foundation's April 9, 2026 press release: over 150 supporting organizations (up from about 50 at the April 2025 launch), more than 22,000 GitHub stars on the core repository, and five production-ready official SDKs covering Python, JavaScript, Java, Go, and .NET. The v1.0 stable spec landed in March 2026. And in August 2025, IBM's Agent Communication Protocol was merged into A2A, retiring one competing standard before it could fragment the field.

Deployments are specific, too. Microsoft wired A2A into Azure AI Foundry and Copilot Studio. AWS added support through Amazon Bedrock AgentCore Runtime. The AAIF announcement named Huawei's HarmonyOS, Tencent's WeChat, and PayPal among production users. The Linux Foundation cited supply chain coordination, financial services transactions, insurance operations, and IT operations management as live domains.

Dimension MCP (Model Context Protocol) A2A (Agent2Agent)
What it connects Agent ↔ tools, data, apps Agent ↔ another agent
Direction Vertical — reaches downward Horizontal — reaches sideways
Origin Anthropic (released November 2024) Google (released April 9, 2025)
Foundation entry December 9, 2025, AAIF founding project June 2025 Linux Foundation → August 17, 2026 AAIF
Core primitives Servers, tools, resources, prompts Agent Cards, Tasks, Messages, Parts, Artifacts
Transports JSON-RPC based JSON-RPC / gRPC / HTTP+JSON REST
Public metrics 97M monthly SDK downloads, 10,000 active servers (Dec 2025) 150+ supporting orgs, 22,000+ GitHub stars, 5 official SDKs (Apr 2026)
What it does NOT do Negotiate or delegate with peer agents Supply tools and context to a model

That last row is the one to internalize. These protocols do not substitute for each other. With only MCP, a single agent has to grab every tool in the world and do all the work itself. With only A2A, agents can talk to each other but none of them can actually touch a real system. You need both before "our agent delegates to a partner's agent, which queries its own ERP and returns an answer" becomes a real workflow instead of a slide.

Membership growth is worth a look too. Forkast reported AAIF went from 49 founding members to more than 250 in under a year. That figure comes from press tallying rather than a foundation disclosure, so treat the exact as-of date as unconfirmed.

Who Got What Out of This

Google bought credibility. Be honest about the dynamics: as long as Google owned A2A outright, deep adoption by Microsoft or AWS meant tying their own agent platforms to a rival's spec. Letting go of ownership is how you buy adoption. It worked before — when Google donated A2A to the Linux Foundation in June 2025, AWS and Cisco signed on as founding members immediately. This AAIF move strips off the last "this is a Google project" label. Google remains the largest contributor and ships new spec support first in Gemini, ADK, and Vertex AI, so the trade is clear: give up owning the standard, keep being the best implementation of it.

Anthropic has every reason to welcome a neighbor. MCP is already a de facto standard, but it only covers one layer — tool connectivity. If the layer above it fragments, everything built on MCP fragments with it. Having A2A land in the same foundation gets Anthropic a completed stack without conceding an inch of its own protocol. Anthropic's David Soria Parra put the strategy plainly at AAIF's launch, describing the goal as having "enough adoption in the world that it's the de facto standard." The safest way to win a standards war is to make sure there isn't one.

Microsoft and AWS bought a hedge. Both have enormous bets riding on their own agent platforms — Copilot Studio, Bedrock AgentCore — and it is uncomfortable to build on a protocol a competitor controls. Under a neutral foundation, spec changes go through a board, and they sit on that board. What was a threat yesterday becomes public road today.

The other ~246 members — the Bloombergs of the list, large enterprises that consume rather than author protocols — bought leverage. They have no interest in inventing a spec. They want to build on something that still exists in five years. Foundation membership guarantees that if a vendor pivots or dies, the code and the trademark stay with the foundation. For an enterprise procurement reviewer, that line item beats any benchmark score.

Three Precedents — Kubernetes, OpenTelemetry, and Symbian

Success case one: Kubernetes and the CNCF. Google donated Kubernetes to the newly formed CNCF under the Linux Foundation in 2015. At the time, Docker owned container mindshare, and neither Amazon nor Microsoft had any reason to adopt an orchestrator built and controlled by Google. You know what happened after the handoff. AWS, Azure, and Alibaba all shipped managed Kubernetes, and Google traded standard ownership for a market where cloud workloads became portable — then competed with GKE inside it. The A2A move is nearly the same script, with Google running the same play a second time. Notably, MCP's own announcement post reached for the same comparison, describing AAIF as "the same neutral stewardship that supports Kubernetes, PyTorch, and Node.js."

Success case two: OpenTelemetry. Observability once had two competing standards — OpenTracing under the CNCF and OpenCensus driven by Google. Library authors had to support both or pick a loser, and that stalemate dragged on for years. Only after the two merged into OpenTelemetry in 2019 did the instrumentation ecosystem take off. The agent world was sitting at exactly that fork. IBM folding ACP into A2A in August 2025, and now A2A and MCP sharing a foundation, both read as the industry deliberately refusing to relive the OpenTracing years.

Failure case: the Symbian Foundation. The counterexample matters more. Nokia bought Symbian OS in 2008, open-sourced it, and handed it to a neutral body called the Symbian Foundation. The member roster was spectacular — Sony Ericsson, Samsung, Motorola, AT&T, Vodafone. On paper it looked stronger than AAIF does today. Two years later the foundation had effectively dissolved, and Nokia pulled the code back behind closed doors. The reason is unglamorous: the foundation existed, but developers never actually built on it. Governance does not manufacture adoption. What separates real infrastructure from a logo alliance is production traffic, not member count. TechCrunch raised precisely this doubt when AAIF launched, wondering openly whether it would become real infrastructure or just another industry logo alliance.

So what's the argument that A2A ends up as Kubernetes rather than Symbian? The metrics. 22,000 stars, five SDKs, 150 organizations, and live deployments in HarmonyOS, WeChat, and PayPal. A2A was already in use before the foundation move. Symbian handed a dying asset to a foundation; Google handed over a living one. That distinction does most of the work.

How the Competition Punches Back

The most interesting counter-play is join it, then differentiate one layer up. Microsoft and AWS have no reason to block A2A. Instead they fill the space A2A deliberately does not define — agent identity, audit logging, cost controls, policy engines — with proprietary platform features. The cheaper the protocol gets, the more the operations layer above it is worth. Azure AI Foundry and Bedrock AgentCore are aimed at exactly that spot. It is the same pattern as Kubernetes: once the orchestrator standardized, EKS, AKS, and GKE started competing on management, security, and billing instead.

Second, there's OpenAI's genuinely awkward position. OpenAI co-founded AAIF and contributed AGENTS.md, but AGENTS.md is an instruction-file convention for coding agents — not remotely the same weight class as A2A or MCP. Meanwhile OpenAI is pushing its own Agents SDK and apps ecosystem, and is more inclined to solve agent collaboration inside its own platform first. Sitting at the table while keeping the crown jewels off it is a workable stance; whether it holds is another question.

Third, the payments and commerce layer is where the real fight is heading. An A2A-adjacent family of extensions is emerging — AP2 (Agent Payments Protocol), A2UI, and UCP — built on A2A's extensibility model. The Linux Foundation said AP2 has passed 60 supporting organizations. The moment agents start paying for things, card networks, PSPs, and platforms all pile in, and that gets uglier than the transport layer ever did. No neutral standard has set there yet.

Fourth, watch the China-side stack. Huawei's HarmonyOS and Tencent's WeChat showing up as A2A production users is significant. Both also run their own agent ecosystems, which leaves room for a dual strategy — adopt the international standard, then layer domestic extensions on top. One protocol with divergent dialects is interoperability in name only.

And finally there's the do-nothing counter-play. Plenty of companies still haven't put multi-agent systems into production. A single agent with a pile of MCP tools handles most workflows just fine. A2A's real competitor may not be another protocol at all — it may be the reasonable position that you don't need more than one agent yet.

So What Actually Changes

If you're a developer, nothing in your code breaks. Spec URLs, GitHub repos, SDK package names all stay the same. What's worth changing is your reading habit: start tracking A2A and MCP release notes together. Aligned roadmaps means the way the two specs reference each other is about to get cleaned up, and agent identity and authentication are the likeliest places where duplicated concepts get reconciled. If you're wiring up A2A for the first time, start with the Agent Card schema and the Task lifecycle. With v1.0.0 being a stable spec, you can build against it without bracing for breaking changes.

If you're an enterprise practitioner, you just gained a line for your procurement doc. "Who owns this protocol?" now answers with "the Agentic AI Foundation under the Linux Foundation," and that answer clears vendor lock-in review far more easily than a single-vendor spec. Practically, this is a decent moment to scope a pilot: the spec is stable, all three major clouds support it, and there are real production references rather than interop demos. Just budget for what A2A does not cover — behavioral auditing, spend ceilings, rollback on failure. That's still your design problem.

If you're an investor, read this coldly. Protocol neutralization means nobody makes money on the protocol itself. Value migrates outward — downward into inference infrastructure, upward into orchestration, observability, identity, and payments. "Agent protocol startup" is going to get progressively harder to defend as a positioning statement. Conversely, anyone building multi-agent operations tooling benefits as the standard hardens, because a stable substrate expands the addressable market. The post-Kubernetes growth of observability, security, and FinOps vendors is the pattern worth studying.

If you're just a user, there's almost nothing to feel yet. But if a few years from now your calendar assistant negotiates directly with an airline's booking agent to move a flight, the wiring underneath has a decent chance of being A2A. Right now the road is being paved. Paving a road doesn't guarantee traffic.

🥄 Three Things You're Probably Wondering

— So what does this mean for me? Not much today. Unless you're a developer chaining multiple agents together or an enterprise practitioner scoping agent deployments, the practical change is close to zero. The one thing worth banking is that when your AI assistant eventually starts trading work with other companies' services, the rules underneath will be shared property rather than one vendor's, and that shows up later as choice.

— Why now, specifically? A2A shipped its v1.0 stable spec in March 2026 and published first-year metrics in April — 150+ organizations, 22,000+ stars — which is when it lost the experimental label. Moving governance while a spec is still churning just adds confusion; moving it after the spec sets is a signal that it's done churning. The sequencing looks deliberate.

— Isn't this just a logo alliance? That risk is real. The Symbian Foundation had a gorgeous member roster and folded within two years, and TechCrunch raised the same doubt about AAIF at launch. The meaningful difference is that A2A and MCP were both running in production before they entered the foundation. Even so, it's too early to call the standard settled — the layers above, like payments and identity, aren't anywhere near consolidated.

Further Reading

Numbers are as of announcement and may change.