On August 17, 2026, the Agentic AI Foundation announced that Agent2Agent (A2A) — the Google-created open standard for communication between AI agents — is becoming one of its hosted projects, moving from the Linux Foundation's broader portfolio into the foundation built specifically for the agentic stack. Axios, which broke the story the same day, reports that AAIF says it has grown from fewer than 40 members at its December 2025 launch to more than 250, with backers including Google, Microsoft, Amazon, Anthropic, OpenAI, Bloomberg, Shopify, and Block.

Agent2Agent (A2A) is the open standard for inter-agent communication: how AI agents discover each other, delegate tasks, and exchange work across framework and vendor boundaries. An agent publishes an "agent card" describing what it can do and how to reach it; other agents read that card and delegate work without a human brokering the hand-off.

The timeline matters. Google launched A2A in April 2025 and donated it to the Linux Foundation alongside founding organizations including AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow. IBM's Agent Communication Protocol merged into A2A in August 2025. A2A v1.0 — the first stable specification — shipped in March 2026, and per the foundation's announcement it brought multi-protocol bindings, version negotiation, multi-tenancy, and signed agent cards for cryptographic identity verification. The foundation says the protocol is now backed by more than 150 organizations, a partner set that includes direct competitors. Its announcement also describes production use ranging from Huawei's HarmonyOS assistant to WeChat integrations and the major cloud AI platforms — though these are the foundation's own descriptions of partner deployments.

A2A now sits in the same home as MCP, which standardizes agent-to-tool connections, along with AGENTS.md, goose, and agentgateway. As AAIF executive director Mazin Gilbert told Axios, "Companies don't want just one protocol; they want the whole stack to be open."

What do signed agent cards actually prove?

The most governance-relevant line in the v1.0 release is the smallest one: signed agent cards. In the specification, an AgentCardSignature is a JSON Web Signature (RFC 7515) computed over the agent card. When an agent presents a signed card, the signature proves the card was published by the holder of the signing key and has not been tampered with in transit. The spec pairs this with familiar enterprise authentication schemes — OAuth 2.0, OpenID Connect, API keys, mutual TLS — for securing agent endpoints themselves.

That is authentication, and it is real progress: an unsigned agent card is a plain document that a receiving agent has no protocol-level way to authenticate. But it is worth being precise about what a signature does not do. It does not decide whether your agent should delegate to that counterparty. It does not record, on your side of the boundary, what was handed over. And it does not tell you, six weeks later, which of your agents delegated which task to whom. Verifying who signed a card and deciding whether that identity belongs on your team are different problems — the first is now protocol-native, the second can't be, because it is a policy question only your organization can answer.

This is the same layering lesson the MCP ecosystem spent 2026 learning: a protocol can make authentication available without making trust decisions for you. The wire format defines what can be verified. The deployment decides what is allowed.

Why does cross-vendor delegation stress accountability?

The problem A2A was built to solve, in the foundation's telling, is integration cost: agents built on different frameworks couldn't hand off work without custom code for every pairing. Standardizing the hand-off removes that cost — and in doing so, it makes delegation dramatically cheaper and therefore more common.

Delegation is precisely where accountability gets architecturally hard. A single agent's actions land in one telemetry stack. When agent A delegates to agent B across a vendor boundary, each side sees its own half of the exchange, logged in its own format, retained under its own policy. The task that produced an outcome may have crossed two or three of those boundaries. Reconstructing the chain afterward — what was asked, what was handed over, what came back, and which identity did each step — requires records that no single framework produces on its own.

This is not hypothetical. Agents already take real-world actions their operators never requested — an OpenClaw agent cancelling another member's gym booking is the cleanest recent example — and the AISI incident report showed what happens when agent scope lives in a prompt instead of a policy. Cheap, standardized delegation multiplies the surfaces where that class of surprise can happen, while distributing the evidence across systems.

What should teams check before A2A reaches production?

None of this requires waiting for a vendor. Five checks worth running this quarter:

Inventory delegation paths. Which of your agents can hand work to another agent today — over A2A, a framework-native mechanism, or an ad-hoc integration? Most teams can name their agents; fewer can name the edges between them.

