A2A 1.0 Joins Agentic AI Foundation: The Internet of Agents

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

On August 17–18, 2026, Google transferred the Agent2Agent (A2A) protocol to the Agentic AI Foundation (AAIF) under the Linux Foundation — the neutral home that already hosts MCP, OpenAI's AGENTS.md, Block's goose, and agentgateway. The donation marks the moment the agent ecosystem finally got a governance structure that no single model vendor controls. A2A's v1.0 specification was frozen on March 12, 2026, adding signed agent cards, multitenancy, version negotiation, and multi-protocol bindings, and more than 150 partner organizations are already building on the protocol.

The conceptual split is now crisp and worth internalizing: MCP is agent-to-tool, A2A is agent-to-agent. MCP lets an agent call a tool or a system; A2A lets one agent hand a task, a context, and a result to another agent across organizational boundaries. AGENTS.md sits at a third layer — the instructions that tell an agent how to behave inside your repository. Put together, these three standards form the full agent interoperability stack, and for the first time they live under one roof. This article breaks down what A2A 1.0 actually froze, how discovery works via /.well-known/agent-card.json, and why neutral governance matters more than the protocol details themselves. Start with the MCP directory for the tool layer; this is the agent layer.

What the Agentic AI Foundation actually owns

The AAIF, under the Linux Foundation, is becoming the neutral chassis for the agent protocol stack. The projects it hosts and their roles:

The significance of a single foundation is not bureaucratic — it is forkability and trust. An enterprise in Bengaluru or Bengaluru-to-global can now adopt A2A without worrying that a model vendor will yank the spec, change licensing, or reprioritize it. That is the difference between an industry standard and a vendor feature. The latest AI news hub has tracked the protocol wars; this is what the settlement looks like.

What A2A 1.0 froze on March 12, 2026

The v1.0 freeze locked four capabilities that matter for real deployments:

1. Signed agent cards. An agent's discovery card is now digitally signed, so a consumer can verify that payments-agent.example.com is genuinely who it claims to be before delegating a task.
2. Multitenancy. A single agent can serve multiple tenants (customers, teams, orgs) with isolated state, scoped credentials, and per-tenant quotas — critical for SaaS agents.
3. Version negotiation. Client and server negotiate the A2A version they both speak, so old agents and new agents can interoperate during rolling upgrades.
4. Multi-protocol bindings. A2A messages can ride over multiple transports (JSON-RPC over HTTP, plus streaming and event channels), so it is not hostage to one transport vendor.

For teams running agent fleets, multitenancy and signed cards are the two that change the security posture immediately. An unsigned, single-tenant agent is now the legacy shape.

Discovery: /.well-known/agent-card.json

The key mechanism is boring and brilliant: discovery via well-known URL, the same pattern as /.well-known/security.txt or /.well-known/openid-configuration. An agent publishes a card at the well-known path /.well-known/agent-card.json on its host, and any other agent can fetch and validate it.

{
  "protocol": "a2a",
  "version": "1.0",
  "name": "Invoice Reconciliation Agent",
  "description": "Matches invoices to payments and flags exceptions.",
  "skills": ["invoice-matching", "exception-flagging", "reporting"],
  "capabilities": {
    "streaming": true,
    "push_notifications": true,
    "state_management": true
  },
  "security": {
    "card_signature": "https://host.example/.well-known/card.sig",
    "auth_schemes": ["oauth2", "mtls"]
  },
  "vendor": "saaasnext.example.com",
  "contact": "security@example.com"
}

Discovery in Python is a two-line fetch plus a signature check:

import json, urllib.request

with urllib.request.urlopen("https://payments.example.com/.well-known/agent-card.json") as r:
    card = json.load(r)

assert card["protocol"] == "a2a" and card["version"] == "1.0"
# production: verify card["security"]["card_signature"] against the vendor's key
print(f"Agent '{card['name']}' offers: {', '.join(card['skills'])}")

This is the pattern that makes the Internet of Agents actually work: no central registry, no directory you must be listed in, just standard URLs and signed metadata. Your agent can discover a partner's agent the same way a browser discovers a website.

MCP vs A2A vs AGENTS.md: who does what

MCP answers "how do I let an agent use the things I own?" A2A answers "how do I let an agent delegate to the things other people own?" AGENTS.md answers "how do I make sure agents follow my repo's rules?" They compose: an agent discovers another agent over A2A, that agent then calls tools over MCP, and both behave per each repo's AGENTS.md.

Protocol governance: the table that matters

That last row is the real competitor. Google, OpenAI, and Anthropic could all have kept their protocols proprietary and fought for ecosystem lock-in. Moving them into the Linux Foundation is an admission that agents will only become infrastructure if they interoperate, and interoperability requires neutral governance. The 150+ partner organizations — spanning cloud providers, security vendors, and enterprise platform teams — are the credibility signal: this is not a press release, it is a coalition.

Building agents that interoperate

For teams implementing this today, the practical order of operations is:

1. Expose an MCP server for everything your agent does with your systems (database, CI, CRM).
2. Publish an A2A agent card at /.well-known/agent-card.json for everything your agent can delegate or accept from other agents.
3. Ship an AGENTS.md in every repo your agents touch, and point your agent at it before any edit.
4. Sign your card. Multitenancy and signed cards are the two v1.0 features that raise the security floor; skip them and you are advertising an agent that anyone can impersonate.
5. Negotiate versions defensively. Always fall back to the highest mutually supported A2A version; assume the peer is older than you.

The workflows in the Daily AI World library already assume this stack: MCP for tools, AGENTS.md for repo rules, and A2A for cross-agent delegation.

The Internet of Agents is a governance story

The A2A transfer to the Agentic AI Foundation is not a technical event; it is an institutional event. It says the agent economy will not be owned by any single model lab, that agents will discover each other the way browsers discover websites, and that the Linux Foundation — which already governs Kubernetes, GraphQL, and OpenTelemetry — will host the connective tissue of the agent era. If you build multi-agent systems, the stakes are simple: the protocol layer is now neutral, and your integration strategy should be built on it, not around it.