Beyond Traditional APIs: The Rise of MCP and A2A in the AI Revolution

The architecture of business technology stands at a pivotal moment of change, one that few organisations have fully recognised. The traditional public API, for a long time the bedrock of modern software integration, is finding its dominance challenged. As AI transforms business operations, two emerging protocols are reshaping how organisations expose their data and capabilities: the Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol. This shift isn't merely a technical curiosity, it represents a fundamental reimagining of how businesses connect with AI systems and how these systems interact with each other. While APIs aren't disappearing, their role is being dramatically redefined. For companies seeking competitive advantage in an AI-powered future, understanding and strategically adopting these new protocols alongside traditional APIs may soon become essential. The organisations that recognise this paradigm shift early will have a distinct advantage. Those who don't may find themselves struggling to integrate with the rapidly expanding ecosystem of AI services that speak these new languages. The question isn't whether APIs will continue to exist, it's whether they alone will be sufficient for businesses that want to thrive in the coming era of AI. What is an MCP Server? The Model Context Protocol (MCP) is an open standard created by Anthropic that standardises how applications provide context to large language models (LLMs). If you're familiar with traditional APIs, think of MCP as their evolution, specifically designed for the AI era. At its core, MCP defines a client-server architecture where: MCP Clients: These are AI models or applications that need access to external data or capabilities. They maintain 1:1 connections with servers. MCP Servers: These are lightweight programs that expose specific capabilities through a standardised interface. They can provide access to databases, APIs, services, and other resources. MCP servers expose three primary capabilities: Tools: Functions that perform specific actions Prompts: Templates for generating structured content Resources: Data sources that can be accessed and analyzed // Example of creating a new MCP server const server = new McpServer({ name: 'simple-greeting-server', version: '1.0.0', }, { capabilities: { tools: {}, resources: {} } }); // Example of registering a tool in an MCP server server.tool( 'greet', // Tool name 'A simple greeting tool', // Description { name: z.string().describe('Name to greet'), // Parameters schema }, async ({ name }): Promise => { return { content: [ { type: 'text', text: `Hello, ${name}!`, }, ], }; } ); // Create a simple resource at a fixed URI server.resource( 'greeting_resource', 'https://example.com/greetings/default', { mimeType: 'text/plain' }, async (): Promise => { return { contents: [ { uri: 'https://example.com/greetings/default', text: 'Hello, world!', }, ], }; } ); The protocol also supports streaming responses, allowing for real-time interactions and progressive updates, critical for maintaining natural conversational flows with AI assistants. Early adopters of MCP include companies across various sectors. Developer tool companies like Zed, Replit, Codeium, and Sourcegraph have implemented MCP servers to allow AI assistants to access their functionality. Financial services company Block (formerly Square) has also been exploring MCP integration for their enterprise systems. How MCP Servers Provide Better Data Access Experiences The traditional API approach requires human developers to write code that calls specific endpoints, parses the returned data, and presents it in a human-readable format. MCP fundamentally changes this paradigm. MCP enables several key improvements in data access: Natural language interfaces: Users can query data using conversational language rather than learning specific query syntax. Multi-tool workflows: AI systems can coordinate multiple tools in a single interaction. For example: User: "Find all customers who purchased Product X last month and create a report of their buying patterns." AI, behind the scenes, handles this as Use MCP to access customer database Filters for Product X purchases in the last month Use MCP to access purchase history Analyzes patterns using statistical tools Generates and formats a report All presented to the user in natural language Contextual awareness: MCP servers can provide metadata about data, allowing AI to understand relationships, constraints, and semantics. Stateful interactions: Unlike stateless REST APIs, MCP connections can maintain session context, enabling conversations about data that evolve over time. While M

May 6, 2025 - 19:27

Beyond Traditional APIs: The Rise of MCP and A2A in the AI Revolution

The architecture of business technology stands at a pivotal moment of change, one that few organisations have fully recognised.

The traditional public API, for a long time the bedrock of modern software integration, is finding its dominance challenged. As AI transforms business operations, two emerging protocols are reshaping how organisations expose their data and capabilities: the Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol.

This shift isn't merely a technical curiosity, it represents a fundamental reimagining of how businesses connect with AI systems and how these systems interact with each other. While APIs aren't disappearing, their role is being dramatically redefined. For companies seeking competitive advantage in an AI-powered future, understanding and strategically adopting these new protocols alongside traditional APIs may soon become essential.

The organisations that recognise this paradigm shift early will have a distinct advantage. Those who don't may find themselves struggling to integrate with the rapidly expanding ecosystem of AI services that speak these new languages. The question isn't whether APIs will continue to exist, it's whether they alone will be sufficient for businesses that want to thrive in the coming era of AI.

