Why A2A and MCP Will Transform How We Build

The future of software isn’t autonomous agents. It’s agents that know how to work together.

Something remarkable happened in April: Google released the Agent-to-Agent (A2A) protocol, with over fifty major companies already signed on as collaborators. Coming hot on the heels of Anthropic’s Model Context Protocol (MCP), this wasn’t just another technical announcement—it was a watershed moment that fundamentally reshapes how intelligent systems will function.

What makes this moment so profound isn’t the technical specifications. It’s the emergence of something I’ve seen brewing beneath the surface: Software isn’t just learning to think. It’s learning to work together.

And that changes everything about how your enterprise needs to approach AI.

The Protocol Revolution — Explained Simply

Imagine two brilliant experts: one a financial analyst, the other a customer service specialist. Now imagine they speak different languages and have no way to collaborate. That’s the current state of enterprise AI—isolated pockets of intelligence with no ability to coordinate.

What A2A and MCP do together is both revolutionary and surprisingly simple:

MCP is like giving each expert the ability to look up information and use tools. Previously, AI systems needed custom integrations for every data source or function they accessed. MCP creates a universal adapter—think of it as a “USB-C port for AI”—that standardises how models connect to external systems.

A2A goes further by enabling these experts to talk to each other, delegate tasks, and collaborate on complex problems. It’s not just about agents using tools—it’s about agents working together as a team.

Together, they form a new foundation for enterprise AI:

MCP connects agents to data and tools
A2A connects agents to other agents

This combination transforms the isolated intelligence of today into an interconnected network of specialists—what I call a “cognitive village.” Instead of trying to build one AI system that does everything, we can create specialised agents that know how to coordinate.

I’ve seen this pattern before. When Apple introduced the iPhone, skeptics questioned why anyone would want to combine a phone, internet device, and music player. Now we can’t imagine life without it. We’re at that same inflection point with AI agents—looking at a paradigm shift that most enterprises aren’t fully grasping yet.

The Pattern Break Moment

Make no mistake: we’ve crossed a threshold that fundamentally changes how software gets built.

“We’re witnessing something beautifully counterintuitive: past a certain threshold, agents begin reducing maintenance costs precisely because they’re adaptable.”

For decades, the industry mantra has been that complexity equals maintenance burden—a formula as reliable as death and taxes. But vertical agent architectures are turning this wisdom on its head. When agents can adapt, learn, and coordinate, they create exponentially improving systems rather than degrading ones.

Before the Protocol Revolution:

Isolated AI capabilities requiring custom integration
Linear processes with predetermined steps
Human orchestration of every workflow
One-to-one mapping of problems to solutions
Scale achieved through bigger models

After the Protocol Revolution:

Interconnected ecosystem of specialised intelligence
Dynamic collaboration between autonomous agents
Self-orchestrating workflows that adapt in real-time
Emergent solutions to unpredicted problems
Scale achieved through better coordination

This pattern break is already happening in cloud operations, where I’ve witnessed multi-agent systems detect anomalies, diagnose root causes, and remediate issues—all with minimal human intervention. In one implementation, this approach reduced incident volume by 71% and cut resolution time by 68%.

The most striking aspect isn’t the metrics, but the emergent behaviours. These agent systems began identifying subtle patterns no human operator had noticed—correlations between seemingly unrelated services, early warning signs that preceded major incidents, and optimisations no one had explicitly programmed.

Is your enterprise still optimising for control instead of coordination? What capabilities might emerge if your systems could talk to each other?

The Evidence Speaks

Early adoption data is already validating this shift.

ServiceNow’s involvement in A2A’s development signals how critical agent interoperability has become for workflow platforms. Meanwhile, community developers have created a ServiceNow MCP server that exposes the platform’s APIs through the protocol—allowing any MCP-compatible agent to query incidents, update tickets, and trigger workflows.

The financial impact numbers are compelling:

43% reduction in system maintenance hours after migrating from traditional RPA to vertical agent architecture
84% decrease in off-hours incidents with self-healing agent ecosystems
37% higher accuracy in complex decision tasks compared to workflow-based approaches

These aren’t theoretical projections—they’re results from early implementations.

Eclipse AI’s multi-agent systems for cloud operations have produced even more dramatic outcomes:

71% reduction in monthly incidents (from 350 to ~100)
68% decrease in resolution time (from 4.2 hours to 1.3 hours)
84% reduction in off-hours incidents
943% increase in preventative actions

What’s fascinating about these outcomes is they combine efficiency gains with a fundamental capability shift. These systems aren’t just faster—they’re solving problems in ways that weren’t possible before.

Menlo Ventures’ research indicates the most successful agent implementations share three characteristics:

Clear domain boundaries and specialisation
Robust feedback mechanisms
External memory architecture for long-term learning

This aligns perfectly with what I’ve observed: the enterprises seeing the most success aren’t trying to build “super agents” that do everything. They’re building cognitive villages of specialised agents that know how to work together.

The Leadership Imperative

For enterprise leaders, this isn’t just a technical shift—it’s a strategic imperative that demands a new mental model.

“The organizations that thrive won’t be those with the biggest models or the most data, but those that fundamentally reimagine how intelligence operates within their systems.”

The New Leadership Framework:

