The enterprise AI agent landscape has converged around a two-layer protocol stack: MCP (Model Context Protocol) for agent-to-tool connections and A2A (Agent-to-Agent Protocol) for inter-agent communication. What began as a fragmented "protocol war" in early 2025 has rapidly consolidated. IBM's competing ACP merged into A2A in August 2025, and in December 2025 the Linux Foundation launched the Agentic AI Foundation (AAIF) — co-founded by OpenAI, Anthropic, Google, Microsoft, AWS, and Block — to provide vendor-neutral governance over both protocols.[5][6]
The adoption numbers are striking. MCP has crossed 97 million monthly SDK downloads (Python + TypeScript combined) with over 5,800 MCP servers in public registries as of March 2026.[3] A2A has attracted over 150 supporting organizations, including every major hyperscaler, and is now integrated into Salesforce Agentforce, Microsoft Copilot Studio, SAP Joule, and Google Vertex AI.[4][7][8]
However, the "protocol polyglot problem" the idea file describes is real. MCP and A2A operate at different architectural layers — they are complementary, not competing — but enterprises must implement both to achieve full agent interoperability. Tooling support is uneven: CrewAI leads on integrated MCP+A2A support, while LangChain requires adapters and many internal frameworks have no A2A support at all.[9] Security remains a concern, with MCP facing documented prompt injection and remote code execution vulnerabilities.[2]
The market context amplifies the urgency. Gartner predicts 40% of enterprise applications will embed task-specific AI agents by end of 2026, up from less than 5% in 2025. Yet Gartner also predicts over 40% of agentic AI projects will be canceled by end of 2027 due to escalating costs, unclear business value, or inadequate risk controls.[11][13] Protocol architecture decisions made now will determine which projects survive.
This brief synthesizes findings from 17 sources gathered via 8 web searches and 3 full-page fetches conducted on March 13, 2026. Searches covered: protocol landscape overviews, enterprise adoption data, vendor-specific implementations, analyst forecasts, security critiques, framework integration, and standards governance.
Sources span April 2025 (A2A launch) through March 2026 (current MCP adoption data). The heaviest concentration of evidence falls in Q4 2025 through Q1 2026, reflecting the rapid consolidation of the protocol landscape following the AAIF formation.
The emerging consensus architecture positions agent protocols in a three-layer stack:[3]
| Layer | Protocol | Function | Analogy |
|---|---|---|---|
| Layer 3 — Agent Coordination | A2A | Agent discovery, task delegation, state sync between agents | HTTP between microservices |
| Layer 2 — Tool Access | MCP | Agent connection to tools, APIs, databases, file systems | USB-C / device drivers |
| Layer 1 — Web Access | WebMCP (emerging) | Structured web access for agents | Browser rendering engine |
A nascent "Layer 4" is also forming around agent-to-user protocols (Google's A2UI and CopilotKit's AG-UI) and domain-specific protocols for commerce (UCP) and payments (AP2), but these are not yet mature enough to factor into enterprise architecture decisions.[2]
Developed by Anthropic in late 2024 and donated to the Linux Foundation in December 2025, MCP standardizes how an AI agent connects to external tools, data sources, and services.[12] It solved the fundamental M×N integration problem — before MCP, 10 models connecting to 100 tools required 1,000 custom integrations.[9]
Transport mechanisms:
Adoption footprint: Built-in support in Claude Desktop, VS Code, Cursor, Windsurf, Zed, JetBrains IDEs. Official servers for GitHub, Slack, PostgreSQL, Google Drive, Stripe, AWS, Jira, Linear, Notion.[3] Every major AI provider (Anthropic, OpenAI, Google, Microsoft, Amazon) has adopted MCP.[3]
Released by Google in April 2025 and donated to the Linux Foundation in June 2025, A2A addresses multi-agent collaboration — agent discovery, task delegation, state synchronization, and authentication between agents.[4]
Core components:
| Capability | MCP | A2A |
|---|---|---|
| Primary purpose | Agent connects to tools/data | Agent communicates with agents |
| Discovery | Manual configuration | Automatic via Agent Cards at well-known URLs |
| Task tracking | Custom implementation required | Built-in state machine |
| Async handling | Bespoke webhooks | Standardized push notifications |
| Agent substitution | Requires rewriting integrations | URL change maintains interface |
| Communication model | Client-server (agent is client) | Peer-to-peer between agents |
| Transport | stdio / SSE / Streamable HTTP | JSON-RPC over HTTPS + SSE |
| Governance | Linux Foundation (AAIF) | Linux Foundation (AAIF) |
| SDK downloads (monthly) | 97M+ | Not publicly reported |
IBM Research launched the Agent Communication Protocol (ACP) in March 2025 to power its BeeAI Platform, an open-source agent interpretability platform. ACP used a client-server model with REST-based communication and passive YAML-based agent discovery — architecturally simpler than A2A's peer-to-peer approach.[6][10]
In August 2025, IBM announced ACP's merger into A2A under the Linux Foundation. Kate Blair, Director of Incubation for IBM Research, joined the A2A Technical Steering Committee alongside representatives from Google, Microsoft, AWS, Cisco, Salesforce, ServiceNow, and SAP.[6] BeeAI agents are now A2A-compliant via adapter patterns.
In December 2025, the Linux Foundation established the Agentic AI Foundation (AAIF) to provide vendor-neutral oversight of both MCP and A2A. Co-founders include OpenAI, Anthropic, Google, Microsoft, AWS, and Block.[5] This institutional backing significantly reduces the protocol fragmentation risk for enterprises — both protocols now have the same governance body, making future convergence or interoperability work more likely.
| Protocol | Originator | Status (March 2026) | Enterprise Relevance |
|---|---|---|---|
| UTCP | Independent | Niche; advocates simpler approach than MCP | Low — limited adoption |
| ANP (Agent Network Protocol) | Independent | Explores "internet of agents" with W3C DIDs | Future watch — relevant for cross-org agent networks |
| NLIP | Ecma International | Introduced January 2026; uses natural language | Low — "not nearly as mature"[2] |
| AG-UI | CopilotKit | Agent-to-frontend protocol | Medium — complementary to MCP/A2A for UI |
| Platform | MCP Support | A2A Support | Notes |
|---|---|---|---|
| Salesforce Agentforce | Native MCP client (pilot July 2025); enterprise MCP server registry | Yes — agent-to-agent via A2A | Also has its own "Agentforce Context Protocol"[7] |
| Microsoft Copilot Studio | MCP Connector available; first-class across Windows 11, GitHub | Yes — "Connected Agents" via A2A (Build 2025) | Azure AI Foundry also supports both[8][14] |
| Google Vertex AI / ADK | Yes | Yes — originator of A2A | A2A v0.3 released with enterprise stability focus[4] |
| AWS (Bedrock / SageMaker) | Yes — official MCP servers | Yes — AAIF co-founder | Published A2A integration blog series[5] |
| SAP Joule | Via platform connectors | Yes — wired A2A into AI assistant | TSC member[4] |
| ServiceNow | Via MCP servers | Yes — early A2A supporter | TSC member |
| Framework | MCP Support | A2A Support | Integration Quality |
|---|---|---|---|
| CrewAI | Deep — inline MCP server declaration, auto lifecycle management | Yes | Best-in-class integrated support for both[9] |
| LangChain / LangGraph | Via official adapters | Via LangSmith | Functional but requires adapter setup |
| OpenAI Agents SDK | Yes | Limited | MCP-first approach |
| Google ADK | Yes | Yes | Native for both |
| BeeAI (IBM) | Via MCP servers | Yes — migrated from ACP | A2A via adapter pattern[6] |
In April 2025, security researchers identified multiple outstanding security issues with MCP:[2][15]
Enterprises deploying MCP at scale report gaps the protocol does not yet address:[15]
A2A has received significantly less security scrutiny than MCP. No independent security audits are publicly available as of March 2026. The protocol specifies HTTPS transport and supports authentication, but production hardening at enterprise scale is largely untested in public case studies. This is a notable gap in the evidence base.
To address these gaps, a category of "MCP Gateways" is emerging — centralized proxy layers that add authentication, RBAC, rate limiting, audit logging, and cost controls on top of raw MCP connections. These gateways sit between agents and MCP servers, similar to API gateways in microservice architectures.[15]
| Prediction | Source | Timeframe |
|---|---|---|
| 40% of enterprise apps will embed task-specific AI agents | Gartner[11] | End of 2026 |
| Over 40% of agentic AI projects will be canceled | Gartner[13] | End of 2027 |
| 1/3 of agentic implementations will combine multi-skill agents | Gartner | By 2027 |
| Agentic AI spending overtakes chatbot/assistant spending | Gartner[16] | 2027 |
| Agentic AI grows at 119% CAGR to $752.7B | Gartner[16] | By 2029 |
| 60% of brands will use agentic AI for 1:1 interactions | Gartner | By 2028 |
| Agentic AI could drive ~30% of enterprise software revenue (~$450B) | Gartner (best case) | By 2035 |
The juxtaposition of Gartner's two forecasts — 40% of apps embedding agents by end of 2026, but 40% of agentic projects canceled by end of 2027 — suggests a cycle of rapid adoption followed by significant winnowing. The implication for protocol architecture: enterprises that invest in standardized, vendor-neutral protocol foundations (MCP + A2A under AAIF governance) are better positioned to survive the winnowing than those building on proprietary agent communication patterns. The cancellation wave will disproportionately hit projects with high integration costs and vendor lock-in.
1. Implement MCP first, A2A second. MCP is more mature (97M+ monthly downloads, 5,800+ servers), has broader framework support, and delivers immediate value by standardizing tool access. A2A matters when you need multi-agent coordination, which most enterprises are not yet doing in production. Start with MCP to solve the tool integration problem today; add A2A when your agent count warrants inter-agent communication.[3]
2. Deploy an MCP gateway before scaling. Raw MCP connections in enterprise environments create security and governance gaps (no RBAC, no audit trail, no rate limiting). An MCP gateway layer is now as essential as an API gateway is for microservices. Evaluate emerging gateway solutions before connecting agents to sensitive internal systems.[15]
3. Choose frameworks with dual-protocol support. CrewAI currently offers the deepest integrated MCP+A2A support. If your enterprise standardizes on a framework today, dual-protocol capability should be a selection criterion — even if you only use MCP initially. Retrofitting A2A support into a framework that lacks it is significantly more costly than choosing one that already has it.[9]
4. Treat AAIF governance as risk mitigation, not guarantee. Both MCP and A2A are now under the Linux Foundation's AAIF. This reduces but does not eliminate vendor lock-in risk. Monitor AAIF's Technical Steering Committee decisions and contribution patterns. If one vendor dominates commits or direction, the "vendor-neutral" label may not hold.[5]
5. Run a "Protocol Risk Audit" before committing. Five questions every enterprise architect should answer before finalizing agent protocol architecture:
6. Budget for the cancellation wave. With Gartner predicting 40% of agentic AI projects will be canceled by end of 2027, resilient architecture matters more than speed-to-deploy. Protocol-standardized, modular agent architectures can be restructured when priorities shift; monolithic, custom-integrated agent stacks cannot.[13]