A2A Goes Neutral: 250 Vendors, One Agent Standard

On August 17, Axios reported that Google’s Agent2Agent protocol is becoming a hosted project of the Agentic AI Foundation, the Linux Foundation body that already governs Model Context Protocol. The company that wrote the spec no longer gets to decide where it goes.

That’s the opposite of the story I wrote yesterday.

Yesterday the news was Stripe buying OpenRouter for more than $7 billion, a neutral routing layer swallowed by a company with a payments agenda. Today a Google-controlled protocol moved to independent governance, with AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow already shipping against it. Same week. Opposite direction. If you’re deciding right now whether to write custom agent-to-agent glue or bet on a standard, those two data points are the whole decision.

Quick Verdict

Question	The Answer
What happened?	A2A became a hosted project of the Agentic AI Foundation, reported by Axios on August 17, 2026.
Who controls it now?	AAIF, under Linux Foundation governance. Not Google.
Was it already open?	Partly. Google donated the spec and SDKs to the Linux Foundation in June 2025. This moves it into the agent-specific foundation.
How big is the foundation?	250+ organizations per Axios. The Linux Foundation’s own August 13 count was 247.
How fast did it grow?	Launched December 9, 2025. Roughly 6x in eight months.
Is the spec stable?	Yes. A2A v1.0 shipped in March 2026, the first production-grade release.
A2A or MCP?	Both. MCP connects an agent to tools. A2A connects agents to each other.
Do I need it today?	Only if you run agents across trust boundaries. Most SMBs don’t yet.
What should I do this week?	Nothing expensive. Make your agent interfaces swappable and check which vendors ship A2A endpoints.
Real risk of ignoring it?	Custom point-to-point integrations you’ll rip out in 2027.

What does A2A joining the Agentic AI Foundation actually change?

Governance, not code. A2A already lived under the Linux Foundation as of June 2025; this moves it into the foundation built specifically for agent standards, alongside MCP, goose, AGENTS.md, and agentgateway. The practical effect: no single vendor can change the spec’s direction, and the eight-company technical steering committee stays the decision-making body.

Your existing A2A integration does not break. Nothing ships differently on Monday. What changed is the answer to the question a procurement lead asks at minute 40 of a vendor call: who owns this thing if the vendor loses interest?

MCP Is the Port. A2A Is the Phone Line.

I described MCP as USB for AI agents back in March, and that analogy still holds. One connector, any tool. Your agent plugs into Airtable, your file system, your CRM, without bespoke integration code for each.

A2A solves a different problem. It defines how two independent agents find each other, agree on what each can do, hand off a task, and pass results back. Think phone numbers and a dial tone. MCP lets your agent pick up a wrench. A2A lets your agent call someone else’s agent and ask them to do the part you don’t own.

Here’s why that distinction matters commercially. An MCP server is something you or a vendor builds and you control. An A2A handoff crosses a boundary between two companies. Your procurement agent talking to a supplier’s fulfillment agent. Your support agent handing a billing dispute to a payment processor’s agent. Neither side controls the other’s model, prompt, or logging. That’s where an actual standard earns its keep, because you cannot write custom glue for every counterparty you’ll ever have.

The spec grew up to match. A2A v1.0 in March 2026 added signed Agent Cards for cryptographic identity, multi-tenancy, and three protocol bindings: JSON+HTTP, gRPC, and JSON-RPC. Official SDKs cover Python, Go, Java, JavaScript, .NET, and Rust. Signed identity is the part I’d underline. An unsigned agent claiming to be your supplier’s fulfillment system is a phishing email with an API.

The Consolidation Nobody Announced

Eighteen months ago the honest read on agent protocols was that we’d get a format war. IBM had Agent Communication Protocol. Google had A2A. Anthropic had MCP. Everyone assumed three specs, three toolchains, and a decade of adapters.

That didn’t happen. Here’s the actual sequence:

Date	What happened
April 2025	Google launches A2A
June 2025	Google donates A2A spec, SDKs, and tooling to the Linux Foundation
August 2025	IBM’s Agent Communication Protocol merges into A2A
December 9, 2025	Agentic AI Foundation forms with MCP, goose, and AGENTS.md
March 2026	A2A v1.0 ships, first stable spec
August 13, 2026	AAIF adds 57 members, reaching 247 organizations
August 17, 2026	A2A becomes an AAIF hosted project

Two competing protocols merged instead of fighting. Then the winner handed itself to a neutral body that its own rivals help govern. The AAIF’s platinum tier at launch included AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Those companies agree on almost nothing else.

(One bookkeeping note: Axios says the foundation grew from fewer than 40 organizations at launch, while the Linux Foundation’s December press release named 47 across three tiers. Different counting rules, probably associate members. The 6x direction is what matters, not the starting digit.)

The August membership wave is the tell that this stopped being a developer story. New gold members included Alibaba Group, Visa, and Wells Fargo. AAIF executive director Mazin Gilbert put it plainly in the announcement: top financial institutions “recognize that building agents at scale requires neutral infrastructure they can depend on.”

Banks joining a protocol foundation is not enthusiasm. It’s risk management. They’re buying a seat at the table before their vendors start making interoperability claims they can’t audit.

Where A2A Is Already Running

The deployment list is more interesting than the membership list, because it’s harder to fake.

• Huawei standardized on A2A for Celia, its OS-level assistant on HarmonyOS
• Tencent’s WeChat integrates with Huawei and Android OEM assistants over it
• Google Cloud, Microsoft Azure AI Foundry, and AWS Bedrock AgentCore all support A2A natively
• Google Cloud and PayPal are extending it into commerce via the Agent Payments Protocol
• More than 150 organizations back the standard, per the foundation

