AI-Designers
Why AI agents need a shared language
One agent checks invoices, a second schedules deliveries, a third answers customer questions. Each runs on a different vendor’s platform, and each is good at its own job. The moment you want them to work together, the tinkering starts: custom interfaces, proprietary data formats, integrations that break with every update. Anyone who couples several AI systems today spends more time on duct tape than on the automation itself.
This is exactly what the Agent2Agent protocol, or A2A for short, sets out to fix. It defines how independent agents find each other, prove who they are, and hand off tasks — regardless of who built them or where they run. Google introduced A2A in April 2025 and handed the standard to the Linux Foundation a few weeks later, in June 2025. Version 1.0 arrived in March 2026. So this is no longer a lab experiment.
A2A and MCP: two protocols, two jobs
Plenty of people confuse A2A with the Model Context Protocol, which we covered in an earlier post. The two don’t compete, though. They complement each other. MCP connects a single agent to tools and data sources — a database, a file system, an internal API. It governs what an agent works with.
A2A governs something else: collaboration between agents. The invoice agent doesn’t talk to the database; it talks to the delivery-scheduling agent. And it doesn’t need to know how the other one works internally, which model sits behind it, or what language it was written in. It states a task, the other returns a result. Here’s an easy way to remember it: MCP looks inward, to the tools. A2A looks outward, to other agents.
Agent Cards: the digital ID
Before one agent can hire another, it first has to know what that other agent can actually do. A2A handles this with so-called Agent Cards. Such a card is a machine-readable description: what capabilities does the agent offer, how do you reach it, what authentication does it expect? An agent reads another’s card and immediately knows whether, and how, a collaboration makes sense.
One detail matters a great deal for enterprise use: Agent Cards are cryptographically signed. The receiving agent verifies the caller’s identity before it delegates any sensitive operation. That sounds technical, but the reason is very practical. When an agent triggers payments or shares customer data on your company’s behalf, you can’t rely on a handshake and good faith. The signature makes it traceable who is talking to whom.

How a task actually flows through
The flow follows a fixed pattern. First, an agent — call it the coordinator — discovers a suitable specialist agent through its Agent Card. Then the two agree on a task: the coordinator describes what it needs, the specialist confirms it can take it on. After that, the specialist does the work and returns a result.
Because tasks between agents can take seconds or hours, A2A builds in long-running processes from the start. An agent can report progress along the way instead of leaving the coordinator to wait blind. If a sub-step fails, that information lands in a defined place — not in a log nobody reads. For processes like a multi-stage order flow or a claims review, this progress channel matters more than it looks at first glance.
Who stands behind the standard
A protocol is only worth as much as the number of people who actually use it. On that front, A2A is unusually well positioned. On its one-year anniversary in April 2026, the Linux Foundation reported more than 150 supporting organizations. Among them are names that rarely sit at the same table: AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow.
The fact that the standard sits with a neutral foundation rather than a single corporation is no side note for businesses. You don’t tie yourself to one vendor’s roadmap. When SAP and Salesforce speak the same protocol, their agents can work together without you having to build and maintain an expensive custom integration. That vendor independence is the real win.

Where A2A pays off in the enterprise
The most obvious case is cross-department automation. A sales agent captures a request, passes it to a logistics agent, which in turn brings in an accounting agent. Each department keeps its own system, its own model, its own rules. They’re connected through A2A, not through a monolith project that forces everyone onto the same tool.
It gets interesting across company boundaries too. A supplier’s agent could reconcile availability with an agent in your purchasing department — machine to machine, verifiable, without a portal login and manual retyping. For regulated industries, the signed identity is the linchpin here: you know whose agent you’re talking to, and you can prove it.
What to weigh before you start
So much for the good news. Now the sober side. A2A solves communication between agents, not their quality. A poorly built agent stays poor, even when it’s cleanly wired up over a protocol. Check first that your individual agents work reliably before you network them.
Second, networking creates a new attack surface. An agent that delegates tasks to others needs clear limits: who may it hire, what data may it pass on, where does its authority end? The cryptographic signature helps with identity, but it doesn’t replace well-thought-out access control. And third, start small. Two agents, one clearly scoped process, a measurable result — that’s a better beginning than a web of ten agents nobody can oversee anymore.
Thinking about how to connect agents from different systems in a way that’s useful and secure — on-premise and under your control? We help you with that, from architecture to operation. Talk to us at ai-designers.eu.
Images: AI-Designed
Deutsch

