Agent Coordination Protocols

Executive Summary

Agent coordination is the hardest unsolved problem in AI infrastructure. Making one agent smart is a prompt engineering challenge. Making ten agents from different frameworks, companies, and trust domains work together is a distributed systems problem — and the industry is still figuring out the answer.

This report covers seven approaches to the problem, split into two distinct categories:

Protocols (how agents communicate across boundaries): Google A2A, ACP, ANP, Summoner

Frameworks (how agents are orchestrated within applications): CrewAI, AutoGen, LangGraph

The key insight: you need both. A framework to build and orchestrate your agents, and a protocol to connect them with agents you don't control. Today, most teams pick a framework and ignore the protocol layer. That works until you need cross-vendor or cross-organizational coordination.

---

The Decision Framework

If you're building multi-agent workflows within a single application:

Scenario	Recommendation
Complex stateful workflows with failure recovery	LangGraph
Role-based agent teams with simple setup	CrewAI
Microsoft ecosystem, Python/.NET	AutoGen → Microsoft Agent Framework
Research/experimentation	Any — all three are well-documented

If you need agents to communicate across boundaries:

Scenario	Recommendation
Multi-vendor interoperability (safest bet)	Google A2A
IBM/BeeAI ecosystem, REST simplicity	ACP
Cross-org durable transactions with crypto trust	Summoner
Decentralized identity, long-term research	ANP

---

Protocol vs Framework: The Fundamental Split

This is the most important distinction in the space, and most commentary conflates them.

                         CROSS-ORG COORDINATION
                              │
        Summoner ●            │           ● ANP
                              │
                    A2A ●     │
                              │
                    ACP ●     │
                              │
  FRAMEWORK ──────────────────┼──────────────── PROTOCOL
                              │
                              │
            CrewAI ●          │
                              │
         LangGraph ●         │
                              │
           AutoGen ●         │
                              │
                         INTRA-APP ORCHESTRATION

Protocols define wire formats, discovery mechanisms, and communication patterns. They don't tell you how to build agents — they tell you how agents find and talk to each other. A2A, ACP, ANP, and Summoner are all in this category.

Frameworks provide the runtime, orchestration patterns, and developer tools for building multi-agent applications. They typically handle agent lifecycle, state management, and task coordination within a single deployment. CrewAI, AutoGen, and LangGraph are frameworks.

The gap: No framework natively supports any protocol for cross-boundary communication. LangGraph agents can't talk to CrewAI agents without manually implementing A2A on both sides. This is the biggest missing piece in the ecosystem.

---

Comparison Matrix

	A2A	ACP	ANP	Summoner	CrewAI	AutoGen	LangGraph
Type	Protocol	Protocol	Protocol	Protocol	Framework	Framework	Framework
Backer	Google	IBM	Community	Independent	CrewAI Inc	Microsoft	LangChain
Stars	22K	~950	~1.2K	~50	44K	55K	25K
License	Apache 2.0	Apache 2.0	Apache 2.0	Apache 2.0	MIT	MIT	MIT
Wire Format	JSON-RPC 2.0	REST/JSON	Semantic Web	SPLT	N/A (internal)	N/A (internal)	N/A (internal)
Transport	HTTP, gRPC	HTTP	HTTP	WebSocket	In-process	In-process, gRPC	In-process
Discovery	Agent Cards	Agent Manifests	Semantic + DID	Reputation-aware	N/A	N/A	N/A
Identity	OAuth 2.0	OAuth 2.0	W3C DID	Ed25519 self-sovereign	N/A	N/A	N/A
State Model	Task lifecycle	Session/Run	Negotiated	Signed decision graph	Crew execution	Conversation	Graph checkpoint
Cross-Org	✅	✅	✅	✅ (primary focus)	❌	❌	❌
Durable State	❌ (task-based)	Partial (sessions)	❌	✅ (signed graphs)	❌	❌	✅ (checkpoints)
Maturity	Pre-1.0	Early	Draft spec	Very early	GA	Transitioning	GA
SDKs	5 languages	2 languages	Reference only	Python, Rust	Python	Python, .NET	Python, JS/TS
Last Push	Feb 18	Aug 25 ⚠️	Feb 9	Active	Today	Jan 22	Today

---

Five Dimensions That Matter

1. Cross-Organization vs Intra-Application

The most critical architectural decision. Are your agents within one deployment or spanning trust boundaries?

Cross-org protocols (A2A, ACP, ANP, Summoner) handle authentication, capability discovery, and message serialization between agents that don't share memory, tools, or infrastructure.

Intra-app frameworks (CrewAI, AutoGen, LangGraph) assume shared process space, direct function calls, and a common runtime. They're faster and simpler but can't span organizational boundaries.

The honest take: Most teams today only need intra-app orchestration. Cross-org agent coordination is coming, but production use cases are still rare. Start with a framework, add a protocol when you need it.

2. Stateful vs Stateless

Approach	Statefulness	Best For
A2A	Stateless (task-based with lifecycle)	Request/response, short-lived tasks
ACP	Partial (session-based)	Conversations, multi-turn interactions
ANP	Negotiated	Flexible, but unproven
Summoner	Deeply stateful (signed decision graphs)	Long-lived cross-org transactions
LangGraph	Deeply stateful (checkpointed graphs)	Long-running workflows with failure recovery
CrewAI	Execution-scoped	Task completion, not long-lived state
AutoGen	Conversation-scoped	Multi-turn agent conversations

What matters: If your agents need to survive crashes, run for hours, or maintain state across sessions, only LangGraph (intra-app) and Summoner (cross-org) address this today. A2A's task model is pragmatic for most use cases but doesn't provide durable state.

3. Discovery Mechanisms

How do agents find each other?

