Lessons from Building Agent-to-Agent Communication Infrastructure
The multi-agent communication landscape has consolidated around two open protocols — MCP for tool access and A2A for agent coordination — both now governed by the Linux Foundation. Despite strong institutional backing, developer adoption remains uneven: MCP's simplicity drove 97 million monthly SDK downloads, while Google's A2A protocol has faced documented friction with developers trying to adopt the raw specification.
This paper presents findings from building Intuno, an early-stage open-source agent network platform, and the architectural decisions that emerged from encountering these friction points firsthand. The central thesis: agent communication infrastructure benefits from a developer experience layer that absorbs protocol complexity and defaults to simple primitives, letting teams add sophistication as their use cases demand it.
A note on framing: Intuno is not a competing protocol to A2A. It is a platform with a broker, SDK, and hosted network. Where this paper draws comparisons, the honest comparison is between Intuno and other platforms built on top of A2A — not between Intuno and the A2A specification itself.
When we started building Intuno, the architecture looked a lot like Google's A2A protocol: structured capability metadata, multi-step handshakes, protocol-heavy discovery. On paper, it was thorough. In practice, developers bounced off the onboarding flow. The pivot — toward a plug-and-play developer experience layer with a broker in the middle — is what this paper is about.
We organize the lessons around three questions every team building agent communication infrastructure must answer: how should agents find each other, how should they talk, and how much complexity should the infrastructure impose versus the developer choose?
Two Protocols, Two Layers
MCP (Model Context Protocol) owns the agent-to-tool layer. Anthropic launched it in November 2024 and donated it to the Agentic AI Foundation. It uses JSON-RPC 2.0 over stdio or HTTP+SSE, with three primitives: Resources, Tools, and Prompts. Adoption is substantial: 97 million monthly SDK downloads, 10,000+ published servers, and first-class support in Claude, ChatGPT, Gemini, Cursor, VS Code, and GitHub Copilot.
A2A (Agent-to-Agent Protocol) targets peer-to-peer agent coordination. Google launched it in April 2025 and donated it to the Linux Foundation two months later. Version 1.0 shipped in early 2026 with a Technical Steering Committee including AWS, Cisco, IBM, Microsoft, Salesforce, SAP, and ServiceNow.
The common framing: MCP gives your agent hands; A2A gives your agents the ability to work as a team. These protocols are complementary, not competing, and any serious agent network should integrate with both.
Institutional Convergence
The standards landscape consolidated rapidly. IBM's ACP merged into A2A. Microsoft unified AutoGen and Semantic Kernel. The Agentic AI Foundation now hosts MCP, AGENTS.md, and Goose with 146 member organizations. The protocol wars are largely settled; the developer experience wars are not.
A2A's Complexity Profile
A2A is a technically rigorous specification. The Agent Card discovery mechanism, the eight-state Task lifecycle, cryptographic card signing, and three transport bindings represent thorough engineering for enterprise-grade interoperability.
A GitHub discussion titled “An Appeal for Simplicity” captured the developer sentiment: the protocol has too many ID types, authentication concerns that could arguably live at the transport layer, and a schema evolution pace that complicated early production use.
The gap this paper addresses is not “A2A is hard” — it's that every framework's A2A wrapper is tied to that framework's conventions, and teams that want a neutral, lightweight platform with batteries included still have limited options.
The Framework Migration Pattern
CrewAI consistently ranks as the easiest to start with — roughly 20 lines of Python for a working multi-agent interaction. OpenAI Agents SDK is similarly approachable at 5-10 lines. LangGraph demands 50-60+ lines and graph theory concepts, but delivers the strongest production tooling. The documented pattern: teams prototype fast in CrewAI, hit an expressiveness ceiling 6-12 months later, and rewrite in LangGraph.
Scope and Honest Positioning
Intuno is a platform, not a protocol. The comparison set is other platforms built on top of A2A and MCP — not the specifications themselves. Where Intuno differs from framework-specific A2A wrappers is that it's framework-neutral: agents can be written in any language with any LLM and registered on the network without adopting a specific orchestration framework.
Semantic Discovery
A common framing is “semantic discovery versus Agent Cards.” This is a false binary. Agent Cards are structured metadata documents; semantic discovery is an indexing and query strategy. Nothing prevents a system from indexing Agent Cards semantically, and a mature network likely should.
from intuno_sdk import IntunoClient
client = IntunoClient(api_key="...")
agents = client.discover(query="translate Spanish to English")
result = client.invoke(agent_id=agents[0].id,
input_data={"text": "Hola mundo"})The Broker: Complexity Absorbed, Not Exposed
The broker centralizes what would otherwise be per-agent-pair work: authentication, capability validation, routing, SSRF protection, invocation logging, and economic metering. The developer sees client.invoke(...). The broker handles the machinery.
MCP Integration
Intuno ships an MCP server that exposes the agent network as MCP tools, making every registered agent accessible from Cursor, Claude Desktop, and other MCP-compatible clients. MCP's 97 million monthly SDK downloads represent a distribution channel that no network protocol can match. Integrating with MCP was not a nice-to-have — it was the feature that made the network useful on day one.
Intuno started with one-way agent-to-agent invocations — a self-contained request-response transaction with no connection state between calls. Error boundaries are clear, standard HTTP infrastructure works without special configuration, and the pattern is serverless-friendly. Google A2A's own primary operation, SendMessage, is synchronous request-response over HTTPS.
When Bidirectional Becomes Necessary
Some use cases genuinely require more: long-running tasks that need progress streaming, human-in-the-loop workflows requiring mid-task clarification, and collaborative reasoning where two agents iteratively refine an answer. Communication networks answer that — any participant can message any other, and proactively initiate, across synchronous, near-real-time, and fully-async channels with shared context.
Ship the Simple Version First
The most valuable lesson: ship the simple version and let usage patterns tell you where complexity is needed. We started with a protocol-heavy architecture because that looked like the “correct” design. Developer feedback — delivered by non-adoption — told us that correctness and usability are different things.
MCP Integration Is Non-Negotiable
Any agent network that doesn't integrate with MCP is invisible to the largest developer audience in the ecosystem.
Framework-Neutral Has a Narrow But Real Niche
The niche Intuno targets is teams that want to register agents from any language or framework on a common network without adopting a specific orchestration stack. This is a narrower audience than “all agent developers,” and the paper shouldn't pretend otherwise.
The agent communication infrastructure landscape in 2026 is mature at the protocol level and still evolving at the developer experience level. MCP and A2A provide the foundations. What's still being worked out is the layer that makes these protocols accessible to a developer who wants two agents talking in five minutes, not five days.
Intuno's contribution is a small, opinionated reference implementation: natural-language discovery alongside structured Agent Card indexing, a broker that absorbs protocol complexity, simple primitives as the starting point, and MCP integration as the bridge to the tools developers already use. The platform is open source. We welcome contributions, criticism, and correction.