Agent Landscape #6: Coordination & Protocols — Agents Talking to Everything

The Problem

You built an agent that works. Now you need it to:

• Use a database tool that someone else built → but your framework's tool format is incompatible with theirs

• Hand off to a specialist agent for a sub-task → but it runs in a different framework (LangGraph vs. CrewAI)

• Show progress to the user while working → but there's no standard event format for "tool started / tool finished / here's intermediate output"

• Run on AWS today, GCP tomorrow → but your agent is deeply coupled to Bedrock APIs

These are all coordination failures. Before 2024, every team invented their own:

• Custom tool schemas (n different JSON formats for the same concept)

• Custom agent-to-agent protocols (or just shared databases)

• Custom streaming formats (SSE, WebSocket, polling)

The result: agents that only talk to tools built in the same framework, can't delegate to agents from other teams, and are locked to one cloud.

In 2025-2026, three protocols emerged to fix this. Plus platform SDKs and tool ecosystems that fill the gaps.

Research & Industry Context

Key Papers & Concepts

AutoGen (Wu et al., 2023, Microsoft) — formalized the multi-agent conversation pattern. Showed that specialized agents collaborating via message passing outperform monolithic agents. Key design: each agent is an actor with a mailbox, processing messages sequentially — the modern incarnation of concurrent agent communication.

CAMEL (Li et al., 2023) — communicative agents via role-playing. Demonstrated that structured agent-to-agent dialogue protocols with inception prompting enable collaborative task completion without human intervention.

MCP Paper (Anthropic, 2024) — formalized the tool integration problem. Key insight: tool providers and AI applications should have a standard interface (like USB) rather than N×M custom integrations. Inspired by LSP (Language Server Protocol).

A2A Spec (Google → Linux Foundation, 2025) — agent-to-agent communication standard. Agent Cards for capability discovery, Task lifecycle management, streaming updates. Google donated governance to Linux Foundation for vendor neutrality.

AG-UI (CopilotKit, 2025) — event-based protocol completing the trifecta: MCP = agent↔tools, A2A = agent↔agent, AG-UI = agent↔user. Adopted by Google, AWS, Microsoft, LangChain simultaneously — rare cross-vendor consensus.

How Industry Solves This

Anthropic: MCP inventor and primary driver. Claude Code, Claude Desktop use MCP natively. First-party MCP servers for filesystem, git, databases. The 87k-star community servers repo shows adoption velocity.

Google: Created A2A, donated to Linux Foundation. ADK natively supports both MCP (tools) and A2A (agent delegation). Agent Cards for discovery.

Microsoft: Adopted AG-UI, supports MCP in Semantic Kernel. Building toward "agent mesh" across Azure services (Copilot Studio → custom agents → Azure AI Foundry).

OpenAI: Agents SDK with handoff pattern (simpler than A2A). MCP support added to ChatGPT and Codex. Not an A2A contributor — betting on their own platform instead of protocol-level interop.

Stripe/Shopify/Robinhood: Building agent-facing APIs directly. Stripe's Agent Toolkit, Shopify storefronts for AI shopping agents. These are the early "agent-native" API rewrites that MCP eventually standardizes.

Common pattern: Companies adopt MCP first (it's immediately useful — tools work), then A2A (when they need multi-agent delegation across services), then AG-UI (when they build user-facing agent products).

The Protocol Stack

MCP (Model Context Protocol — Anthropic) — 8k spec / 87k servers

What it is: Standard interface for agents to discover and use tools. Think USB-C for AI tools.

Why it matters:

• Hundreds of MCP servers already exist (filesystem, databases, APIs, cloud services)

• Any agent that speaks MCP gets instant access to the full ecosystem

• Anthropic-backed with growing adoption (Cursor, Claude Code, Zed)

Limitations:

• No global registry (tool discovery is local)

• No standard auth between client and server

• Transport layer still evolving (stdio vs. HTTP/SSE)

A2A (Agent-to-Agent — Google/Linux Foundation) — 24k stars

What it is: Protocol for agent-to-agent communication. Agents discover each other via Agent Cards, exchange Tasks, stream updates.

(See protocol stack diagram above)

Why it matters:

• Agents from different frameworks can collaborate

• Agent Cards enable capability-based discovery

• Standard task lifecycle (submitted → working → complete/failed)

• Linux Foundation governance (vendor-neutral)

AG-UI (Agent-User Interface Protocol) — 14k stars

What it is: Event-based protocol for agent-to-UI communication. Created by CopilotKit, adopted by Google, AWS, Microsoft, LangChain.

(See protocol stack diagram above)

Why it matters:

• The missing third piece: MCP = tools, A2A = agents, AG-UI = users

• Enables generative UI — agents producing interactive interfaces, not just text

• Adopted by all major vendors

The Three-Layer Summary

Adopt all three. They're complementary, not competing.

Platform SDKs: What You Gain vs. Lose

Cloudflare Agents — 5k stars

Stateful agents as Durable Objects on the edge. Each agent has SQLite, WebSocket persistence, scheduling.

Best for: Lightweight always-on agents (chatbots, monitors, schedulers).

AWS Strands — 6k stars

Open-source Python SDK for Bedrock + Lambda + DynamoDB agents.

Best for: AWS-native teams who want lightweight agent SDK.

Microsoft Semantic Kernel — 28k stars

Enterprise agent SDK for .NET, Python, and Java. Plugin system, planner, memory connectors.

Best for: Enterprise teams in the Microsoft ecosystem who need multi-language support and Azure-native integration.

Vercel AI SDK — 25k stars

TypeScript SDK for AI-powered UIs. Streaming, tool calling, multi-step in React/Next.js.

Best for: Frontend AI features. Not for backend infrastructure agents.

Tool Ecosystems: How Agents Touch the Real World

A massive category — 350k+ combined stars — giving agents real-world capabilities.

Why these matter: "85% of the web is beyond APIs." Until every service has an agent-native API, browser automation and web extraction are table stakes.

Observability: Debugging Agent Behavior

Agent traces aren't HTTP request logs. Different shape, different debugging.

The pattern: Agent debugging requires session-level traces (not request-level), cost attribution across multi-step chains, and quality evaluation that handles non-determinism.

Recommendation: Langfuse for open-source self-hosted, LangSmith if you're already in the LangChain ecosystem, Arize Phoenix if you want OpenTelemetry-native.

Multi-Agent Coordination Patterns

Beyond protocols, there are patterns for how agents actually work together:

Handoff (OpenAI): Agent A recognizes it's wrong agent → transfers to Agent B with full context.

Topic Bus (AutoGen): Agents publish/subscribe to topics. Event-driven, decoupled.

Sub-agent Delegation (DeerFlow/Hermes): Parent spawns child agents with scoped context and budget.

Pipeline (AgentScope): Sequential handoff through specialized stages.

The right pattern depends on task structure:

• Independent subtasks → parallel delegation

• Sequential expertise → pipeline/handoff

• Collaborative iteration → topic bus

The Decision Framework

Key Takeaway

The protocol stack is settling. Three protocols cover the full surface. The smart strategy: adopt all three, deploy on one platform (keep platform-specific code abstracted), and compose tool capabilities via MCP.

Vendor lock-in is technical debt that compounds. Protocol adoption is infrastructure that appreciates.

The web interaction tools (350k+ combined stars) are as important as the protocols — they're how agents interact with the 85% of the world that doesn't have an API yet.