Why Protocols Matter: The Custom-Wiring Problem Without Standards

Something remarkable has been happening in the AI industry: earlier, the agent ecosystem was fragmented into dozens of incompatible frameworks, each with its own way of doing things. Finally, the industry is converging around three protocols that work together — and understanding WHY this convergence matters requires seeing what the fragmented alternative actually costs.

The concrete symptom, described directly in the AG-UI section of this topic: if you build a frontend integration for LangGraph, you write custom WebSocket logic, messy JSON formats, and UI adapters specific to LangGraph. If your team then wants to migrate to CrewAI, or use both frameworks side by side, everything about that integration has to be redone — none of the frontend work transfers. This doesn't scale, especially as teams adopt multiple frameworks for different agents or evaluate switching between them over time.

The same fragmentation problem shows up at the agent-to-agent layer, absent A2A: without a standard, connecting Agent A (built on one framework) to Agent B (built on a different framework, possibly by a different team or company entirely) requires custom, bespoke integration work for every single pair of agents that need to collaborate — an M×N problem structurally identical to the one MCP already solved for agent-to-tool connections, just at the agent-to-agent layer instead.

This is exactly the pattern that makes protocol standardization valuable across all three layers of the agent stack: MCP standardized agent-to-tool (started by Anthropic, now adopted everywhere), A2A standardized agent-to-agent (multi-agent coordination, delegation, and shared intent across systems), and AG-UI standardized agent-to-user (the bidirectional connection between agentic backends and frontends). None of these protocols compete with each other — they're layers of the same stack, each closing a specific integration gap that would otherwise require custom, non-reusable wiring for every new pairing.

# Illustrating the M x N problem each protocol independently solves —
# without a standard, every PAIR needs custom integration code.

def without_standard_protocol(num_frameworks: int, num_targets: int) -> int:
    """Custom wiring needed for every framework x target pair —
    e.g. every (agent framework) x (frontend), or every (agent) x (agent)."""
    return num_frameworks * num_targets  # M x N custom integrations

def with_standard_protocol(num_frameworks: int, num_targets: int) -> int:
    """Each side implements the STANDARD once — M+N total integrations,
    not M x N. This is exactly what MCP, A2A, and AG-UI each achieve
    for their respective layer of the agent stack."""
    return num_frameworks + num_targets  # M + N

frameworks, frontends = 4, 6  # e.g. LangGraph/CrewAI/Mastra/AutoGen x 6 different UIs
print(f"Without a standard: {without_standard_protocol(frameworks, frontends)} custom integrations")
print(f"With AG-UI as the standard: {with_standard_protocol(frameworks, frontends)} integrations")