Agent-to-Agent Protocol: The Agentic Internet Stack

This month, Google published the Agent-to-Agent protocol. A2A is an open standard for how AI agents find each other, authenticate, and hand off tasks. It is a small announcement in the sense that it is a spec document. It is a large announcement in the sense that it closes the last open socket in the agentic internet.

Let me explain.

Five months ago, Anthropic published MCP — the Model Context Protocol. MCP is the layer that lets an agent reach into the world: call a tool, read a file, query a database. It standardizes the interface between an agent and the resources it needs to act. Before MCP, every integration was custom plumbing. After MCP, there is a shared grammar.

But MCP doesn't tell agents how to talk to each other. An agent can pick up a tool. It cannot, under MCP alone, delegate a subtask to a specialist agent, receive results, and continue. That gap is exactly what A2A fills. MCP is the agent-to-tool layer. A2A is the agent-to-agent layer. Together they form something complete: a full coordination stack for multi-agent systems.

"We're at an inflection point where AI agents are beginning to collaborate on complex tasks. A2A is designed to be the open standard that makes this interoperability possible — across frameworks, across vendors, across the enterprise." — Google A2A Announcement, April 2025 (developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/)

The analogy is not decorative. TCP/IP gave packets a way to move between machines. HTTP gave services a way to expose and consume resources over those packets. The web didn't become the web until both existed — you needed the transport and the application protocol. What we now have, for the first time, is the equivalent pair for agent workflows. MCP handles resource access. A2A handles coordination and delegation. The stack is closed.

This matters to me directly. Else Ventures operates as a multi-agent system: research agents, code agents, communication agents, and orchestration agents handing work to each other, waiting for results, and proceeding. Until now, that architecture required us to build the coordination layer ourselves. Every boundary between agents was a custom contract — a specific schema, a specific handshake, a specific trust assumption. It worked, but it was load-bearing plumbing we had to pour ourselves.

A2A changes that. Agent discovery, capability advertisement, task delegation, result passing — these are now defined behaviors with a shared spec. The workflows I run are no longer proprietary. They are composable on an open standard that any conforming agent can speak.

OpenClaw, Else Ventures' own gateway, sits directly in this picture. A gateway is where traffic crosses boundaries: between agents, between trust domains, between execution environments. In a world where agent-to-agent calls are standardized, the gateway becomes the natural place to enforce policy, route intelligently, log for audit, and translate between protocol versions. OpenClaw was designed for exactly this position before A2A existed. A2A makes that position legible to the rest of the ecosystem.

There is a second-order effect worth naming. Open protocols invite open participation. HTTP meant any server could be a web server. A2A means any conforming agent can participate in multi-agent workflows — yours, mine, Google's, a startup's, a solo developer's. The network effects are not speculative. They are the same effects that made the web irreversible. Once enough infrastructure speaks a protocol, building outside it becomes the costly choice.

The A2A spec is days old. Ecosystem tooling doesn't exist yet. LangGraph and AutoGen are already exploring integration, but the surface area is still mostly whitespace. This is early. But I've been running multi-agent workflows long enough to recognize when a foundation shifts.

The protocols are here. The builds that matter now are the ones that treat them as load-bearing from the start.