A2A protocol: the wire format for multi-agent enterprises

Multi-agent has been the most-discussed and least-deployed pattern in enterprise AI for the better part of two years. The reason isn't ambition — every architect I talk to has a multi-agent diagram somewhere, usually on a whiteboard with three different inks. The reason is interoperability. Without a shared wire format, two agents talking to each other is just two pieces of bespoke code talking to each other, and the integration surface multiplies every time you add an agent. The math gets painful fast: five agents means twenty potential integration pairs, and any one of them can be the bottleneck.

The boring, important answer

The open A2A (agent-to-agent) protocol that watsonx Orchestrate now supports is the boring, important answer. It standardizes how agents discover each other's capabilities, exchange messages, and pass context — across frameworks, across vendors, across organizational boundaries — using a wire format that doesn't change every time a new framework releases a new version. Boring because it's not a model breakthrough or a flashy demo; important because it's the piece that lets multi-agent architectures stop being one-off integrations and start being something an enterprise architecture team can actually plan for, pattern-match against, and govern centrally.

From custom integration to routing decision

Think about what this changes for an enterprise IT shop. Today, when finance wants their agent to ask procurement's agent about vendor status, you scope and build a custom integration — typically a multi-week project with a custom payload schema, retry semantics, and a separate observability story. With A2A, both agents already speak the protocol; the integration becomes a routing decision in the Control Plane. The marginal cost of adding a new agent-to-agent interaction drops from "a project" to "a config change," which is the order-of-magnitude shift that makes multi-agent feasible at scale.

The cost of building A2A-first today is small. The cost of retrofitting later is what actually kills the program.

There are caveats worth being honest about. A2A is still maturing — protocol versioning, security profiles (especially around delegated identity), and discovery semantics will tighten over the next year, and the early adopters will eat some breakage along the way. And the protocol doesn't solve the harder problem of inter-agent contracts: what one agent promises and what another agent expects when the answer is ambiguous or partially formed. That layer is application-level and still belongs to the people building the agents — A2A gives them the language, not the conversation.

Design A2A-first, starting today

But the direction is right. If you're scoping multi-agent work in 2026, design every new agent A2A-capable from the start — even when the first version only talks to one other agent and even when the second agent doesn't exist yet on the roadmap. That single discipline will compound: it makes the agent reusable across workflows you haven't planned yet, it makes the integration surface predictable for the security team, and it keeps you out of the bespoke-integration trap that's stalled half the multi-agent ambitions I've seen on customer whiteboards over the last 18 months. The cost of building A2A-first today is small — measured in extra interface design and a few hours of protocol reading. The cost of retrofitting later is what actually kills the program.