You have an AI agent. It searches, writes, reasons. You chain a few together with Python glue code, cross your fingers during demos, and call it "multi-agent architecture." It mostly works. Everyone nods.

This is how most production multi-agent systems — setups where several AI programs collaborate on a task — actually operated until last week. Custom integrations, hardcoded schemas, and optimism.

The agents couldn't talk

Your Claude-based orchestrator meets a GPT-based specialist — nothing happens. Your LangChain graph doesn't know what a Vertex AI agent is. Every multi-agent stack was a walled garden with a different fence height. Interoperability has been the missing layer since day one.

Two protocols cracked the problem

In April 2025, Google shipped A2A — Agent-to-Agent protocol, a standardized way for AI agents to discover each other and delegate tasks. Anthropic had already formalized MCP — Model Context Protocol — for tool connections. In June 2025, Google donated A2A to the Linux Foundation. Microsoft adopted A2A for Azure AI Foundry and Copilot Studio in September 2025. Salesforce, SAP, ServiceNow, Box followed — the ecosystem grew to over 150 organizations.

Then March 2026 happened. On March 25, MCP crossed 97 million installs — the fastest adoption curve for any AI infrastructure standard in history. The next day, Sam Altman announced full MCP support across OpenAI's product line. And mid-March, the A2A community shipped v1.0 — the first stable, production-ready release, complete with signed Agent Cards for cryptographic identity verification.

The infrastructure for a cross-vendor agent mesh assembled while the industry argued about benchmark numbers.

How the plumbing works

A2A and MCP solve different problems.

MCP is the horizontal layer: agent-to-tool connections. An agent uses MCP to call databases, APIs, filesystems, browsers — anything that speaks the protocol. Think USB-C for AI tool access. Over 10,000 active MCP servers now run across public and enterprise deployments.

A2A is the vertical layer: agent-to-agent communication. One agent discovers another through an "Agent Card" — a JSON descriptor listing capabilities and authentication requirements. The initiating agent delegates a task. The receiving agent executes, streams back progress, and returns a result in a standardized format.

MCP handles what an agent can reach. A2A handles who an agent can delegate to. Two axes covering the full surface.

Cross-vendor orchestration actually works

As of March 2026, you can build an orchestrator agent that routes tasks to specialists running on completely different infrastructure. A Claude-based planner delegates a coding task to a Copilot-style agent, gets the result back, passes it to a testing agent running on a local model, aggregates everything, and responds to the user.

The glue is the protocol. No custom serialization for each hop. The handoff is standardized. This is the first time "multi-agent" actually means something interoperable — not just within one vendor's ecosystem.

The security model barely exists

Here's what the marketing decks omit.

A2A v1.0 introduced signed Agent Cards — that's progress. But the rest of the trust layer remains improvised. Agent Cards are inconsistent across implementations — what one vendor puts in "capabilities," another puts in "supported_tasks," a third ignores entirely. Error handling varies wildly. Streaming support is spotty outside reference implementations.

When four agents form a delegation chain and one acts on your behalf in a third-party system — who authorized that? A2A v1.0 adds cryptographic identity but no standard capability token system. MCP's 2026 roadmap acknowledges gaps in audit trails, SSO-integrated auth, and gateway behavior. Anyone building production multi-agent pipelines is still improvising the authorization layer. That's not engineering. That's hope.

What this means for you

If you're building anything agent-based, learn A2A and MCP as concepts. Not necessarily implement them from scratch — the raw protocol serves platform builders more than product builders today. But know which vendors support them. The ecosystem is moving toward a model where AI capabilities are network-addressable services, not hardcoded dependencies. Design an agent today that assumes it's the only agent in the room, and you're designing for obsolescence.

The pipes are being laid

The agent ecosystem just got its TCP/IP moment — the foundational networking layer that made the internet possible. The routing protocols are a mess, nobody agrees on security, and better tooling will eat the v1 implementations alive. But the plumbing is real. What gets built on top of it — and who ends up controlling the router — is the question worth watching.