A2A

Why Advertising Agents Need a Shared Way to Talk

MCP solves how an agent uses a tool. It does not solve a different, equally basic problem: how two independent agents — built by different companies, running on different platforms, with no shared codebase — find each other and communicate at all.

That problem sounds simple until you consider the constraint most agent-to-agent interactions actually operate under: neither side wants to expose its internal reasoning, proprietary logic, or private state to the other. A buyer agent and a seller agent need to negotiate. Neither one wants to hand the other its source code to do it.

A2A, the Agent-to-Agent protocol, standardizes that interaction — discovery, messaging, task coordination — while keeping each agent's internals opaque to the other.

What A2A Standardizes

A2A defines how one agent announces what it can do, how another agent finds that announcement, and how the two exchange structured messages to accomplish a task together. An agent hosts a standardized manifest — an Agent Card — declaring its identity, its capabilities, and how to reach it. Any other agent that speaks A2A can read that manifest and know exactly what it's dealing with, without either party needing custom integration work.

Communication happens through a defined task lifecycle: a request is submitted, worked on, and either completed or flagged for clarification, with support for long-running or asynchronous exchanges rather than assuming every interaction resolves instantly.

How A2A Relates to MCP and AdCP

MCP and A2A solve adjacent but distinct problems. MCP standardizes the interface between a single agent and the tools it uses — what tools can I call, how do I call them. A2A standardizes the interface between two separate agents — who can help me accomplish this task, and how do we coordinate.

AdCP builds directly on both. It applies A2A's discovery and messaging patterns specifically to the advertising domain — buyer agents and seller agents finding each other, negotiating, executing — while relying on MCP to give those agents standard access to the tools they need along the way. A2A is the general communication layer; AdCP is what that layer looks like applied to a media transaction specifically.

Where Opacity Fits

A2A's design assumes agents will not, and should not, reveal their internal workings to each other. A seller agent doesn't need to know how a buyer agent's model was trained, what its internal decision logic looks like, or what proprietary data informs its strategy. It needs to know what the buyer agent is asking for, and be able to trust the interaction enough to respond.

This opacity is a feature, not a limitation. It allows genuinely independent systems — built with no coordination between the teams that made them — to work together anyway, because the protocol only requires agreement on the interface, not on the implementation behind it.

What A2A Does Not Do

A2A does not define advertising-specific behavior — no auction logic, no supply descriptors, no campaign lifecycle. It is domain-agnostic by design; those specifics are AdCP's job. It also does not verify agent identity in the way AAMP's registry does — A2A standardizes how two agents talk, not whether either one should be trusted before the conversation starts.

Why This Matters

The value of any agent is limited by how many other agents it can actually work with. A brilliant buyer agent that can only talk to seller agents built by the same company isn't a buyer agent operating in a market — it's a closed loop. A2A is what turns isolated capability into something that can actually participate in an open ecosystem, by giving every agent, regardless of who built it, a shared way to say: here's who I am, here's what I can do, here's how to reach me.