Lately, the term “MCP” and “A2A” has been popping out a lot in my feed. With GitHub launching its first official MCP server, it’s time I continue my quest of exploring what exactly is MCP and A2A, how they work and why they are superpowers for AI Agents.

Hello and welcome to another Articles by Victoria, the place where I randomly write things I’m curious about. In the evolving landscape of AI, the emergence of autonomous agents capable of perceiving, reasoning, and acting has been transformative. Last month, I wrote an article on Understanding AI Agents: An Overview and it has garnered a few private discussions among friends and co-workers.

Now that everyone has become curious of the possibilities that AI agents can bring, let’s take it a step further by learning about the MCP and A2A protocols in this article.

Btw, I now include this article and any AI-related articles to a new series called “AI, but make it make sense”. The aim of this series is to demystify anything AI, for non-techies and techies. Since I’m only 1 human brain, not every article can be super detailed. Feel free to always reach out if there’s a specific topic you’d like me to cover or elaborate in this series. Thanks!

Series link: https://lo-victoria.com/series/ai

What is MCP?

First developed by Anthropic, the Model Context Protocol (MCP) is an open standard that allows AI agents to connect seamlessly with external tools, APIs, and data sources. Think of MCP as a universal connector, enabling AI agents to fetch information, interact with APIs, and execute tasks beyond their built-in knowledge.

Core Components of MCP

• MCP Host: the actual user-facing environment that wants to access data (e.g. Claude)

• MCP Client: the component that takes queries, sends the request, and returns the output (examples)

• MCP Server: the component that has access to the tools/resources - examples

• MCP Protocol: "Rules" that allows agent-tool communication, no matter how they’re built.

Why MCP?

Think of MCP as a smart way to help AI tools talk to each other and get the right information—without confusion or extra work. Before MCP, every AI agent had to come with its own built-in tools and custom connections. It was like giving each one its own set of private tools that no one else could use. Developers had to build these over and over again for each system.

With MCP, it's like switching from private APIs (which only the original system can use) to public APIs that anyone can access. Now, developers can build tools once, and all AI agents or systems can use them. This makes it easier to share information, avoids repeating the same work, and helps AI agents know exactly where and how to get what they need—cleanly and modularly.

The 3 MCP Primitives

The MCP protocol defines three core primitives that servers can implement:

Table source: https://github.com/modelcontextprotocol/python-sdk

Server Capabilities

MCP servers declare capabilities during initialization:

Table source: https://github.com/modelcontextprotocol/python-sdk

What is A2A?

As a complementary to MCP, Google introduced the Agent-to-Agent (A2A) protocol, primarily built upon JSON-RPC 2.0 and an open standard that enables AI agents to communicate and collaborate across different platforms and frameworks. A2A provides a common language for agents, allowing them to securely exchange information, coordinate actions, and work together effectively. ​

This interoperability is crucial for complex tasks that require multiple specialized agents. For example, a customer support agent can delegate a technical query to a specialized troubleshooting agent, ensuring efficient and accurate responses.​

Think of it as MCP allows agents to connect to tools and resources, while A2A allows agents to talk to each other. Below is a simplified diagram.

Core Components of A2A

Looking at the specs file found on the Google GitHub page, here's an explanation of its key components (you can study the JSON for more details):

1) Agent Discoverability: AgentCard contains information about an agent including:

• Identity (name, description, version)

• Available capabilities and skills

• Supported authentication methods

Example (from google.github.io)

