Agent Landscape #6: Coordination & Protocols — Agents Talking to Everything
Standards let agents talk to anything. Platform SDKs lock agents to one cloud. Choose wisely.
TLDR: Three protocols cover the full agent communication surface: MCP (agent↔tools, 87k servers), A2A (agent↔agent, Linux Foundation), AG-UI (agent↔user, adopted by Google/AWS/MS). Adopt all three. Pick one platform SDK (AWS Strands, Semantic Kernel, Cloudflare, Vercel AI). Compose tool capabilities via MCP — the web interaction tools (Firecrawl 131k, Browser Use 98k) are as critical as the protocols themselves.
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
| Protocol | Surface | Adoption |
|---|---|---|
| MCP | agent ↔ tools | Universally adopted, 87k servers |
| A2A | agent ↔ agent | Linux Foundation, cross-vendor |
| AG-UI | agent ↔ user | Google/AWS/MS/LangChain adopted |
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.
| Gain | Lose |
|---|---|
| Cheapest always-on (pennies/month) | Cloudflare lock-in |
| Native WebSocket persistence | TypeScript only |
| Edge-native (global, low latency) | No GPU access |
Best for: Lightweight always-on agents (chatbots, monitors, schedulers).
AWS Strands — 6k stars
Open-source Python SDK for Bedrock + Lambda + DynamoDB agents.
| Gain | Lose |
|---|---|
| Clean Python SDK | AWS-ecosystem assumptions |
| Native Bedrock integration | No event sourcing |
| Open source (Apache-2.0) | No multi-agent coordination |
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.
| Gain | Lose |
|---|---|
| Multi-language (.NET, Python, Java) | Heavy abstraction layer |
| Deep Azure/OpenAI integration | Microsoft ecosystem assumptions |
| Enterprise features (RBAC, telemetry) | Slower iteration than lighter SDKs |
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.
| Gain | Lose |
|---|---|
| Best frontend AI DX | Frontend only |
| Framework-agnostic model access | TypeScript only |
| Built-in streaming | Request-response focused |
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.
| Project | Stars | What it does | MCP |
|---|---|---|---|
| Firecrawl | 131k | Web scraping → clean markdown for agents | Yes |
| Browser Use | 98k | LLM-driven browser automation (Playwright) | Yes |
| Crawl4AI | 68k | Deep web crawling for RAG/knowledge | Yes |
| Composio | 29k | 1000+ SaaS integrations with managed auth | Yes |
| Skyvern | 22k | Browser automation via LLM + computer vision | Yes |
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.
| Project | Stars | What it does | Open source |
|---|---|---|---|
| Langfuse | 29k | Open-source LLM observability — traces, evals, prompt management | Yes |
| LangSmith (LangChain) | — | Trace-based evaluation, multi-turn testing, comparison testing | No (managed) |
| Arize Phoenix | 10k | Open-source ML/LLM observability, OpenTelemetry-native | Yes |
| AgentOps | 6k | Session replay, time-travel debugging, cost attribution per agent | Yes |
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.
Previous: Agent Landscape #5: Sandboxing — The Missing Security Boundary Series start: Agent Landscape #1: The 5 Things Every Production Agent Needs