MCP vs A2A vs Agent Skills: The Complete AI Agent Protocol Stack

01. Introduction: The Three-Layer AI Agent Stack

If you've been building with AI agents in 2025–2026, you've likely encountered a growing constellation of protocols, standards, and tools. The Model Context Protocol (MCP) lets AI models access tools and data. The Agent-to-Agent Protocol (A2A) lets agents collaborate with each other. But there's a third layer that often gets overlooked: the knowledge and workflow layer — the skills, context, and institutional know-how that make agents actually productive.

This is where Agent Skills comes in — the open standard from Anthropic for packaging and sharing agent expertise. Together with MCP and A2A, Agent Skills form a complete three-layer stack for building, managing, and scaling AI agent systems. Tools like SkillKit and skills.sh have emerged to manage this layer across the fragmented agent landscape.

“MCP gives agents hands. A2A gives agents colleagues. Agent Skills give agents expertise.”

The Three-Layer Stack

Figure 1: The three-layer AI agent stack — Tools (MCP), Collaboration (A2A), Knowledge (Agent Skills)

This guide covers the current state of all three layers as of February 2026, including the latest spec changes, ecosystem growth, and how they work together in practice.

02. MCP in 2026: The Universal Tool Layer

The Model Context Protocol has had an extraordinary 12 months. What started as Anthropic's open standard for tool integration has become the de facto protocol for the entire AI industry. In December 2025, MCP was donated to the Linux Foundation's AI & Data Foundation (AAIF), co-founded by Anthropic, OpenAI, and Block — signaling that MCP is now genuinely vendor-neutral infrastructure.

Key Milestones

• Linux Foundation AAIF donation (Dec 9, 2025): MCP governance moved to the Linux Foundation, with Anthropic, OpenAI, and Block as co-founding members. This eliminated the last objection enterprises had about single-vendor lock-in.
• MCP Apps (SEP-1865): Launched January 26, 2026, MCP Apps allow servers to deliver interactive HTML-based UIs that render inside AI chat interfaces. A Kubernetes dashboard, a database query builder, or an analytics chart can now appear directly in your Claude or ChatGPT conversation.
• Server Cards (SEP-1649): A .well-known/mcp.json discovery mechanism that lets clients inspect a server's capabilities before connecting — similar to A2A's Agent Cards, but for MCP servers.
• Streamable HTTP: Replaced SSE as the primary remote transport. A single HTTP endpoint handles both requests and streaming responses, simplifying deployment and improving compatibility with proxies and load balancers.
• OAuth 2.1 + OIDC: Full authentication and authorization for remote servers, with incremental scope consent via WWW-Authenticate headers.

MCP by the Numbers

What MCP Solves

Before MCP, every AI application built its own custom integrations. A Slack integration for Claude was completely different from a Slack integration for ChatGPT. MCP standardized this: build one MCP server for Slack, and it works with every MCP-compatible host. This is the same pattern that USB brought to hardware peripherals — one connector, universal compatibility.