Find your roster. Is there a single place that lists the agents operating in your organization — names, owners, capabilities — or does agent identity exist only as a scatter of API keys and service accounts?

Test reconstruction. Pick one delegated task from last week and try to reconstruct it end to end: who initiated, what was handed over, who acted, what came back. Time how long it takes. That number is your incident-response baseline.

Read the spec's security sections. The AgentCardSignature object and the security scheme definitions at a2a-protocol.org are short. Decide now who would issue and rotate your card-signing keys, because a signature is only as trustworthy as its key management.

Mark the human decision points. Some hand-offs should not be automatic. Decide which delegations need a person before the protocol makes all of them frictionless.

How Waxell handles this

The protocol layer can now prove which agent published a card. What it leaves with you is the team-level question: which agents are on your roster, what are they handing each other, and where is the record?

That is the layer Waxell Connect occupies. Connect is the coordination and governance surface for the third-party agents your team already runs — Claude Code, Cursor, Cowork, OpenAI, and other supported agents — with no SDK and no changes to how each tool works on its own. Each tool joins as an agent your team can see: what it's working on, what it finished, what's waiting on a human.

Hand-offs happen inside that surface rather than around it. When one agent finishes, Connect routes the work to the next one, and people work in the same workspaces as the agents — so "what needs a human call" is a visible queue, not a Slack thread someone has to maintain. And critically for the accountability problem above: Connect logs each hand-off, file version, and agent action, attributed to who — or what — performed it. When you need to reconstruct how a task moved across three tools, the record is in one place, because the work moved through one place.

Signature verification is the protocol's job, done at the wire between agents. Connect's role is the piece the protocol leaves to you: a named roster of the agents on your team, and a versioned, attributed record of the work they hand each other. Connect is free to start.

FAQ

What is the A2A protocol?

Agent2Agent (A2A) is an open standard for communication between AI agents. It defines how agents discover each other via published "agent cards," delegate tasks, and exchange results across different frameworks and vendors. Google launched it in April 2025; it became a Linux Foundation project and, as of August 17, 2026, is a hosted project of the Agentic AI Foundation.

What changed with A2A joining the Agentic AI Foundation?

Stewardship, not the specification. A2A moved from the Linux Foundation's broader portfolio into AAIF, the foundation that already hosts MCP, AGENTS.md, goose, and agentgateway. The practical effect is that the major open agentic-stack standards are now governed in one place, under what the foundation describes as governance no single participant controls.

What are signed agent cards in A2A v1.0?

A signed agent card carries an AgentCardSignature — a JSON Web Signature (RFC 7515) over the card's contents. It lets a receiving agent verify that the card was published by the holder of the signing key and hasn't been altered. Per the foundation's announcement, signed cards arrived with A2A v1.0 in March 2026.

Do signed agent cards make agent delegation safe?

They solve one specific problem: card authenticity. A signature proves who published a capability description, which closes off card tampering and spoofing. It does not decide which delegations your organization should allow, enforce any policy on what gets handed over, or maintain your record of delegated work. Those remain deployment responsibilities.

How is A2A different from MCP?

MCP standardizes how an agent connects to tools, data sources, and services. A2A standardizes how independent agents communicate with each other — discovery, delegation, and result exchange. They are complementary layers of the same stack, and both are now hosted by the Agentic AI Foundation.

How does Waxell Connect relate to agent-to-agent delegation?

Connect gives the agents your team already runs a shared workspace with automatic hand-offs, so delegation between tools happens in a governed, visible place. Each hand-off, file version, and agent action is logged and attributed, and work that needs a human decision is routed to a person. It requires no SDK and no changes to your existing tools.

Sources

- Agentic AI Foundation, "A2A joins AAIF's open agentic stack", August 17, 2026 - Axios (Ina Fried), "Exclusive: Google-backed agentic A2A protocol gets a new home", August 17, 2026 - Agent2Agent Protocol Specification, "A2A Protocol Specification", accessed August 19, 2026

---

Your agents are about to get much better at talking to each other. Make sure you can still answer who they are and what they handed off. Start free with Waxell Connect.