What is an MCP Server?

The Model Context Protocol (MCP) is an open standard created by Anthropic that standardises how applications provide context to large language models (LLMs). If you're familiar with traditional APIs, think of MCP as their evolution, specifically designed for the AI era.

At its core, MCP defines a client-server architecture where:

MCP Clients: These are AI models or applications that need access to external data or capabilities. They maintain 1:1 connections with servers.
MCP Servers: These are lightweight programs that expose specific capabilities through a standardised interface. They can provide access to databases, APIs, services, and other resources.

MCP servers expose three primary capabilities:

Tools: Functions that perform specific actions
Prompts: Templates for generating structured content
Resources: Data sources that can be accessed and analyzed


  // Example of creating a new MCP server
 const server = new McpServer({
    name: 'simple-greeting-server',
    version: '1.0.0',
  }, {
    capabilities: {
      tools: {},
      resources: {}
    }
  });

  // Example of registering a tool in an MCP server
  server.tool(
    'greet',                     // Tool name
    'A simple greeting tool',    // Description
    {
      name: z.string().describe('Name to greet'),  // Parameters schema
    },
    async ({ name }): Promise<CallToolResult> => {
      return {
        content: [
          {
            type: 'text',
            text: `Hello, ${name}!`,
          },
        ],
      };
    }
  );

  // Create a simple resource at a fixed URI
  server.resource(
    'greeting_resource',
    'https://example.com/greetings/default',
    { mimeType: 'text/plain' },
    async (): Promise<ReadResourceResult> => {
      return {
        contents: [
          {
            uri: 'https://example.com/greetings/default',
            text: 'Hello, world!',
          },
        ],
      };
    }
  );

The protocol also supports streaming responses, allowing for real-time interactions and progressive updates, critical for maintaining natural conversational flows with AI assistants.

Early adopters of MCP include companies across various sectors. Developer tool companies like Zed, Replit, Codeium, and Sourcegraph have implemented MCP servers to allow AI assistants to access their functionality. Financial services company Block (formerly Square) has also been exploring MCP integration for their enterprise systems.

How MCP Servers Provide Better Data Access Experiences

The traditional API approach requires human developers to write code that calls specific endpoints, parses the returned data, and presents it in a human-readable format. MCP fundamentally changes this paradigm.

MCP enables several key improvements in data access:

Natural language interfaces: Users can query data using conversational language rather than learning specific query syntax.

Multi-tool workflows: AI systems can coordinate multiple tools in a single interaction. For example:
User: "Find all customers who purchased Product X last month and create a report of their buying patterns." AI, behind the scenes, handles this as

Use MCP to access customer database
Filters for Product X purchases in the last month
Use MCP to access purchase history
Analyzes patterns using statistical tools
Generates and formats a report
All presented to the user in natural language

Contextual awareness: MCP servers can provide metadata about data, allowing AI to understand relationships, constraints, and semantics.

Stateful interactions: Unlike stateless REST APIs, MCP connections can maintain session context, enabling conversations about data that evolve over time.

While MCP servers themselves don't translate information (they simply fetch data), the AI clients accessing them can interpret and present the data in ways that make sense to humans. This separation of concerns allows businesses to focus on exposing their data correctly, while letting AI handle the interpretation and presentation layers.

Real-world examples show how this transforms user experiences. A weather MCP server might simply return raw meteorological data, but an AI accessing it through MCP can say: "It looks like you should bring an umbrella today. There's a 70% chance of rain this afternoon, with the heaviest precipitation expected around 3pm."

Enterprise ready: OAuth Implementation

For enterprise adoption, security cannot be an afterthought. Recognising this, Anthropic has implemented OAuth 2.1 as the authorisation mechanism for MCP, addressing one of the most critical concerns for businesses considering new technologies.

The OAuth 2.1 implementation in MCP offers several key security features:

Token-based authentication: Rather than sharing credentials, systems exchange secure tokens with limited lifespans.
Scope-limited access: MCP servers can restrict what resources each client can access based on granular permissions.
Delegated authorisation: Users can authorise AI systems to access specific resources without sharing their credentials.
Standardised flows: MCP adopts industry-standard OAuth flows, making integration straightforward for security teams already familiar with OAuth.

Implementation example:

// Setting up OAuth in an MCP server configuration
const server = new McpServer({
  name: 'enterprise-data-server',
  version: '1.0.0',
  auth: {
    type: 'oauth2',
    authorizationUrl: 'https://auth.enterprise.com/authorise',
    tokenUrl: 'https://auth.enterprise.com/token',
    scopes: {
      'read:data': 'Read access to enterprise data',
      'write:data': 'Write access to enterprise data'
    }
  }
});