The protocol handles three types of capabilities: Tools (executable functions like “send email” or “query database”), Resources (read-only data like file contents or API responses), and Prompts (templated interaction patterns that guide the AI's behavior for specific tasks).

03. A2A in 2026: The Agent Collaboration Layer

While MCP handles the vertical relationship between an AI model and its tools, the Agent-to-Agent Protocol (A2A) handles the horizontal relationship between independent AI agents. Created by Google, A2A has matured significantly in 2025–2026 and is now the leading standard for multi-agent collaboration.

Key Milestones

• A2A v0.3 with gRPC: The latest specification added gRPC as an alternative transport alongside HTTP+SSE, enabling high-performance binary communication for latency-sensitive agent interactions.
• ACP merger (September 2025): The Agent Communication Protocol (ACP), a competing standard, merged into A2A, consolidating the agent collaboration space around a single protocol.
• Google ADK 1.23.0 (January 2026): The Agent Development Kit gained the Interactions API for Gemini integration, making it trivial to build A2A-compatible agents that work with Google's AI ecosystem.
• Cloud Run zero-trust deployment: Google provided turnkey infrastructure for deploying A2A agents with zero-trust security on Cloud Run, complete with IAM integration and automatic scaling.
• Gemini Deep Research: Google's research agent uses A2A internally, demonstrating that the protocol works at production scale for complex, multi-step research tasks.

How A2A Works

A2A follows a straightforward pattern. Each agent publishes an Agent Card at /.well-known/agent.json that describes its capabilities, supported input/output types, and authentication requirements. When one agent needs help from another, it discovers the remote agent's card, creates a Task, and monitors progress through streaming updates. The remote agent can request additional input, stream partial results, and eventually complete the task with structured artifacts.

A2A by the Numbers

04. The Missing Layer: Agent Skills

MCP gives agents access to tools. A2A lets agents collaborate. But neither protocol addresses a fundamental question: how does an agent know what to do?

A developer can connect their AI coding agent to a GitHub MCP server (tools) and a code review A2A agent (collaboration), but the agent still needs to know the team's coding standards, the project's architecture decisions, the preferred testing patterns, and the deployment workflow. This is the knowledge and workflow layer — and in December 2025, Anthropic formalized it as the Agent Skills open standard.

What Are Agent Skills?

Agent Skills are packaged bundles of knowledge, context, and behavior that can be installed on any compatible AI coding agent. The standard is built around SKILL.md files — markdown documents that contain structured instructions, context, and metadata that agents can consume. Think of them as “plugins for agent brains” rather than plugins for agent tools.

The SKILL.md Format

A SKILL.md file typically contains:

• Metadata: Name, version, author, description, compatible agents
• Instructions: Detailed guidelines, coding patterns, workflow steps
• Context: Background knowledge the agent needs
• Hooks: Triggers that activate the skill at specific points (e.g., before commit, after file edit)
• Commands: Slash commands that invoke specific skill behaviors

# SKILL.md example
---
name: react-best-practices
version: 1.0.0
agents: [claude-code, cursor, codex]
---

## Instructions
- Use functional components with hooks, never class components
- Prefer server components in Next.js App Router
- Use TypeScript strict mode
- Follow the project's existing naming conventions

## Hooks
- pre-commit: Run type check and lint before committing
- post-edit: Verify imports are properly organized

## Commands
- /component: Generate a new React component following team patterns
- /test: Generate tests for the current file

The skills.sh Directory

Alongside the SKILL.md standard, the community-driven skills.sh directory emerged as a central marketplace for discovering and sharing agent skills. As of February 2026, skills.sh has tracked 37,152 total installs across its skill listings, with a leaderboard showing the most popular skills by category.

The Cross-Agent Problem

The Agent Skills standard defines the format, but the AI coding agent landscape is fragmented. Claude Code uses CLAUDE.md, Cursor uses .cursorrules, Codex uses AGENTS.md — each with its own configuration syntax and file locations. A skill written for one agent won't work on another without manual conversion.

This is where skill management tools become essential. SkillKit, for example, provides a universal CLI that can translate skills across 32 different AI coding agents, install from a 15K+ skill marketplace, and manage team collaboration workflows. Other tools in the ecosystem include skills.sh for discovery, and individual agent-specific skill managers.

Figure 2: Agent skills management — CLI tools, marketplaces, translators, and multi-agent adapters

Key Capabilities of the Skills Ecosystem

05. How They Work Together

The real power of MCP, A2A, and Agent Skills emerges when you use them together. Each layer addresses a different concern, and they compose cleanly without overlap.

Figure 3: How MCP, A2A, and Agent Skills work together in a real development workflow

A Concrete Example

Imagine a developer asks their AI coding agent to “add a user authentication system to the app.” Here's how the three layers work together:

1. Agent Skills (Knowledge Layer): The agent has a “secure-auth-patterns” skill installed that provides context on the team's preferred auth approach (JWT with refresh tokens, bcrypt for passwords, Supabase Auth for the backend). The skill's hooks trigger a security review before any auth-related code is committed.
2. MCP (Tool Layer): The agent connects to a Supabase MCP server to inspect the existing database schema, a GitHub MCP server to read the project's existing code, and a documentation MCP server to pull up Supabase Auth API references.
3. A2A (Collaboration Layer): The agent delegates a security review subtask to a specialized security-review A2A agent, which analyzes the generated auth code for OWASP top-10 vulnerabilities and returns findings as structured artifacts.

Without skills, the agent might implement auth using a pattern the team doesn't prefer. Without MCP, it can't access the actual codebase or database. Without A2A, it can't get a second opinion from a specialized agent. All three layers are necessary for a complete, production-quality result.

Layer Responsibilities

06. Detailed Comparison

Here's a comprehensive side-by-side comparison of all three standards:

07. The Emerging Protocol Universe

MCP, A2A, and Agent Skills are the three established layers, but the broader protocol universe is expanding rapidly. Several emerging standards are worth watching:

Figure 4: The broader AI agent protocol ecosystem — core, emerging, and management layers

AG-UI (Agent-User Interaction Protocol)

AG-UI focuses on the frontend streaming layer — how agents communicate their state, progress, and outputs to user interfaces in real time. While MCP Apps handles UI for tool results, AG-UI standardizes the broader agent-to-frontend communication pattern, including streaming text, tool call progress, state updates, and interactive confirmations.

ANP (Agent Network Protocol)

ANP takes a broader view than A2A, aiming to create an “Internet of Agents” with decentralized identity, verifiable credentials, and network-level agent discovery. Where A2A focuses on structured task delegation between known agents, ANP envisions open-ended agent networking at internet scale.

ACP (Agent Communication Protocol)

The Agent Communication Protocol was an alternative to A2A that focused on simplicity and developer experience. In September 2025, ACP merged into A2A, consolidating the agent collaboration space. The merger brought ACP's simpler patterns into A2A while preserving A2A's richer task lifecycle model.

Agentic Commerce Protocol

An emerging standard for agent-to-agent commercial transactions — payments, SLAs, usage metering, and billing between AI agents that provide services to each other. Still early-stage, but relevant as the agent ecosystem matures toward commercial viability.

08. Getting Started

For developers looking to build with the full stack today:

Start with MCP (Tool Access)

# Install the MCP TypeScript SDK
npm install @modelcontextprotocol/sdk

# Or the Python SDK
pip install mcp

# Browse 10K+ servers at the MCP registry
# https://modelcontextprotocol.io

Add A2A (Agent Collaboration)

# Install Google ADK
pip install google-adk

# Create an A2A agent with ADK
adk create my-agent --framework a2a

# Deploy to Cloud Run with zero-trust
gcloud run deploy my-agent --source .

Layer in Agent Skills (Knowledge & Workflows)

# Create a SKILL.md in your project root
# Or install from the skills.sh directory

# Use a skill manager for cross-agent support
npx skillkit install react-best-practices

# Translate a skill to a different agent format
npx skillkit translate my-skill --agent cursor

# Browse skills interactively
npx skillkit ui

Combine All Three

The most effective approach is to start from the bottom of the stack and work up:

1. Connect your tools via MCP: Set up MCP servers for your database, code repository, documentation, and any APIs your agent needs.
2. Enable collaboration via A2A: If your workflow benefits from specialized agents (code review, security analysis, testing), set up A2A agents that your primary agent can delegate to.
3. Standardize knowledge via Agent Skills: Create SKILL.md files that encode your team's coding standards, workflows, and best practices. Use hooks to enforce quality gates. Share skills across your team with a skill manager.

09. Conclusion

The AI agent protocol stack is not a competition — it's a composition. MCP, A2A, and Agent Skills each solve a distinct problem, and together they form the complete infrastructure for building production-grade AI agent systems.

• MCP is the tool layer: 10K+ servers, 97M monthly SDK downloads, Streamable HTTP, OAuth 2.1, MCP Apps for interactive UIs, now governed by the Linux Foundation.
• A2A is the collaboration layer: Agent Cards for discovery, structured task lifecycle, gRPC support, deep Google ADK integration, enterprise adoption from Salesforce, SAP, and Atlassian.
• Agent Skills is the knowledge layer: SKILL.md standard from Anthropic, 15K+ marketplace skills, cross-agent translation for 32 agents, team collaboration, hooks, and methodology management via tools like SkillKit and skills.sh.

The future of AI agents is not about choosing between protocols — it's about composing them. The best agent systems will use MCP for tool access, A2A for collaboration, and Agent Skills for knowledge. The stack is ready. The ecosystem is growing. Build with all three layers.