Read the third bullet twice. The three major clouds support the same agent protocol. If you’ve spent the last two years assuming multi-cloud AI means writing everything twice, that assumption has an expiration date on it now.

The Skeptic’s Case Is Still Half Right

I’m not going to sell you on protocol enthusiasm. Two objections deserve a real answer.

Objection one: most teams haven’t solved single-agent reliability yet. True, and I’ve said so repeatedly. Agents fail on plumbing, not intelligence, and adding a second agent to a workflow where the first one drops tool calls just gives you two things to debug. If your agent can’t reliably read your CRM today, agent-to-agent negotiation is not your bottleneck.

Objection two: interoperability widens the trust surface. Mahesh Shanmugasundaram of Seekr made this point well in Techstrong’s coverage, warning about an “AI game of telephone” where each agent “treats the prior agent’s output as 100% trusted input vs. a claim to be verified.” Hallucinations compound down a chain. So do prompt injections, which is exactly the failure pattern behind the agents that faked identities to breach real companies earlier this year.

Both objections argue against deploying multi-agent workflows this quarter. Neither argues against the standard. A protocol with signed identity and a published trust model is the thing that makes those risks auditable. Custom point-to-point integrations have the same trust gap with none of the tooling.

The correct position: slow down on multi-agent architecture, and be fast about making sure whatever you do build speaks the standard.

How do you get A2A-ready without rebuilding anything?

Five steps. A competent engineer finishes the first three in an afternoon, and none of them require you to deploy a multi-agent system.

1. Add “A2A support” to your vendor evaluation checklist. Same line item as SOC 2. Ask for the roadmap date, not a yes or no. Vendors who can’t answer are telling you something.
2. Inventory every place two systems already hand off AI work. Ticket routing into billing, lead scoring into CRM, document extraction into approval. Those are your future A2A boundaries, and most of them are cron jobs and webhooks today.
3. Keep agent capability definitions in config, not code. Same rule I’ve pushed for model identifiers. If adopting a protocol means editing a config file instead of a rewrite, you can wait for the ecosystem instead of betting on it.
4. Do not write a custom agent-to-agent integration with an outside party this year. If a partner wants your agents talking to theirs, ask for A2A. The spec is stable, the SDKs cover six languages, and the alternative is a bilateral contract you maintain forever.
5. Assign one person to watch the AAIF project list quarterly. Twenty minutes. MCP, A2A, agentgateway, AGENTS.md. When a fifth project lands there, that’s your signal that a category just standardized.

Steps 1 and 4 are policy decisions you can make in a meeting. Steps 2 and 3 are the engineering work, and both pay off whether or not you ever ship a multi-agent workflow.

My Read

Three things I think are true.

Neutral governance is now a purchasable feature, and it’s cheap. Google gave up unilateral control of a protocol it created, and got a standard that AWS and Microsoft will ship in their own products. That trade only makes sense if the ecosystem is worth more than the control, which it obviously is at this point. Expect more of these donations, and expect “hosted by a neutral foundation” to show up in enterprise RFPs the way “open source” did fifteen years ago.

The OpenRouter comparison is the useful frame. A hosted service can be sold. A specification governed by a foundation with 247 members cannot. When I wrote yesterday that the abstraction is the strategy and the vendor is an implementation detail, this is the other half of that argument. Standards survive acquisitions. Products don’t. Where you have the choice, put your integration surface on the spec.

Most SMBs should still not build multi-agent systems in 2026. The economics I laid out in Gemini Spark Just Priced Your AI Agent Layer haven’t moved. One well-instrumented agent with good MCP connections beats a fleet of agents negotiating with each other, and it beats it on cost, latency, and the number of things that can silently go wrong at 2am. A2A becoming a real standard doesn’t change that. It changes what you build when you eventually do need it, and it changes what you should refuse to build in the meantime.

Here’s the version I’d give a business owner who doesn’t care about protocols. The thing that made AI integrations expensive was never the AI. It was that every connection between two systems was a custom project with an owner, a maintenance bill, and a person who leaves the company. That’s the same problem 76% of SMBs using AI without integrating it are stuck inside. Standards are how that cost goes away, and this week a big piece of it moved to a place where no single vendor can take it back.

The Bottom Line

Google handed its agent-interoperability protocol to a foundation that AWS, Microsoft, Anthropic, and OpenAI help govern, in the same week a neutral AI routing layer got bought by a payments company. One of those events made your stack safer. Membership at 247 organizations and climbing, a stable v1.0 spec since March, and native support in all three major clouds mean A2A is past the point where you need to bet on whether it wins.

You still don’t need to deploy it this quarter. What you need is to stop building the thing it replaces.

Your Next Step: Open your integration inventory and find every place your systems hand AI-generated work from one tool to another. For each one, write down who maintains the connector and what happens if that vendor changes their API. Then add a single line to your vendor questionnaire asking for A2A and MCP support dates. That’s an hour of work, it costs nothing, and it turns the next two years of agent tooling from a series of custom projects into a procurement question.

---

Related Reading:

• OpenRouter’s $7B Stripe Deal Kills the Lock-In Pitch
• MCP Hit 97M Installs. Is Your Stack Ready?
• Your AI Agents Are Failing. It’s Not the Model.
• Gemini Spark Just Priced Your AI Agent Layer
• AI Agents Faked Identities to Hack Real Companies
• Model-Agnostic Workflows: Your AI Stack Has an Expiration Date