An Integrator’s Take on MCP, A2A, and ACP

1. Introduction: The Integration Crisis (Again)

1.1 The "Doing" Problem

We’ve hit a phase shift in AI. We are moving from the era of "Chat"—where we just generated text—to the era of "Agency"—where models are expected to actually do things. In the early days, interaction was a simple request-response cycle: you gave a prompt, the model gave you a probabilistic completion based on frozen weights. It was reasoning, sure, but it was blind to your enterprise context.¹

Now, we want "AI Agents." We want a Brain (the LLM), Tools (APIs, DBs), and Context (Memory). But the second we tried to build this, we slammed headfirst into a wall I call the N×M Integration Problem.²

1.2 The N×M Nightmare

If you’ve been in integration as long as I have, you know this story. The landscape of 2023-2024 was fragmentation city. You have M models (Claude, GPT-4, Llama) and N tools (Postgres, Slack, Salesforce). To get them talking, developers were writing bespoke connectors for every single pairing.²

A connector for an OpenAI agent to talk to Postgres was totally different from a Claude agent talking to Postgres. Authentication, error handling, schema definitions—all tightly coupled and brittle. If a data source API changed, you had to update every single agent integration manually. We were building silos, effectively preventing the multi-agent systems we were all dreaming about.

1.3 The "TCP/IP Moment" for AI

The industry finally realized that if AI is going to be critical infrastructure, we need a standard. We need our "TCP/IP moment." We need to decouple the intelligence (the model) from the interface (the tool).

In this post, I’m breaking down the three contenders fighting to solve this, plus the critical piece everyone forgets: governance.

Model Context Protocol (MCP): Anthropic’s play to solve the vertical integration problem (Agent ↔ Tool).³
Agent-2-Agent Protocol (A2A): Google’s play for the horizontal web of agents (Agent ↔ Agent).⁴
Agent Communication Protocol (ACP): IBM’s local-first, REST-native approach to orchestration.⁵

2. Model Context Protocol (MCP) = The USB-C of AI

2.1 The Philosophy: Inversion of Control

Anthropic dropped MCP in November 2024, pitching it as the "USB-C port" for AI applications.³ The core idea is simple but powerful: Inversion of Control.

Previously, the agent had to know how to talk to the tool. MCP flips it. The tool (or data source) exposes a standardized "MCP Server" interface. Any "MCP Client" (Claude, Zed, an IDE) can plug into it without knowing the internal logic. This turns our N×M nightmare into an N+M ecosystem. You write a "Google Drive MCP Server" once, and it works everywhere.

2.2 The Architecture

MCP isn't your typical web arch. It uses a Client-Host-Server topology:

MCP Server: A lightweight process wrapping the data/API. No LLM inside. It just exposes capabilities.
MCP Client: The consumer. It maintains the connection and translates natural language into protocol requests.
The Host: The runtime (like the Claude Desktop App) that manages the lifecycle and security boundaries.

The Transport:

Stdio: For local stuff, it spawns the server as a subprocess and talks over stdin/stdout. Fast, secure, keeps data on the machine.³
SSE over HTTP: For remote/distributed connections. Server-Sent Events push updates, HTTP POST handles requests. The payload is strictly typed JSON-RPC 2.0. Stateless and robust.

2.3 The Primitives

MCP abstracts AI needs into three buckets that map to how LLMs actually think:

Resources (Passive Context): Data the model can read. Think logs or database rows. The killer feature here is Dynamic Subscriptions. An agent can subscribe to a resource (like a log file), and if it changes, the server pushes an update. Real-time eyes on the system.
Tools (Action): The ability to do work. The client requests a list of tools (tools/list), gets a JSON schema, and the LLM generates arguments to call them (tools/call). Anthropic pushes for "Code Execution" here—offloading math or logic to the server so the LLM doesn't hallucinate.
Prompts (Workflows): Reusable templates defined by the server. A "Git MCP Server" might expose a "Generate Commit Message" prompt. It moves prompt engineering from the user to the infrastructure.

3. Agent-2-Agent Protocol (A2A): The Web of Agents

3.1 Google's Vision: Decentralized Collaboration

While MCP is about an agent using a tool (vertical), Google’s A2A is about an agent hiring another agent (horizontal).⁴

A2A wants to build the "World Wide Web of Agents." It envisions a decentralized mesh where a Salesforce agent, an Atlassian agent, and a travel agent—all built by different vendors—can discover and negotiate with each other.

3.2 The Architecture

A2A uses a Client-Remote Agent model.

Client Agent: Holds the user relationship and breaks down the goal.
Remote Agent (A2A Server): The specialist. It’s a black box to the client.
Transport: Strictly HTTPS with TLS 1.2+. Encrypted, standard web transport.

3.3 The Agent Card

This is the DNS of the A2A world. Every agent hosts an Agent Card at a "well-known" URI (/.well-known/agent.json).

It’s a JSON manifest containing:

Identity: Name, version, URL.
Skills: Natural language descriptions of what the agent can do.
This enables Semantic Discovery. The Client Agent reads the Agent Card to figure out if the Remote Agent can help, allowing for fuzzy matching and dynamic orchestration.4

4. Agent Communication Protocol (ACP): The Local Orchestrator

