AI Agents Now Have a Shared Standard for Talking to Each Other

On August 17, 2026, the Agentic AI Foundation (AAIF) announced that Agent2Agent (A2A) has officially joined as a hosted project. If you haven't run into A2A before, here's the short version: it's an open standard that lets AI agents built by different companies, on different frameworks, talk to each other and hand off work without someone writing custom integration code for every single pairing.

That last part is the whole point. Before A2A, if your company's agent needed to talk to a partner's agent, someone had to build a custom connector for that exact combination. Add a new vendor, write another connector. A2A gives agents a shared language instead, so that work doesn't have to happen from scratch every time.

The core idea is simple. Every agent publishes something called an agent card, which is a structured description of what that agent can do and how to reach it. Other agents read that card, see what's available, and delegate tasks directly, no human needed to broker the handoff.

Think of it like a business card, except machines can actually read it and act on it. One agent finds another, checks what it's capable of, and hands off a task in a structured, observable way. It works the same regardless of what framework either agent was built on.

A2A isn't a brand new idea someone rushed out. It's had time to prove itself.

• Google launched A2A in April 2025.
• Google donated it to the Linux Foundation in June 2025, with founding backers including AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow.
• In August 2025, IBM's competing Agent Communication Protocol merged into A2A instead of continuing as a rival standard. IBM's own engineers joined A2A's technical steering committee.
• A2A reached its v1.0 stable spec in March 2026, adding signed agent cards for cryptographic identity verification and support for multi-tenancy.

By the time this AAIF move happened, A2A already had over 150 backing organizations and a working, versioned specification behind it.

This isn't just a whitepaper protocol. A few real examples worth knowing:

• Huawei uses A2A as the protocol between Celia, its OS-level AI assistant, and in-app agents across HarmonyOS. Celia can hand off long running tasks to an app's agent, control app interfaces through an agent, or ask an app agent for contextual recommendations.
• WeChat is among the first major apps connecting with Huawei and other Android device assistants over A2A, letting users start messages, voice calls, and video calls through an AI assistant.
• Google Cloud, Microsoft Azure AI Foundry, and AWS Bedrock AgentCore all support building and hosting A2A agents natively, so agents built on different clouds or frameworks can still talk to each other over the same protocol.
• Google Cloud and PayPal are extending A2A into agentic commerce through something called the Agent Payments Protocol, where shopping and merchant agents communicate over A2A during product discovery, pricing, and order fulfillment.

Here's the part that's genuinely new. A2A already had its own governance setup under the Linux Foundation since mid-2025, so it wasn't homeless before this. What changed is that it now sits directly inside AAIF, alongside three other projects it was previously running in parallel with: MCP, goose, and AGENTS.md, plus a newer addition called agentgateway.

This closes a question people in the space had been asking since AAIF launched back in December 2025. Would A2A eventually fold into AAIF, or stay as a separate, parallel effort indefinitely? Now there's an answer.

With A2A inside the fold, AAIF describes its whole stack in five layers, each handled by one project:

• Instructions and context: AGENTS.md
• Agent runtime: goose
• Agent to tool connectivity: MCP
• Traffic mediation and control: agentgateway
• Agent to agent interoperability: A2A

That's a genuinely useful way to think about the space now, since each layer has one clear owner under one governance model instead of several separate efforts that may or may not stay aligned.

If you're building anything involving multiple AI agents right now, this is worth paying attention to. The practical upshot is that the protocol layer for agent to agent communication is now governed the same way as the rest of the stack it depends on, MCP included, under one neutral roof rather than a patchwork of separate efforts. That reduces the risk of the tools you build on getting pulled in different directions by different vendors down the line.

A2A was already running in production before this move. What changes now is who's steering it, and that it's steered the same way as everything else your agents will likely depend on.