Shift from Tools to Teams
- Old approach: Deploy AI as isolated tools for specific tasks
- New approach: Design an ecosystem where agents collaborate across functions
Move from Control to Orchestration
- Old approach: Design rigid workflows with strict controls
- New approach: Create environments where agents can self-organize around goals
Evolve from Brittle to Adaptive
- Old approach: Optimize for predictability and consistency
- New approach: Optimize for learning and adaptation
Transform from Reactive to Proactive
- Old approach: AI systems that wait for queries or triggers
- New approach: Agents that anticipate needs and take initiative

I’ve seen firsthand how this shift creates profound ripple effects throughout organisations. Teams reorganise around agent coordination rather than direct task execution. New roles emerge focused on agent training and oversight. Performance metrics evolve to measure human-agent team effectiveness rather than individual productivity.

Crucially, this transformation requires more than just technical expertise—it demands cognitive diversity on your teams. The most successful agent implementations I’ve seen have been led by individuals who naturally think in terms of networks and relationships rather than linear sequences.

How well is your organization prepared to shift from operator to orchestrator? Are your governance models ready for systems that learn and adapt?

The Technical Roadmap

Successfully implementing A2A and MCP requires a deliberate architectural approach. Here’s the roadmap I’ve found most effective:

1. Create Your Cognitive Village Architecture

Start by mapping your agent ecosystem as a radial architecture—with agents at the centre and spokes extending to tools, knowledge bases, and other agents:

This architecture should include:

Specialisation with Clear Boundaries: Each agent must have well-defined domains of expertise
Standardised Communication Protocols: Ensure reliable information exchange between agents
Shared Knowledge Repositories: Create centralised memory architectures accessible to all agents
Authority Hierarchies: Establish clear delegation structures and escalation pathways

2. Implement the Memory Architecture Revolution

For every problem solved, store it as memory in a system outside the large language model:

"For every maths problem solved you store it as memory in a store outside of the LLM... Don't put it in a workflow, tell the agent it can store its memories in vector stores, graphs, cache tools."

This external memory architecture creates a watershed moment by mirroring human memory systems:

Vector stores for semantic knowledge
Graph databases for relational understanding
Cache systems for rapid retrieval

3. Design for Self-Improvement

The ultimate leap is teaching agents to update their own operating procedures:

"I have taught my AI agents to rebuild their own system instructions... burn-down entire CloudOps workflows and rebuild them based on knowledge graph data."

This architecture includes:

Performance monitoring mechanisms that detect when outcomes don’t match expectations
Instruction evaluation frameworks that identify which aspects need adjustment
Controlled experimentation boundaries for safe testing of alternatives

4. Common Failure Modes to Avoid

Over-constraining with workflows: Don’t force agents into rigid processes—give them guidelines and goals
Under-defining success metrics: Establish clear evaluation criteria for agent performance
Neglecting the external memory architecture: Ensure agents can store and retrieve knowledge beyond their context windows
Assuming more power equals better results: Often, constraints and specialisation lead to better outcomes than raw capabilities

I’ve learned these lessons the hard way. The most common mistake I see is organisations trying to script every agent interaction rather than creating environments where agents can discover the best way to collaborate.

Are you building workflows that constrain your agents, or frameworks that empower them to adapt and evolve?

The Decision Point

We stand at a fork in the road that will define the next decade of enterprise technology. While most organisations focus on incremental AI improvements—faster models, better prompts, slightly smoother automation—the true revolution lies in building systems that know how to work together.

The enterprises that flourish won’t be those with the most powerful individual AI systems, but those that create the most effective cognitive villages. The winners won’t be those who perfect control but those who master coordination.

As Apple showed us with the iPhone, the greatest leaps forward don’t come from perfecting existing paradigms, but from reimagining what’s possible. The companies that dominated after the iPhone’s emergence weren’t those who digitised existing services—they were the ones who created entirely new categories.

This is your chance—your moment—to define the AI future in your industry. Will you be Nokia, perfecting the existing paradigm until it’s suddenly irrelevant? Or will you be Apple, reimagining not just the technology but how we interact with it?

Don’t wait to explore these technologies until your competitors have already mastered them.

The future isn’t just about building smarter AI. It’s about building AI that knows how to collaborate—with other systems and with humans. And that might be the most important lesson of all.

Implementation Framework: Your 90-Day Plan

Weeks 1-2: Map your current AI initiatives against potential multi-agent architectures
- Identify high-value processes that involve multiple specialised domains
- Assess current integration points between AI systems
Weeks 3-4: Develop your agent ecosystem vision
- Define specialised domains and agent boundaries
- Create initial architecture for agent communication and memory
Weeks 5-8: Launch pilot project
- Select one high-value, contained process for initial implementation
- Implement basic A2A and MCP connections for proof of concept
Weeks 9-12: Measure, learn, and scale
- Establish metrics for agent performance and collaboration
- Refine based on pilot results
- Develop roadmap for expanding to additional domains

The revolution is already underway. The only question is whether you’ll lead it or follow in its wake.

About the Author:

Chris Jones is CTO of Eclipse AI, specialising in multi-agent cognitive architectures for enterprise applications. Drawing on extensive experience across software development, system architecture, and AI strategy, he brings a multidisciplinary perspective to the challenges of integrating artificial intelligence into business operations. Chris is known for bridging technical innovation with practical business transformation—creating systems that not only leverage AI capabilities but fundamentally reimagine how organisations operate.