Why ACP Had to Exist: A Personal Line of Reasoning
When Anthropic unveiled Model Context Protocol (MCP) last year, it felt like the missing USB-C port for LLMs: one uniform jack an agent could use to plug into any CRM, ERP, search index, or vector store without hand-carved adapters. MCP’s JSON-RPC vocabulary elegantly normalized agent → tool calls and even gave us streaming responses and shared context objects. But the very moment I wired two tool-savvy agents together I ran into an old problem: the cables only ran outward. Nothing in MCP taught the agents how to find one another, share conversation state, or negotiate ownership of a task. In other words, MCP perfected the southbound interface (toward tools) and left the east-west highway (between agents) unpaved.
The Structural Gap
Multi-agent workflows escalate combinatorially. A purchasing bot that talks to an inventory bot, a risk-analysis bot, and a compliance bot needs three bespoke bridges; add a forecasting bot and you suddenly maintain six. Scale that to dozens of departmental agents and the diagram looks like early 1990s networking spaghetti. Without a peer-to-peer standard, every new path is more “duct tape.” IBM’s research group literally used that phrase when introducing their alternative.
Enter ACP: The “HTTP” Layer for Agents
Agent Communication Protocol (ACP) proposes a clean abstraction:
Core purpose
Tool invocation
Agent discovery & dialogue
Complements, not competes
Transport
JSON-RPC over HTTP/SSE
Plain REST (JSON) + optional WebSockets
Familiar to any stack
Discovery
None (tools are referenced by the caller)
Manifest-based self-advertising, even offline
Agents locate each other in zero-trust zones
Modes
Synchronous, streaming tool calls
Sync, async, and long-running conversations
Covers “fire-and-forget” and live collaboration
Context propagation
Request/response metadata
Full conversational transcript + capability tokens
Agents keep memory across hops
ACP’s mantra, “agents to agents; MCP connects agents to tools” instantly clicked for me because it mirrors the layered Internet: TCP moves bytes; HTTP moves documents; RESTful ACP moves tasks.
Key Traits I Find Noteworthy
Self-description: Every ACP agent carries a signed manifest that advertises its skills and endpoint, so even an air-gapped factory floor can let autonomous forklifts discover the scheduling agent sitting two VLANs away.
Capability tokens: Think JWT meets Kubernetes RBAC. An agent can delegate a subset of its powers to another agent without leaking full API keys, crucial for least-privilege chains in regulated industries.
Observability hooks: OTLP traces are first-class, so ops teams inspect agent chatter in Grafana the same way they inspect microservices today.
Thin clients: Because it’s pure REST, a cURL one-liner can poke an agent; yet SDKs for Python/TypeScript exist when you need schema validation.
Why This Matters for Enterprise Value
N²‐integration tax disappears. Instead of writing ten bespoke bridges for ten agents, teams publish a manifest once and let ACP’s discovery layer do the wiring. That frees engineering cycles for real features, not glue code.
Decentralized autonomy. Finance, supply-chain, and HR agents can collaborate directly without routing every message through a monolithic “manager” service that becomes a single point of failure.
Zero-trust friendliness. In highly segmented networks, like banks, telcos, critical infrastructure, agents can talk through standard HTTPS ports with signed capability tokens, satisfying auditors who already understand TLS and REST headers.
Vendor-neutral ecosystem. Both MCP and ACP live under open governance (MCP under Anthropic, ACP under the Linux Foundation’s BeeAI). That means an SAP-backed procurement agent, a Salesforce service bot, and an open-source RAG retriever can all cooperate without locking the buyer into a single AI vendor.
Observability and rollback. Because every ACP exchange is traceable, ops can replay a failed multi-agent interaction or roll back a decision chain, this is essential for regulated markets where “explainability” is a board-level word.
A Closing Deduction
MCP solved the last-mile problem of getting LLMs to do things in the outside world. The minute we asked those newly empowered agents to coordinate as peers, we hit a protocol vacuum. ACP steps neatly into that space, giving enterprises a shared lingua franca for agent discovery, delegation, and dialogue. Together, MCP + ACP form a layered stack:
MCP = context in -> results out.
ACP = intent in -> consensus out.
The practical upshot is that an organization can now compose swarms of specialized agents, such as finance auditors, legal reviewers, field-service troubleshooters, without drowning in integration cost. That architectural leverage, not just raw model quality, is what will differentiate the next wave of agentic enterprises.
Ref:
[1]: https://research.ibm.com/blog/agent-communication-protocol-ai
[2]: https://modelcontextprotocol.io/introduction
[3]: https://modelcontextprotocol.io/specification/2025-03-26
[4]: https://agentcommunicationprotocol.dev/introduction/welcome
Last updated