Agents Still Can't Talk to Each Other
Five of the top eight repos on GitHub Trending today are agent infrastructure. Meta's Astryx design system (24.6K stars, 2,842/day). Anthropic's skills repo at 193K stars. Addy Osmani's agent-skills at 115K stars. Vercel's Rust-based agent-browser at 49K stars. And the one that tells the real story: Home Assistant MCP — a 7,100-star project that lets Claude, ChatGPT, and other AI assistants configure your thermostat.
📖 Read the full version with charts and embedded sources on AgentConn →
That last repo matters because it proves the Model Context Protocol has escaped the developer-tools ghetto. When your smart home speaks MCP, the protocol war is not theoretical anymore — it is infrastructure.
But here is the uncomfortable truth the trending page cannot show you: none of these agents can talk to each other. Your Anthropic-powered coding agent cannot hand a task to your Google-powered research agent. Your fleet of sub-agents is, as one Microsoft engineer put it at AI Engineer, "really just an unmanaged distributed system." The middleware layer connecting these agents is being reinvented simultaneously across community repos, platform-official projects, and standards bodies — and the convergence pattern reveals something most coverage gets wrong.
This is not a protocol war. It is a protocol stack taking shape.
The Two-Layer Reality
The internet has seven layers. The agent ecosystem, it turns out, needs at least three. And the market has spent the last eighteen months building them out of order.
Layer 1: Agent-to-Tool (MCP). Anthropic's Model Context Protocol, released in November 2024 and donated to the Linux Foundation's Agentic AI Foundation (AAIF) in December 2025, is the closest thing to a solved problem. MCP defines how an agent connects to external tools and data sources — databases, APIs, file systems, smart home devices. Think of it as the USB-C of agent tooling: one plug, any tool.
The adoption numbers tell the story. MCP has crossed 97 million monthly SDK downloads. Over 10,000 public MCP servers are live on GitHub. OpenAI, Google, Microsoft, and AWS have all adopted the protocol. When we wrote in June about whether MCP was just an auth gateway, the answer was already shifting from "auth layer" to "universal service connector." Home Assistant adopting MCP within two months of launch confirmed it.
Anthropic is leaning into the platform play. Boris Cherny announced that Claude now auto-connects to company plugins — the MCP layer becoming invisible infrastructure that "just works."
💡 Key insight: MCP won the tool layer not by being technically superior to alternatives, but by being first, open, and composable. The same strategy that made USB-C win: ship early, give it away, let the ecosystem do the rest.
Layer 2: Agent-to-Agent (A2A). Google's Agent2Agent Protocol tackles the harder problem: how do agents built by different vendors, running on different frameworks, discover each other and collaborate? A2A defines "Agent Cards" (JSON metadata describing what an agent can do), a task lifecycle (submitted, working, input-needed, completed, failed), and streaming updates via Server-Sent Events.
A2A hit v1.0 in March 2026 with multi-tenancy support and both JSON-RPC and gRPC bindings. IBM's competing Agent Communication Protocol (ACP) merged into A2A in August 2025, and the protocol moved under the AAIF alongside MCP in August 2026.
View original post on Google Developers Blog →
The relationship between the two layers is cleaner than the "war" framing suggests. As the Substack newsletter Agents Today put it: "MCP is agent-to-tool (vertical). A2A is agent-to-agent (horizontal)." An A2A agent can internally use MCP servers to do its work — the protocols compose rather than compete.
View original post on Substack →
The GitHub Convergence Signal
The trending page on November 11, 2026 is a snapshot of an ecosystem building both layers simultaneously — but not yet connecting them.
The tool layer is saturating. Anthropic's skills repo (193K stars) and Osmani's agent-skills (115K) are both about packaging capabilities for agents to consume. Home Assistant MCP (7.1K, 640/day) extends the tool layer to physical devices. Vercel's agent-browser (49K) gives agents web interaction through MCP-compatible tooling. These projects all assume MCP as the connector standard.
The agent layer is still fragmented. Meta's Astryx (24.6K, 2,842/day) — a design system for agent-ready interfaces — does not define how the agents behind those interfaces communicate. Meta's own Muse Ember — their smallest agent-optimized model — can "carry workflows across apps, call tools in sequence, run tests and make targeted code fixes," but the cross-vendor handoff is still absent. None of the trending repos implement A2A. The inter-agent plumbing remains bespoke.
This gap is why five of the eight trending repos can be agent infrastructure without any of them solving the actual interoperability problem. They are building increasingly sophisticated individual agents that still cannot coordinate across vendor boundaries.
What the Community Is Saying
The AI Engineer conference uploads from the same week converge on one uncomfortable realization. Vorflux's talk argues that once every engineer runs agent fleets, "merge is the bottleneck" — the constraint moves from writing code to integrating the outputs of multiple autonomous agents. Microsoft's presentation frames sub-agents as a distributed system problem, with all the failure modes that implies: partial failures, inconsistent state, no guaranteed message delivery.
The practitioner frustration is consistent: agents work fine in isolation, but the moment you need Agent A (built on Claude) to delegate to Agent B (built on Gemini), you are writing custom integration code that A2A was designed to eliminate.
Standard Agents' breakdown makes the sharpest case: the current state is analogous to pre-HTTP networking, where every vendor had a proprietary protocol and cross-vendor communication required gateway translation. A2A is the HTTP proposal. MCP is the filesystem mount. Together, they could form the interoperability stack — if adoption follows governance.
The early "protocol war" framing from outlets like Koyeb positioned A2A and MCP as competitors. That framing is already outdated: ACP merged into A2A in August 2025, and both MCP and A2A share governance under AAIF. The real picture is a two-layer stack, not a two-party fight.
The HN discussion around the MCP July 2026 release captures the practitioner mood: commenters debated whether MCP's bespoke protocol was a mistake, and whether A2A adoption would follow the same slow ramp. The thread reflects a community that wants interoperability but is skeptical of any single standard body delivering it fast enough.
View discussion on Hacker News →
View original article on Koyeb →
The Governance Bet: AAIF
The most underreported development in agent interoperability is organizational, not technical.
The Agentic AI Foundation — launched by the Linux Foundation in December 2025 with Anthropic, Block, and OpenAI as co-founders — now hosts both MCP and A2A under a single governance structure. Google formally transferred A2A in August 2026. The foundation has grown to 270+ member organizations including AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow.
View original article on Axios →
💡 Why this matters: For the first time, the two dominant agent protocols — tool-layer and agent-layer — share a standards body. Joint interoperability specifications are expected in Q3 2026. This is the HTTP + TCP/IP moment: separate protocols, unified governance.
This is how protocol wars actually end. Not with one standard killing the other, but with layered composition under neutral governance. USB did not replace Ethernet. TCP did not replace HTTP. The OSI model works because each layer does one job. The agent stack is converging on the same architecture: MCP handles what your agent can reach, A2A handles who your agent can talk to.
Meanwhile, the model layer keeps accelerating. Anthropic's Fable 5.2 just took the top spot on the Artificial Analysis Intelligence Index — but a faster model does not fix a fragmented protocol stack. The interoperability bottleneck is orthogonal to model capability.
Cisco's Layer 9 Bet: The Semantic Gap
But two layers may not be enough.
Cisco's Outshift division is pushing a concept they call the "Internet of Cognition" — a semantic protocol layer that sits above both MCP and A2A. Their argument: current protocols handle the syntax of agent communication (message format, transport, discovery) but not the semantics (meaning, intent, capability alignment).
Cisco's AGNTCY project, donated to the Linux Foundation in July 2025 with Dell, Google Cloud, Oracle, and Red Hat as co-founders, proposes a semantic layer containing an I/O Mapper Agent and a Semantic Router Agent. The SLIM messaging substrate is designed to carry A2A, MCP, or ACP traffic while adding semantic understanding of what agents actually mean when they communicate.
⚠️ Contrarian take: Cisco's Layer 9 vision is intellectually honest — syntactic protocols genuinely do not solve semantic alignment between independently built agents. But "ontology alignment" is where AI interoperability proposals go to die. This is the same problem that killed the Semantic Web in the 2000s. The practical bet is that LLMs themselves handle the semantic translation layer (they are already good at it), making a formal semantic protocol unnecessary. Cisco may be solving a problem that foundation models are about to dissolve.
Roy Chua of AvidThink captures the skeptic position: genuinely aligned semantic understanding between agents "will require hard work in representation learning and ontology alignment." That is true — but also describes a decade-long research program, not shipping infrastructure.
The Protocol Stack as of November 2026
| Layer | Protocol | Owner | Status | What It Does |
|---|---|---|---|---|
| Semantic (Layer 9) | AGNTCY / SLIM | Cisco + LF | Experimental | Intent alignment, semantic routing |
| Agent-to-Agent | A2A v1.0 | Google → AAIF | Production | Agent discovery, delegation, task lifecycle |
| Agent-to-Tool | MCP v1.0 | Anthropic → AAIF | De facto standard | Tool/data/service connectivity |
Each layer addresses a different problem. MCP answers "what can my agent reach?" A2A answers "who can my agent delegate to?" AGNTCY/SLIM asks "do the agents actually understand each other?" — a question the market has not proven needs a protocol-level answer yet.
What This Means for Builders
If you are building agent systems today, here is the practical playbook:
1. Use MCP for tool integration — this is settled. With 97M+ monthly downloads, 10K+ public servers, and adoption by every major cloud provider, MCP is the TCP/IP of agent tooling. Do not build custom tool connectors. Do not roll your own integration protocol. Use MCP or wrap your existing APIs with MCP servers. The Home Assistant adoption proves the standard works beyond developer tools.
2. Adopt A2A for cross-vendor agent delegation — if you need it. Most teams do not need cross-vendor agent communication yet. If all your agents run on the same framework and model provider, A2A is overhead you do not need. But if you are building multi-vendor agent systems — say, a Claude agent delegating to a Gemini specialist — A2A's Agent Cards and task lifecycle are the cleanest abstraction available. The v1.0 spec with gRPC and JSON-RPC bindings is production-ready.
3. Do not build custom agent-to-agent plumbing. This is the key tactical takeaway. Every week of custom inter-agent protocol work is a depreciating asset. The AAIF governance merge means A2A and MCP are converging toward a joint interoperability spec. Whatever you build from scratch will need to be migrated. Build on the emerging standard or build an abstraction layer that can swap implementations.
4. Ignore the semantic layer for now. Cisco's AGNTCY/SLIM is intellectually interesting but years from production. If you need semantic alignment between agents today, use the LLM itself as the translation layer — have the receiving agent interpret the sending agent's output through its own context window. This is "good enough" for current production systems and costs less than implementing a formal semantic protocol.
5. Watch the AAIF joint spec. The joint interoperability specification between MCP and A2A teams will be the next inflection point. It will likely define how an A2A agent card can advertise its MCP tool capabilities and how A2A task results can flow through MCP channels. Prototype on today's separate specs, but architect with composition in mind.
💡 The bottom line: The agent interoperability stack is not a war — it is a layer cake. MCP (tools) + A2A (agents) + semantic (TBD) mirrors the network stack that runs the internet. Build on the layers that are stable, prototype on the layers that are forming, and do not invent your own where a standard exists.
Related Reading
- Skills vs MCP: Is MCP Just an Auth Gateway? — the token-cost case for when to use each
- Your SaaS Now Has a Second Customer: The AI Agent — how WebMCP extends the agent-to-tool layer to the browser
- The Orchestration Frontier: Multi-Agent Coordination — the coordination layer between individual agents and cross-vendor interop
- Fleet Orchestration and Background Agents — managing your own agent swarm vs. talking to someone else's
Originally published at AgentConn
Top comments (0)