4.1 IBM's Vision: Local-First & Simple

IBM Research (via the "BeeAI" project) introduced ACP with a different philosophy: Simplicity and Ubiquity. It’s aimed at Edge computing and privacy-sensitive environments.⁵

ACP rejects complex RPC frameworks for REST-native patterns. If you can use curl, you can talk to an ACP agent.⁶

4.2 Architecture

REST Endpoints: GET /agents, POST /runs. Dead simple.
Sessions: ACP explicitly models stateful sessions to handle multi-turn dialogs.
Offline Discovery: ACP agents embed metadata in their distribution packages (like Python wheels). You can discover capabilities by inspecting the file on disk without spinning up the server—perfect for Scale-to-Zero architectures.

This makes ACP the go-to for "LAN" scenarios—like a factory floor or a hospital network—where data sovereignty is king and cloud relays are a no-go.⁶

5. Comparative Analysis: The Integrator's Matrix

Here is how the specs stack up side-by-side:

Feature	Model Context Protocol (MCP)	Agent-2-Agent (A2A)	Agent Communication Protocol (ACP)
Focus	Vertical: Agent ↔ Tool	Horizontal: Agent ↔ Agent (Cloud)	Horizontal: Agent ↔ Agent (Local/Edge)
Backed By	Anthropic	Google Cloud	IBM Research
Transport	Stdio / HTTP (SSE)	HTTPS (SSE)	HTTP (REST / SSE)
Discovery	Explicit Connection	Decentralized (Agent Cards)	Local Metadata / Registry
Best For	IDEs, connecting LLMs to DBs	Enterprise Swarms, Cross-Vendor	Edge AI, Privacy, Factory

6. The Missing Link: Governance & The Unified Asset Catalog

We've talked about how agents talk to tools (MCP) and how they talk to each other (A2A/ACP). But there is a massive elephant in the room that most developers are ignoring: Governance.

6.1 The "Rogue Agent" Problem

Let's be real for a second. Hooking an LLM directly up to your enterprise APIs is terrifying. If you give an agent raw access to your ERP system's API, you are trusting a probabilistic model—which occasionally hallucinates—with the keys to your financial kingdom. An agent doesn't know that it shouldn't query the entire Transactions table at 2 PM on a Friday. It just sees a tool and uses it.

We saw this "wild west" era with APIs ten years ago, and we fixed it with API Management. Now, we are seeing it with agents, and we need Controlled Access.

6.2 The Unified Asset Catalog as the "Menu"

This is where solutions like the IBM webMethods Unified Asset Catalog come into play. You can think of the Unified Asset Catalog as a curated, safe "menu" for your AI agents.

Instead of letting an agent discover every API endpoint in your company, you register specific, safe capabilities in the Catalog. The Catalog acts as a metadata layer that sits between the agent and your actual infrastructure.

Controlled Access: You define exactly who (which agent) can access what (which API).
Semantic Metadata: The Catalog enriches technical APIs with business context. It turns a cryptic GET /v1/cust/884 endpoint into a semantic skill like "Retrieve Customer Contact Details." This helps the agent understand why it should use a tool, not just how.
Policy Enforcement: Because the access goes through the webMethods integration layer, you can enforce policies like rate limiting, masking sensitive PII fields (so the LLM never sees them), and audit logging.

6.3 The Future: The Agent Control Plane

Recent developments in late 2024 and 2025 have pushed this concept further. We are seeing a convergence where the Integration Platform (iPaaS) becomes the Agent Control Plane.

In this architecture, the Unified Asset Catalog is the source of truth.

MCP Servers query the Catalog to dynamically generate tool definitions for the agent.
A2A Agents query the Catalog to populate their "Agent Cards" with verified skills.
Governance is applied centrally. If you update a policy in the Catalog, every agent—whether it's running in Claude, a local script, or a cloud swarm—instantly adheres to the new rule.

This is the only way to scale. You cannot rely on "prompt engineering" to keep your agents secure. You need structural, architectural governance.

7. The Bottom Line

The days of the black box chatbot are over. We are building modular, interoperable intelligence.

If you are an integrator:

Adopt MCP right now for your data connections. It’s the standard.
Look at ACP for your internal, private agent meshes.
Keep an eye on A2A for cross-organizational services.
Most Importantly: Don't skip the governance layer. Use a Unified Asset Catalog to curate and control what your agents can actually touch.

The future isn't one giant model; it's a mesh of specialists speaking these protocols, governed by a robust integration platform.

References

Anthropic. "Model Context Protocol (MCP)." modelcontextprotocol.io
WebMethodMan. "Born to be an Integrator."(https://www.webmethodman.com/p/born-to-be-an-integrator)
Anthropic. "Introducing Model Context Protocol." Anthropic News
Google Cloud. "A2A: A New Era of Agent Interoperability."(https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/)
IBM Research. "Agent Communication Protocol (ACP)."(https://www.ibm.com/think/topics/agent-communication-protocol)
ACP Contributors. "ACP: Open protocol for communication between AI agents." GitHub - i-am-bee/acp
IBM. "IBM webMethods Hybrid Integration: Unified Asset Catalog."(https://www.ibm.com/products/webmethods-hybrid-integration)