This OAuth implementation makes MCP enterprise-ready, allowing businesses to confidently expose their data and capabilities to AI systems while maintaining strict security controls.

Introduction to the A2A Protocol

While MCP connects AI models to data and tools, the Agent-to-Agent (A2A) protocol developed by Google enables AI agents to communicate with each other. Together, they create a powerful ecosystem with new possibilities for automating complex workflows.

A2A is an open protocol enabling communication and interoperability between agentic applications, even those built on different frameworks or by different vendors. It defines:

Message formats: Standardised structures for requests, responses, and events.
Conversation management: How agents establish sessions, maintain context, and manage conversation flow.
Capability discovery: Methods for agents to learn what other agents can do.

A2A uses JSON for message exchange, with a structure that includes:

{
  "id": "msg_12345",
  "role": "user",
  "content": [
    {
      "type": "text",
      "text": "What's the status of our logistics network?"
    }
  ],
  "capabilities": [
    {
      "name": "logistics_data_access",
      "version": "1.0.0"
    }
  ]
}

While MCP enables AI-to-tool communication, A2A enables AI-to-AI communication.

How Agent-to-Agent Communication Adds Business Value

The combination of MCP and A2A protocols creates opportunities for businesses that go far beyond simply exposing APIs to AI systems. This technology stack allows your business to create AI representatives that can handle complex workflows autonomously, collaborate with other AI systems (including your customers' AI assistants), and protect your sensitive business logic while still providing valuable services.

The synergy between MCP and A2A enables several advanced capabilities:

Composite workflows, AI agents can coordinate complex multi-step processes by:

Using MCP to access various data sources and tools
Using A2A to delegate specialised tasks to other agents
Maintaining context throughout the entire workflow

Encapsulation of business logic, rather than exposing all internal APIs and processes, businesses can create AI agents that:

Understand natural language requests
Execute appropriate internal processes (via MCP)
Return relevant results
All while keeping sensitive business logic protected

Adaptive discovery, user-facing AI assistants (like Claude Desktop) can:

Discover appropriate specialised agents for specific tasks
Establish A2A communications with those agents
Translate complex user requests into actionable agent instructions
Present results back to users in natural language

This example illustrates how this might work in practice:

A user asks their AI assistant: "I need to schedule a meeting with our Tokyo team and arrange travel."

The assistant uses A2A to discover relevant specialised agents:
- An internal agent that has access to the company personnel data va MCP
- An internal agent with access to internal company documentation stored in vector databse
- An internal agent that sends notifications to internal communication tools, such as Slack or email
- An internal agent which interacts with an online calendar, eg Google Workspace
- An external agent provided by a travel partner, with access to it's own internal booking systems
The assistant delegates a task to the internal personnel agent, "Get a list of everyone in the Tokyo team"
The assistant delegates a task to the internal scheduling agent, "Find available meeting times when all Tokyo team members are available"
When the calendar agent completes it's task, it returns the options for meetings, the users assistant assess the times and selects the best options for a meeting time
The assistant then assigns a new task to the travel agent,"Find flights and hotels that align with these meeting times"
Options returned from booking agent to assistant
Assistant retrives documents that state budgets allowed for business trips and picks the best option for both financial and planning reasoning
Assistant sends 2nd task to the travel agent, instructing it to confirm the booking
Confirmation of booking is returned
Users assistant sends a 2nd task to the calendar agent, "Book the meeting for the Tokyo team and send out invites"
Because the calendar agent also has access to the notification agent through the A2A, it is able to send notifications out about the meeting
The assistant sends notification and email confirmation of the plan to the user via the notification agent

The specialised agents use MCP to interact with relevant tools and data sources

This approach adds layers of protection for businesses, as they don't need to fully expose private data or internal processes. Instead, they create purpose-built agents that handle specific tasks while maintaining appropriate security boundaries.

Conclusion: Preparing for the API Evolution

Traditional public APIs will continue to play a vital role in software integration, but MCP and A2A protocols offer specialised capabilities that address the unique needs of AI-powered systems. Forward-thinking businesses should begin exploring these protocols as complementary technologies to their existing API strategies.

Experiment with MCP server implementations alongside your existing APIs
Explore the A2A protocol for scenarios requiring agent-to-agent communications
Consider how these protocols might extend your architecture for AI-specific use cases

The future of business technology lies not in replacing existing systems, but in thoughtfully integrating AI-native experiences where they add the most value. MCP and A2A provide important building blocks for this future, and the businesses that strategically incorporate them will be well-positioned to leverage the full potential of AI in their operations and offerings.