{
  "name": "Google Maps Agent",
  "description": "Plan routes, remember places, and generate directions",
  "url": "https://maps-agent.google.com",
  "provider": {
    "organization": "Google",
    "url": "https://google.com"
  },
  "version": "1.0.0",
  "authentication": {
    "schemes": "OAuth2"
  },
  "defaultInputModes": ["text/plain"],
  "defaultOutputModes": ["text/plain", "application/html"],
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "route-planner",
      "name": "Route planning",
      "description": "Helps plan routing between two locations",
      "tags": ["maps", "routing", "navigation"],
      "examples": [
        "plan my route from Sunnyvale to Mountain View",
        "what's the commute time from Sunnyvale to San Francisco at 9AM",
        "create turn by turn directions from Sunnyvale to Mountain View"
      ],
      // can return a video of the route
      "outputModes": ["application/html", "video/mp4"]
    },
    {
      "id": "custom-map",
      "name": "My Map",
      "description": "Manage a custom map with your own saved places",
      "tags": ["custom-map", "saved-places"],
      "examples": [
        "show me my favorite restaurants on the map",
        "create a visual of all places I've visited in the past year"
      ],
      "outputModes": ["application/html"]
    }
  ]
}

2) Capability Definition: AgentSkill defines specific capabilities an agent can perform:

• Unique skill identifier and name

• Detailed description of what the skill does

• Input and output mode specifications (what types of data it accepts and produces)

• Optional examples showing how to use the skill

• Optional schema defining expected parameters

• Authorization requirements for using the skill

3) Objects: Message contains multiple Part. Task is the desired outcome for the agent, Artifact is the output from a task

4) State Management: The protocol explicitly handles task state transitions through status codes.

PENDING → RUNNING → SUCCEEDED/FAILED/CANCELED

5) Auth Handling: includes auth methods such as

• API keys

• OAuth flows

• Other custom authentication schemes

6) Task Management Methods

• tasks/create - Initiates a new task for the agent to perform

• tasks/get - Retrieves the current state of a task

• tasks/stream - Provides real-time updates on task progress

• tasks/send - Sends additional messages to an ongoing task

• tasks/cancel - Stops an in-progress task

Overview: MCP vs A2A

What MCP and A2A Mean for AI Development

The adoption of MCP and A2A signifies a shift towards more modular and collaborative AI systems. By standardizing interactions between agents and tools (MCP) and among agents themselves (A2A), developers can create more flexible and scalable AI solutions.​

Rather than building monolithic systems, teams can focus on creating specialized agents that excel at specific tasks, then connect them through standardized interfaces. This modular approach accelerates development cycles and allows for more sophisticated AI applications without corresponding increases in complexity.

Businesses benefit from increased flexibility and reduced vendor lock-in. As more AI tools adopt these protocols, organizations can select best-of-breed components and replace parts of their AI stack without rebuilding entire systems. This fosters innovation while preserving investments in existing infrastructure.

End-users will experience more capable and responsive AI systems that can tap into specialized knowledge and capabilities on demand. As agents learn to collaborate effectively, we'll see AI assistants that can seamlessly handle complex workflows spanning multiple domains and data sources.

In future articles of this series, I shall be going through step-by-step, how to build your own MCP server and implement A2A protocol in your AI agent workflow. Stay tuned!

Conclusion

All in all, the introduction of MCP and A2A protocols marks a significant advancement in AI development, promoting interoperability and collaboration among AI agents and tools. As these standards gain traction, we can anticipate more sophisticated, efficient, and adaptable AI systems that will transform various aspects of our digital lives.​

As developers, it is crucial that we know how to leverage these new “superpowers”. Thanks for reading! Hope this article has been helpful! If it has, do leave a like, share the article and comment your thoughts below! Have you dabbled in MCP and A2A? Stay tuned for more “AI, but make it make sense” articles! Cheers!

Let's Connect!

• Twitter

• LinkedIn

• GitHub

References

• https://www.anthropic.com/news/model-context-protocol

• https://modelcontextprotocol.io/introduction

• https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

• https://google.github.io/A2A/#/

• https://github.com/google/A2A/blob/main/specification/json/a2a.json

• https://google.github.io/A2A/#/documentation?id=agent-card

• https://google.github.io/A2A/#/documentation?id=agent-to-agent-communication

• https://github.com/github/github-mcp-server

• https://github.com/modelcontextprotocol/servers

• https://github.com/modelcontextprotocol/python-sdk