The Tale of Two Protocols: What They Actually Do

The Tale of Two Protocols: What They Actually Do

MCP emerged from Anthropic's labs in November 2024 as an open standard for agent-tool integration. By Q1 2026, it's racked up 97M+ SDK downloads and 10,000+ public servers [1]. The protocol handles four key primitives: Tools (like search_db), Resources (files and databases), Prompts (templates), and Tasks (async operations) [3].

A2A launched from Google in April 2025 with a different mission: enabling agents to work together as peers. It's backed by 100-150 organizations including Salesforce, SAP, ServiceNow, and LangChain [2]. Where MCP is mostly stateless client-server communication, A2A manages stateful task lifecycles: queued, running, completed, failed, and input-required states [2].

The technical differences matter for builders. MCP uses progressive tool discovery through directories and enables code-based calls that reduce token usage by 98.7%—from 150,000 tokens down to 2,000 for complex operations [4]. A2A uses Agent Cards (.well-known/agent.json files) for capability discovery and supports streaming, webhooks, and multiple modalities including text, audio, and video [2].

Both protocols run on JSON-RPC, but with different transport layers. MCP operates over stdio and Streamable HTTP, while A2A works over HTTP, gRPC, and REST [3]. Security-wise, both implement OAuth 2.1 with session management, though they tackle different attack vectors—MCP focuses on confused deputy and SSRF attacks, while A2A emphasizes signed agent cards for trust verification [3].

Production Reality: What Actually Works (And What Breaks)

The cost numbers tell the real story. Simple single-agent tasks run $0.10-0.50 (1-3k tokens), while multi-agent CrewAI setups cost $0.50-2.00 (3-10k tokens). Complex AutoGen workflows can hit $2-5 per interaction (5-25k tokens)—making multi-agent systems 5-10x more expensive than single agents [6].

But the ROI can justify the costs. One insurance company reported 85-95% accuracy improvements after tuning their multi-agent case processing system [6]. Development time also varies dramatically: CrewAI implementations take about 1 week versus 3 weeks for equivalent AutoGen setups in reservation systems [6].

The failure modes are predictable but painful. Infinite loops, hallucinations, and context overload plague conversations longer than 30-45 minutes. Cost explosions happen when agents spawn sub-agents without proper controls. Latency varies wildly (1-4 seconds), and debugging AutoGen workflows remains "chaos" according to multiple production teams [6].

Memory bloat is the silent killer. Agents accumulate context until they hit token limits, then either crash or start forgetting critical information. Security issues include prompt injection, data exfiltration, and "agent sprawl" where teams lose track of what's running where [6].

The Nordic CTO Playbook: Phased Implementation Strategy

Based on our experience and conversations with Nordic engineering leaders, here's the practical rollout strategy that actually works:

Phase 1: MCP Tool Integration (2-6 weeks per tool). Start with single agents connected to your core systems—CRM, databases, Slack, GitHub. Build the MCP servers for your most critical tools first. This phase teaches you about token optimization and security boundaries without the complexity of agent coordination [7].

Phase 2: A2A Multi-Agent Coordination (4-12 weeks). Once your tools are MCP-enabled, introduce agent-to-agent workflows. Start with simple handoffs: research agent → coding agent → review agent. Use A2A's task lifecycle management to track progress and handle failures gracefully [7].

Phase 3: Commerce Layer Integration. Layer in ACP (Agent Commerce Protocol) or UCP for payment flows and external service integration. This is where you move from internal automation to customer-facing AI products [8].

The key is starting narrow with Level 2-3 autonomy. Whitelist specific tools, set maximum API calls per session, implement smart summarization to manage context, and build human-in-the-loop gates for critical decisions [6]. Monitor costs and conversation trajectories religiously—set alerts at 80% of your budget thresholds [6].

Real-World Architecture: How MCP and A2A Work Together

The most successful implementations we've seen combine both protocols strategically. A2A handles orchestration while MCP grounds agents in real-world tools. Here's what that looks like in practice:

Enterprise loan processing: Credit analysis agent (A2A) coordinates with document processing agent and risk assessment agent. Each specialist uses MCP to access credit databases, OCR services, and regulatory compliance tools [7]. The A2A layer manages handoffs and ensures all agents complete their tasks before final approval.

Sales training simulations: Customer persona agent and sales coach agent interact via A2A to create realistic scenarios. Both agents use MCP to access product databases, pricing tools, and performance analytics [7]. The A2A protocol manages the conversational flow while MCP provides real-time data access.

Support ticket resolution: Billing agent and technical agent collaborate through A2A to resolve complex customer issues. MCP connections enable direct access to billing systems, knowledge bases, and ticketing platforms [7]. The result: faster resolution with full context preservation.

The pattern is consistent: A2A delegates tasks between agents, MCP executes actions in the real world. This separation of concerns makes debugging easier and scaling more predictable.

The Governance Gap: Why Protocols Aren't Enough

Here's what the protocol evangelists won't tell you: technical standards don't solve organizational problems. MCP and A2A enable agent coordination, but they don't provide governance frameworks for approval workflows, audit trails, or compliance management [7].

Production teams need additional layers:

• Approval gates for high-impact decisions
• Audit logging for regulatory compliance
• Cost controls with automatic shutoffs
• Performance monitoring with trajectory analysis
• Security policies for data access and retention

The protocols handle the plumbing. Your judgment builds the guardrails. This is where Nordic engineering culture—with its emphasis on consensus and systematic risk management—provides a competitive advantage in AI deployment.

Smart teams are building governance layers on top of MCP/A2A rather than trying to embed controls within the protocols themselves. This separation allows for protocol upgrades without breaking compliance systems.

The Post-SaaS Future: When AI Squads Replace Software

The convergence of MCP and A2A points toward a fundamental shift in how we build and buy software. Instead of purchasing SaaS tools, organizations will deploy AI squads that can adapt to any workflow using protocol-standardized integrations [8].

Consider the implications: Why buy separate tools for project management, customer support, and sales automation when a coordinated team of AI agents can handle all three using the same underlying data and business logic? The protocols make this possible by standardizing how agents discover capabilities and coordinate work.

Nordic companies are already experimenting with this model. One logistics firm replaced their entire customer service stack with a three-agent system: intake, routing, and resolution agents coordinated via A2A and connected to legacy systems through MCP. The result: 40% cost reduction and 60% faster response times.

The shift requires different thinking about software architecture. Instead of integrating disparate SaaS tools, you're orchestrating AI capabilities. Instead of training humans on multiple interfaces, you're configuring agent behaviors. Code becomes free, but judgment becomes the differentiator.

This is why we're bullish on the protocol layer. MCP and A2A aren't just technical standards—they're the foundation for a post-SaaS economy where intelligence, not interfaces, defines software value.

Sources

1. https://www.digitalocean.com/community/tutorials/a2a-vs-mcp-ai-agent-protocols
2. https://getstream.io/blog/ai-agent-protocols
3. https://devtk.ai/en/blog/mcp-vs-a2a-comparison-2026
4. https://www.anthropic.com/engineering/code-execution-with-mcp
5. https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability
6. https://47billion.com/blog/ai-agents-in-production-frameworks-protocols-and-what-actually-works-in-2026
7. https://neomanex.com/posts/a2a-mcp-protocols
8. https://www.digitalapplied.com/blog/ai-agent-protocol-ecosystem-map-2026-mcp-a2a-acp-ucp