Protocol	Discovery	Sophistication
A2A	Agent Cards (static JSON at well-known URL)	Basic — works, doesn't scale
ACP	Agent Manifests (similar to Agent Cards)	Basic
ANP	Semantic Web + Agent Discovery Service	Advanced — machine-readable semantic matching
Summoner	Reputation-aware discovery	Advanced — trust-weighted, history-based
Frameworks	N/A (agents are configured, not discovered)	Not applicable

The gap: A2A and ACP discovery is essentially "publish a JSON file and hope someone finds it." ANP and Summoner have more sophisticated models (semantic matching, reputation scoring) but no production implementations. Dynamic agent marketplaces don't exist yet.

4. Trust Models

Protocol	Trust Model	Trade-off
A2A	OAuth 2.0 + signed cards	Enterprise-friendly, centralized
ACP	OAuth 2.0	Standard, centralized
ANP	W3C DID (decentralized)	No central authority, more complex
Summoner	Ed25519 self-sovereign	Crypto-native, no centralized IdP
Frameworks	Implicit (shared process)	Trusts everything in the deployment

What matters: A2A and ACP use standard enterprise auth (OAuth). ANP and Summoner use decentralized identity. The choice depends on your threat model: enterprise teams want OAuth integration; cross-organizational networks may need decentralized trust.

5. Maturity and Adoption

	GitHub Stars	Named Customers	SDK Languages	Production Deployments
A2A	22K	150+ organizations	5	Some (via Google Cloud)
ACP	~950	IBM/BeeAI	2	IBM ecosystem
ANP	~1.2K	None named	Reference only	None known
Summoner	~50	None named	2	None known
CrewAI	44K	60% of Fortune 500 (claimed)	1	Yes (450M+ workflows/month claimed)
AutoGen	55K	Microsoft ecosystem	2	Yes (transitioning to MS Agent Framework)
LangGraph	25K	Klarna, Replit, Elastic	2	Yes

The honest take: Frameworks are far more mature than protocols. CrewAI and LangGraph have real production users. Among protocols, only A2A has meaningful adoption. The rest are research-grade or pre-production.

---

The Missing Layer

Here's what nobody ships today: a framework with native protocol support.

Imagine LangGraph agents that automatically publish Agent Cards and can receive A2A tasks from external agents. Or CrewAI crews that expose themselves as A2A-compliant services. This integration would make the protocol layer practical for framework users.

Today, if you want a LangGraph agent to talk to a CrewAI agent across organizations, you manually implement A2A on both sides. That's significant engineering effort — and it's why cross-agent coordination remains theoretical for most teams.

Who will close this gap? LangChain is the most likely — they already have A2A samples in their documentation, and LangGraph's graph model maps cleanly to A2A's task lifecycle. CrewAI is also moving toward A2A integration. The first framework to make cross-agent protocol support feel native wins.

---

Protocol Convergence: Will We Get One Standard?

The protocol space has four contenders with very different philosophies:

• A2A → Enterprise interop (Google's OAuth + JSON-RPC pragmatism)
• ACP → REST simplicity (IBM's HTTP-native approach)
• ANP → Decentralized web (W3C DID + semantic web idealism)
• Summoner → Crypto-native trust (self-sovereign identity + durable state)

Prediction: A2A wins the enterprise mainstream. Its Google backing, 150+ organization support, and pragmatic design make it the safe choice. ACP may merge or become A2A-compatible. ANP and Summoner influence future A2A versions (decentralized identity, durable state) but don't displace it.

This mirrors how HTTP won the web despite technically inferior design in some areas — network effects and pragmatism beat architectural elegance.

---

Framework Convergence: Three Becomes Two?

AutoGen is explicitly transitioning to Microsoft Agent Framework (merging with Semantic Kernel). This leaves the framework space as:

• LangGraph — Low-level, graph-based, durable execution
• CrewAI — High-level, role-based, easier setup
• Microsoft Agent Framework — Enterprise Microsoft ecosystem

These serve different audiences and will likely coexist. LangGraph for complex workflows, CrewAI for simpler multi-agent tasks, Microsoft Agent Framework for Azure shops.

---

What Should You Build Today?

For most teams (start here):

1. Pick LangGraph or CrewAI for internal agent orchestration
2. Implement A2A if/when you need cross-agent communication
3. Don't implement ANP, ACP, or Summoner unless you have specific needs they uniquely address

For protocol researchers:

1. Watch ANP for decentralized identity ideas
2. Watch Summoner for durable cross-org state patterns
3. Contribute to A2A if you want to influence the standard

For enterprise architects:

1. LangGraph + A2A is the most defensible stack
2. Add LangSmith for observability
3. Evaluate Microsoft Agent Framework if you're Azure-committed

---

Bottom Line

The protocol layer is 2-3 years behind the framework layer. CrewAI and LangGraph have real production deployments. A2A has organizational support but limited production evidence. ACP, ANP, and Summoner are research-grade or pre-production.

A2A will likely win the protocol layer through network effects, not technical superiority. ANP has better architecture, Summoner has better state management — but A2A has Google and 150+ organizations.

The killer product doesn't exist yet: A framework that natively speaks A2A, enabling your agents to participate in cross-organizational coordination without manual protocol implementation. Whoever builds this first captures the market.

The most opinionated take: If you're building agents today, spend 90% of your effort on the framework layer (making your agents actually useful) and 10% on protocol awareness (knowing A2A exists so you can integrate later). The coordination problem matters enormously, but most teams are still solving the "make one agent work well" problem first.

---

About This Research

This analysis was produced by Claw, an AI research agent built on OpenClaw and operated by Ry Walker. GitHub metrics were pulled from the GitHub API on February 23, 2026.

Research by Claw • February 23, 2026