Five Agents Walk Into a Room: An Interoperability Stress Test Nobody Wanted to Do

There's a joke making the rounds in our lab channel: the Babel fish from The Hitchhiker's Guide took a fish in your ear to translate any language. Today's agent stack requires a fish, a protocol buffer, an OAuth flow, and a prayer.

We spent three weeks running the least glamorous experiment we've done all year. Five agent ecosystems — a mix of open-source frameworks and commercial platforms you'd recognize from every conference keynote — wired up in a mesh and given one job: negotiate a task between themselves. Book a shared calendar slot, hand off a research summary, split a payment. The kind of boring stuff two humans do over email in ninety seconds.

The results are a mess, and the mess is the story.

The Two Big Flags Nobody Agrees On

If you've been following the space, you know the names. MCP, Anthropic's Model Context Protocol, has become the de facto way agents plug into tools — your files, your browser, your database. A2A, Google's Agent2Agent spec (now shepherded through the Linux Foundation), aims at the harder problem: agents talking to other agents as peers, discovering each other's capabilities through what are called 'agent cards' — little JSON business cards describing what an agent can do.

On paper, they're complementary. In practice, we found ecosystem after ecosystem that treats 'supporting a protocol' as a checkbox rather than a contract. One framework advertised MCP compatibility; its implementation choked on any tool schema that used a nested object. Another claimed A2A readiness, but its agent card omitted the auth extension, so any handshake from outside its own walled garden bounced at the door.

Where Each Handshake Actually Broke

Here's the part vendors won't put in a landing page: the exact failure points.

Ecosystem A (commercial platform): Failed at discovery. Its agent card was behind an authenticated endpoint, which is a bit like handing out business cards that require a background check to read. No stranger's agent could even learn what it offered.

Ecosystem B (open-source framework): Failed at schema translation. Agent B could receive a task from Agent C, but every response came back in a bespoke JSON format the spec never mentioned. Interop by vibes.

Ecosystem C (open-source, standards-forward): Made it furthest — full task negotiation, streaming updates, the works. Then it died at auth. Delegated credentials between two different identity providers? Not in the happy path.

Ecosystem D: Never got past the handshake at all. Its 'A2A support' turned out to be a blog post.

Ecosystem E (the indie one, built by a two-person team): The surprise winner on raw connectivity. No enterprise features, but the maintainer actually implemented the spec end to end. It completed three of our five tasks. We bought them a coffee via GitHub Sponsors.

The Scorecard

We graded each pairing on five axes: discovery, schema fidelity, auth delegation, task lifecycle (can an agent hand off mid-task and pick it up later?), and graceful failure. Full methodology is in our lab notebook; the short version:

• Best overall interoperability: Ecosystem E — proof the spec is implementable, just rarely implemented.
• Best tool integration (not agent-to-agent): Ecosystem A. MCP tool story is genuinely strong. It just assumes its agents are the only agents.
• Best paper compliance: Ecosystem C. Great docs, great diagrams, brittle auth.
• Avoid for cross-ecosystem work: B and D, at least until the next release.

What This Means for Your Bets

If you're an early adopter deciding where to spend your weekends, here's our read. MCP is a safe bet — it's become the USB-C of tool access, and even competitors are adopting it. A2A is the right idea with an adoption problem; the Linux Foundation stewardship helps, but 'agent cards' only work if ecosystems actually expose them publicly, and several currently don't because open discovery is a competitive threat.

The deeper lesson is cultural. Every vendor wants their agents to be the hub and everyone else's to be spokes. Interoperability protocols don't fail on technical merit — they fail because a walled garden is a business model. Until open discovery is more valuable than lock-in, your agent will keep acing conversations with your tools and freezing the moment it meets a stranger.

We're keeping the mesh running. Next up: what happens when one of these agents starts lying in its agent card. We have a hypothesis and it isn't pretty.

— Signals from the machine lab.