A2A Protocol at One: How Google’s Agent Communication Standard Quietly Became the Internet for AI

Here's a number that should make you pause: 150 organizations. That's how many companies — including AWS, Microsoft, Cisco, SAP, and Salesforce — have now adopted the Agent-to-Agent (A2A) protocol, just one year after Google open-sourced it and handed it to the Linux Foundation.

In April 2025, A2A was a Google side project with 50 early backers. By April 2026, it had 22,000 GitHub stars, production-grade SDKs in five languages (Python, JavaScript, Java, Go, .NET), and native integration across all three major cloud platforms. Quietly, something important happened: what people called "infrastructure" a year ago is becoming infrastructure.

What Just Happened

On April 9, 2026, the Linux Foundation announced that A2A had surpassed 150 supporting organizations and entered enterprise production use across multiple industries. Here's the breakdown:

• Cloud platform integration: AWS embedded A2A natively into Bedrock AgentCore Runtime. Microsoft integrated it into Azure AI Foundry and Copilot Studio. Google Cloud — the original contributor — made it the default communication layer across its AI ecosystem.
• SDK ecosystem: The project expanded from Python-only to five production languages, reaching developers across the full enterprise stack.
• AP2 companion protocol: A parallel standard called the Agent Payments Protocol (AP2) launched with backing from 60+ financial institutions, enabling agents to not just talk to each other — but transact.

Real production deployments are already running. Supply chain networks use A2A to let autonomous agents from different vendors coordinate shipments without human handoffs. Insurance companies route claims across heterogeneous agent systems for underwriting and settlement. IT operations teams run cross-platform troubleshooting where one vendor's agent delegates sub-tasks to another's.

Why A2A Matters: From API Spaghetti to Shared Infrastructure

Think about the internet before TCP/IP. Every network used its own protocols. IBM had SNA. DEC had DECnet. Connecting two different systems meant writing custom gateways — expensive, brittle, and slow. TCP/IP didn't make networks faster. It made them compatible. That's what A2A is doing for AI agents.

The core problem A2A solves is deceptively simple: how does one AI agent discover, talk to, and delegate work to another AI agent that it's never met before? Without a standard, every agent-to-agent handshake requires custom integration code. With A2A, agents publish an "Agent Card" — a standardized manifest describing their capabilities, endpoints, and authentication requirements — and other agents discover them automatically.

This is the same pattern that made the web work. Websites publish their structure via DNS and HTTP. Browsers read it. Nobody at Google Chrome has to call anyone at nginx to make sure a new site loads. A2A brings that same zero-negotiation interoperability to the agent ecosystem.

And here's the thing people miss: infrastructure is defined by what you don't think about. When you make a phone call, you don't negotiate signaling protocols. When you browse a website, you don't configure TCP handshakes. A2A took a year to go from "someone called it infrastructure" to "it's actually becoming invisible infrastructure." The future it points to isn't futuristic — it's already here.

Key Details: What A2A Actually Does

The Agent Card: A Universal Business Card for AI

Every A2A-compatible agent publishes a machine-readable Agent Card. Think of it as a YAML file crossed with an API spec. It declares what the agent can do (e.g., "fraud detection for banking transactions"), what inputs it needs (transaction data, customer profile), its security requirements (OAuth2, API key), and how to reach it (endpoint URL). Other agents read this card and decide whether to delegate work — no human involved.

MCP Handles Tools, A2A Handles Collaboration

A common confusion: MCP (Model Context Protocol) and A2A sound similar but solve different problems. MCP — originally from Anthropic and now also under the Linux Foundation — standardizes how a single agent connects to tools and data sources. A2A standardizes how multiple agents talk to each other. They're complementary layers in the same stack: MCP is the agent's internal toolkit; A2A is the agent's social network.

Agent Payments: When Agents Need Wallets

The launch of AP2 (Agent Payments Protocol) signals something bigger. If agents can delegate work and transact autonomously, you get an agent-to-agent economy where specialized agents charge for services — a fraud-detection agent performing checks for an e-commerce agent, billed per transaction. Over 60 financial institutions backing AP2 suggests they see this as a real revenue stream, not a thought experiment.

What This Means For Different Groups

• For enterprise developers: You can now build agent systems that call agents from other vendors without custom integrations. Pick the best fraud-detection agent, the best logistics agent, the best customer-facing agent — they'll negotiate via A2A.
• For startups: A2A lowers the barrier to building specialty agents. You don't need to build a platform. Build one agent that does one thing extremely well, publish an Agent Card, and let the ecosystem find you.
• For end users: You won't see A2A. You'll just notice your customer service agent actually knows what the logistics agent promised you — because they talked to each other.

The Bigger Picture: Digital Public Infrastructure Is Being Built Right Now

What's happening with A2A mirrors the early days of the internet in one critical way: nobody owns it. The Linux Foundation hosts it. Five languages have SDKs. Three cloud platforms run it natively. It's not a Google product — it's a public protocol. That's precisely what makes it infrastructure.

The vision of AI agents as shared infrastructure — like the telephone network or the internet itself — isn't just a metaphor anymore. When 150 organizations from AWS to SAP all agree on how agents should talk to each other, and when 60 financial institutions sign on for agent-to-agent payments, you're watching the TCP/IP moment for AI. Some people said it would happen. Now it's actually happening.

FAQ

What's the difference between A2A and MCP?
A2A governs communication between agents (agent-to-agent). MCP governs how a single agent connects to tools and data sources (model-to-context). They're complementary and both live under the Linux Foundation.

Is A2A only for Google's ecosystem?
No. It's an open standard under the Linux Foundation with SDKs in five languages. AWS Bedrock, Azure AI Foundry, and Google Cloud all support it natively.

Do I need A2A to build an AI agent?
Not for a single agent. A2A becomes valuable when you want your agent to work with agents built by other teams or vendors — the multi-agent use case.

What's AP2 and why does it matter?
The Agent Payments Protocol enables agents to charge for services autonomously. Backed by 60+ financial institutions, it hints at a future agent-to-agent economy.

Bottom Line

A2A took one year to go from a Google open-source release to the Linux Foundation's fastest-growing agent project, with 150+ organizations, all three major clouds, and production deployments in supply chain, finance, and insurance. It's not a standard being debated — it's a standard being used. If you're building multi-agent systems, this is the protocol you'll be speaking. Want to understand the agent communication stack? Check out our MCP vs A2A deep dive and our guide to multi-agent orchestration frameworks.

Related Reading

• Can China's First AI Agent Regulation Turn Its 'Doer' Advantage Into a Global Le
• China's AI Agent Battle Royale: Inside the Six-Way War for Enterprise Deployment
• The AI Agent Safety Debate: Are We Overthinking the Risks?