Blog

MCP, A2A, ACP: What does it all mean?

Written by Duncan Devore | May 15, 2025 8:50:42 PM

The rise of agentic AI marks a fundamental shift in enterprise software design, introducing large-scale distributed systems and autonomous agents that collaborate, reason, and perform complex workflows. For senior technologists and business leaders, understanding communication protocols like MCP, A2A, and ACP are needed for building scalable, interoperable agentic AI solutions.

In this blog, we'll look at three influential communication protocols—Model Context Protocol (MCP), Agent-to-Agent (A2A), and Agent Communication Protocol (ACP). We’ll discuss their key characteristics, features, and provide message calling examples.

1. Model Context Protocol (MCP)

Overview:

MCP, created by Anthropic, standardizes the interaction between large language model (LLM)-based agents and external tools or APIs. It employs a request/response REST interface over HTTP for structured invocation of external capabilities, facilitating simple, rapid integration. Think of it as a universal way for AI agents to access and interact with data sources, tools, and instructions in a consistent manner.

MCP is like the basic grammar for AI communication, ensuring different applications can understand each other when accessing data, tools, and LLM's.

Features:

  • Request/Response follows JSON RPC 2.0
  • Makes it easier and faster to integrate AI agents with various tools and data, for example a REST based interface
  • Fast becoming a standard that will reduce vendor lock-in by providing a common interface to different LLM providers
  • Outlines how AI agents can query and interact with these servers to retrieve and utilize the provided context
  • SSE over HTTP allows MCP clients (like AI agents or applications) to connect to remote MCP servers that expose tools and functionalities over a network

Example MCP message calling:

Request: 1. Model Cont1. Model Context Protocol (MCP)ext Procol (MCP)

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "NYC"
    }
  }
}
  • "jsonrpc": "2.0", identifies this follows the JSON RPC 2.0 spec
  • Request invokes a "tools/call"
  • "method": Specifies the tools/call method within the MCP
  • "params": Includes the name of the tool to be called ("get_weather") and any necessary arguments (in this case, the "location":"NYC")

Response:

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Current Weather NYC:\nTemperature: 72°F\nConditions: Cloudy"
      }
    ],
    "isError": false
  }
}
  • "jsonrpc": "2.0", identifies this follows the JSON RPC 2.0 spec
  • Response: Contains the outcome of the tool call
  • "content": An array holding the actual information returned by the tool, formatted in different types (here, a text-based weather report)
  • Status: Indicates whether the tool call resulted in an error ("isError": false)

2. Agent-to-Agent Protocol (A2A)

Overview:

Google's A2A provides a structured JSON-over-HTTP approach for agent-to-agent communication, supporting clearly defined task lifecycles and real-time communication via SSE (Server-Sent Events) or webhooks. It aims to create a world where agents, possibly built on different frameworks and by different vendors, can seamlessly collaborate.

A2A is like universal meeting rules for AI, ensuring smooth collaboration and information exchange between different agents.

Features:

  • Request/Response follows JSON RPC 2.0
  • Clearly structured task states (submitted, working, completed)
  • Agents can collaborate without needing to share proprietary logic or internal workings, enhancing security
  • Supports easy agent discovery through standardized metadata
  • Allows specialized agents to work together on tasks beyond the capability of a single agent
  • Provides a stateful, task-oriented communication mode

Example A2A message calling:

Request:

{
"jsonrpc": "2.0",
"id": 1,
"method": "tasks/send",
"params": {
  "id": "de38c76d-d54c-436c-8b9f-4c2703648d64",
  "message": {
    "role": "user",
    "parts": [
      {
        "type": "text",
        "text": "tell me a joke"
      }
    ]
  },
  "metadata": {}
}
}

Request structure:

  • "jsonrpc": "2.0", identifies this follows the JSON RPC 2.0 spec
  • It's a JSON-RPC 2.0 request
  • The method being called is "tasks/send"
  • It includes a unique identifier ("id")
  • The "params" contain information about a task to be sent
  • The task's "message" has a user role and contains a text part asking "tell me a joke"

Response:

{
"jsonrpc": "2.0",
"id": 1,
"result": {
  "id": "de38c76d-d54c-436c-8b9f-4c2703648d64",
  "sessionId": "c295ea44-7543-4f78-b524-7a38915ad6e4",
  "status": {
    "state": "completed"
  },
  "artifacts": [
    {
      "name": "joke",
      "parts": [
        {
          "type": "text",
          "text": "Why did the chicken cross the road? To get to the other side!"
        }
      ]
    }
  ],
  "metadata": {}
}
}

Response structure:

  • "jsonrpc":2.0", identifies this follows the JSON RPC 2.0 spec
  • The "result" indicates the outcome of the task
  • It includes the original "id" and a "sessionId" for the interaction
  • The "status" shows the task is completed
  • The "artifacts" array contains the output of the task, in this case, a "parts" named "joke" with the "text":  "Why did the chicken cross the road? To get to the other side!"

3. Agent Communication Protocol (ACP)

Overview:

The Agent Communication Protocol (ACP, designed by BeeAI and the Linux Foundation) is an emerging open standard designed to enable interoperability between different AI agents, regardless of their underlying frameworks, technologies, or developers. Think of it as a potential "HTTP for AI agents," aiming to transform the current landscape of siloed agents into a connected network.

ACP is like a universal power adapter for AI, allowing diverse agents to connect and communicate seamlessly.

Features:

  • Flexible, cross-platform compatibility
  • Built-in agent registration and discovery
  • Rapid extensibility and developer-friendly REST APIs
  • Agents can exchange messages containing various types of content, such as text, images, JSON data, and more, allowing for rich communication
  • ACP focuses on how agents communicate, not how they are internally built

Example ACP message calling:

Request:

{
  "agent_name": "echo",
    "input": [
      { 
        "parts": [
          {
            "content": "Howdy!",
            "content_type": "text/plain"
          }
        ]
      }
    ]
}

Request structure:

  • "agent_name": name of the agent being called
  • "parts": Array of "content" and its type

Response:

{
  "run_id": "44e480d6-9a3e-4e35-8a03-faa759e19588",
  "agent_name": "echo",
  "session_id": "b30b1946-6010-4974-bd35-89a2bb0ce844",
  "status": "completed",
  "await_request": null,
  "output": [
    {
      "parts": [
        {
          "name": null,
          "content_type": "text/plain",
          "content": "Howdy!",
          "content_encoding": "plain",
          "content_url": null
        }
      ]
    }
  ],
  "error": null
}

Response structure:

  • run_id: Unique ID for this agent execution
  • agent_name: Name of the agent ("echo")
  • session_id: ID of the ongoing conversation
  • status: "completed" indicating the run finished
  • output: Contains the agent's results, including content like "Howdy!"
  • error: null, meaning no errors occurred

Conclusion: What it all means

In conclusion, MCP, A2A, and ACP each play essential roles in the advancement of agentic AI, providing standardized protocols crucial for enabling seamless integration, secure collaboration, and extensive interoperability among diverse AI agents. These protocols not only simplify the complexity inherent in multi-agent environments but also significantly reduce barriers to adopting AI solutions across different technologies and vendors.

Moving forward, as organizations increasingly rely on distributed, intelligent systems, familiarity and proficiency with protocols like MCP, A2A, and ACP will become indispensable. Business leaders and technology strategists who understand these frameworks will be better equipped to navigate the evolving landscape of Agentic AI, leveraging their capabilities to innovate, scale, and maintain competitive advantages in a rapidly changing technological environment.

References:
View full post