# Agent Skills vs MCP vs Function Calling vs A2A (2026 Guide)

> Agent Skills, MCP, function calling and A2A are four different layers of the same agent stack, not four competing choices. Here is what each one actually does, the context cost of picking wrong, and a decision table you can apply to your next build.

**Source:** https://mcpplaygroundonline.com/blog/agent-skills-vs-mcp  
**Author:** Nikhil Tiwari  
**Published:** 2026-09-02  
**Updated:** 2026-09-02  
**Category:** Comparison  
**Reading time:** 14 min read

---

📖 TL;DR

-   **Agent Skills** teach an agent _how_ to do something. A folder with a SKILL.md file. No server, no auth, no runtime.
-   **MCP** gives an agent _access_ to something. A live JSON-RPC server exposing tools, resources and prompts.
-   **Function calling** is the model-level primitive underneath both. Provider-specific JSON schemas, no discovery, no transport.
-   **A2A** connects one agent to _another agent_. A horizontal link, where MCP is the vertical one.
-   Rule of thumb: **knowledge → Skill. Connectivity → MCP. One provider, one app → function calling. Cross-agent delegation → A2A.**
-   They compose. The MCP working group is now standardising [Skills over MCP](#skills-over-mcp), which merges the top two.

Table of Contents

1.  [Four Layers, Not Four Choices](#four-layers)
2.  [What Are Agent Skills?](#agent-skills)
3.  [What Is MCP?](#what-is-mcp)
4.  [What Is Function Calling?](#function-calling)
5.  [What Is A2A?](#a2a)
6.  [Agent Skills vs MCP: The Real Difference](#skills-vs-mcp)
7.  [Side-by-Side Comparison](#comparison)
8.  [When to Use Each](#when-to-use)
9.  [Skills over MCP](#skills-over-mcp)
10.  [One Real Stack, All Four](#real-stack)
11.  [Five Expensive Mistakes](#mistakes)
12.  [How to Test the MCP Layer](#testing)
13.  [FAQ](#faq)

Every week someone asks me whether **Agent Skills replace MCP**. The question is wrong, and picking the wrong one is expensive.

Wrap procedural knowledge in an MCP server and you burn context on every session. Wrap live database access in a Skill and it simply cannot reach the database.

I have shipped both. **Agent Skills vs MCP is not a versus at all** — they sit at different layers, alongside function calling and A2A.

This post gives you the one-sentence distinction for each, a decision table you can paste into a design doc, and the five mistakes I see teams make.

I also cover _Skills over MCP_, the MCP working group effort that merges the two standards. It changed how I plan agent architecture in 2026.

## Four Layers, Not Four Choices

Here is the whole argument in one table. **Each row answers a different question**, which is why teams end up shipping all four.

Layer

Answers

Shape

Runtime?

**Agent Skills**

How do I do this task?

Folder with SKILL.md

No

**MCP**

What can I reach?

JSON-RPC client/server

Yes

**Function calling**

How does the model ask?

JSON schema in the API call

Your code

**A2A**

Who else can do this?

Agent-to-agent HTTP protocol

Yes

**Function calling is the floor.** MCP standardises what sits on top of it. Skills sit above MCP as instructions. A2A sits beside all three.

## What Are Agent Skills?

An _Agent Skill_ is a folder containing a `SKILL.md` file. That is the entire required surface area.

Anthropic shipped Skills in Claude in October 2025 and **released the format as an open standard on 18 December 2025** at agentskills.io.

The frontmatter needs exactly two fields. Everything else is optional.

```
my-skill/
├── SKILL.md          # required: metadata + instructions
├── scripts/          # optional: executable code
├── references/       # optional: docs loaded on demand
└── assets/           # optional: templates, schemas
```

```
---
name: incident-postmortem
description: Write a blameless postmortem from an incident timeline.
  Use when the user mentions an outage, incident review, or RCA.
license: Apache-2.0
allowed-tools: Bash(git:*) Read
---

## Steps
1. Pull the incident timeline from the linked doc.
2. Separate trigger, contributing factors and detection gap.
3. Never name individuals. Name systems and processes.
```

The rules are tight. **`name` is max 64 characters**, lowercase alphanumerics and single hyphens, and must match the directory name.

`description` is max 1024 characters and does the real work. It is the only thing the agent sees until the skill fires.

### Progressive disclosure is the whole trick

Skills load in three stages, and this is why they are cheap.

1.  **Discovery** — only `name` and `description` load at startup, roughly 100 tokens per skill.
2.  **Activation** — the full SKILL.md body loads when a task matches. Keep it under 5,000 tokens.
3.  **Execution** — bundled scripts and reference files load only if the instructions reach for them.

**You can install fifty skills and pay almost nothing until one fires.** Try that with fifty MCP servers and your context window is gone before the first message.

**Portability check:** the same SKILL.md folder is read by Claude Code, ChatGPT and Codex, Cursor, GitHub Copilot, VS Code, Gemini CLI, JetBrains Junie, Kiro, Goose and OpenCode. Write once, run in any of them.

## What Is MCP?

The _Model Context Protocol_ is a live client-server protocol. It gives an agent access to systems it does not already have.

MCP uses **JSON-RPC 2.0 between hosts, clients and servers**. Servers expose three primitives: tools, resources and prompts.

The current revision is **2026-07-28**, which moved the base protocol to stateless, self-contained requests with per-request capability negotiation.

That matters for deployment. Stateless servers scale horizontally without sticky sessions, which the older session-bound transport required.

If MCP is new to you, start with my [guide to the Model Context Protocol](/blog/what-is-model-context-protocol) before going further.

The critical property: **an MCP server does something**. It queries Postgres, hits the Stripe API, reads a file. A Skill cannot do any of that on its own.

### The context cost nobody warns you about

Most MCP clients load **every connected server's full tool list into the system prompt at session start**. Names, descriptions and complete input schemas.

Connect eight servers with fifteen tools each and you have spent a serious chunk of the context window before the user types anything.

This is the single strongest practical argument for Skills. It is also why [tool description quality](/blog/mcp-tool-description-quality) is worth obsessing over.

Not sure how much context your MCP server is costing?

Connect it in the browser, see every tool schema the model receives, and watch a real model decide which one to call.

[Test any MCP server free →](https://mcpplaygroundonline.com/mcp-test-server) [Count your tool-schema tokens](https://mcpplaygroundonline.com/mcp-token-counter)

## What Is Function Calling?

_Function calling_ is a model capability, not a protocol. You pass JSON schemas in the API request and the model returns a structured call.

**You still write every piece of plumbing.** Execution, auth, retries, error shaping, and a new adapter for each provider you support.

There is no discovery. The model cannot ask what tools exist — you hand it the list on every request.

Function calling is the right choice when **one app talks to one provider and owns all its tools**. Adding MCP there is pure overhead.

It is the wrong choice the moment a second client needs the same tools. I unpacked the trade-offs in [MCP vs function calling vs REST APIs](/blog/mcp-vs-function-calling-vs-api-comparison).

Worth remembering: **MCP does not replace function calling**. Under the hood an MCP client still converts tools into function-calling schemas for the model.

## What Is A2A?

_A2A_ (Agent2Agent) connects agents to other agents. Google announced it in April 2025 and donated it to the Linux Foundation that June.

An agent publishes an **Agent Card** at a well-known URL describing its skills, endpoint and auth. Other agents read it to decide whether to delegate.

Note the collision: A2A uses the word "skills" for advertised agent capabilities. **Those are not Agent Skills as in SKILL.md.** Different concept, same word.

The axis is what separates them. **MCP is vertical, agent down to tools. A2A is horizontal, agent across to agents.**

Full breakdown in my [MCP vs A2A comparison](/blog/mcp-vs-a2a-agent2agent-protocol).

## Agent Skills vs MCP: The Real Difference

Strip everything else away and it comes down to one line.

**MCP gives an agent a capability it did not have. A Skill gives an agent judgment it did not have.**

Ask one question about your use case: **does the agent need to reach a system it cannot currently reach?**

Yes means MCP. The agent has no path to your warehouse, your ticketing system, your internal API.

No means a Skill. The agent already has the tools — it just does not know your process, your naming conventions, your review checklist.

### Four differences that show up in production

**Context cost.** Skills load metadata first, body on demand. MCP tool schemas load in full, up front, whether used or not.

**Operations.** A Skill is Markdown in git. An MCP server is running software with uptime, tokens, versioning and a protocol to track.

**Failure mode.** A bad Skill produces bad output you can read and fix. A broken MCP server produces timeouts, 401s and [\-32602 errors](/blog/mcp-error-32602).

**Security surface.** A Skill runs bundled scripts with your agent's permissions. An MCP server is an external system that can return prompt-injection payloads in tool results.

Neither is safe by default. **Both need review before you point an autonomous agent at them.**

⚠️ Skills are executable, not documentation

A skill can bundle scripts and declare `allowed-tools` to pre-approve them. Installing a skill from a public marketplace is closer to installing an npm package than reading a README. Audit it. [Scan your MCP server →](https://mcpplaygroundonline.com/mcp-security-scanner)

## Side-by-Side Comparison

Agent Skills

MCP

Function calling

A2A

**Provides**

Procedural knowledge

Live system access

Structured intent

Delegation

**Artifact**

SKILL.md folder

Server process

JSON schema

Agent Card + endpoint

**Context cost**

~100 tokens idle

Full schemas, always

Full schemas, always

Card only, on discovery

**Needs hosting**

No

Yes

Your app

Yes

**Cross-vendor**

Yes, 40+ clients

Yes

No, per provider

Yes

**Governance**

Open spec, agentskills.io

Linux Foundation

Each model vendor

Linux Foundation

**Best for**

Repeatable workflows

Shared integrations

Single-app tools

Multi-agent systems

## When to Use Each

### Build an Agent Skill when…

-   The task is **process and judgment**, not access — a code review checklist, a brand style guide, a postmortem format.
-   You keep pasting the same instructions into chat.
-   The agent already has the tools and just applies them wrongly.
-   You want the same behaviour across Claude Code, Codex and Cursor without maintaining three configs.
-   The knowledge changes often and non-engineers should be able to edit it.

### Build an MCP server when…

-   The agent needs **live data or a real side effect** — a query, a write, a deploy.
-   Access requires credentials the agent must not see in plaintext.
-   Multiple clients or teams need the same integration.
-   You need an audit trail of every call.
-   You are exposing your product to customers' agents. See [why your SaaS needs an MCP server](/blog/why-your-saas-needs-an-mcp-server).

### Use plain function calling when…

-   One app, one model provider, three or four tools you fully own.
-   Nothing external will ever consume those tools.
-   You want the smallest possible dependency footprint.

### Reach for A2A when…

-   Independent agents, owned by **different teams or vendors**, must hand work to each other.
-   The remote side should stay a black box, exposing outcomes rather than tools.
-   Tasks are long-running and need their own status lifecycle.

## Skills over MCP: The Two Standards Are Converging

Here is what most comparison posts miss. **MCP is absorbing skills as a first-class concept.**

The _Skills over MCP_ effort started as an interest group in February 2026 and became a full working group on 16 April 2026.

It is co-led by maintainers from Nordstrom and Anthropic, with participants from Google, GitHub, AWS, Databricks, Bloomberg and Saxo Bank.

The current direction is **SEP-2640, a Skills Extension built on MCP's existing Resources primitive**, on the Extensions Track rather than the core spec.

The practical result: an MCP server will be able to ship **both the tools and the instructions for using them**, discovered through one connection.

That is a real shift. Today you install a Postgres MCP server and separately write a Skill explaining your schema conventions.

Under the extension, the server hands over both. **Progressive disclosure, currently a Skills-only property, comes to MCP.**

It is still in review, so do not build on it yet. But it settles the strategic question — **Skills and MCP were never going to be rivals**.

MCP already has precedent for this pattern. [Tasks](/blog/mcp-tasks-extension-long-running-operations) and MCP Apps landed the same way, as opt-in extensions negotiated at initialization.

## One Real Stack, All Four

Take a support-triage agent I would actually build. Every layer earns its place.

1.  **MCP** connects it to Linear, Sentry and Postgres. That is how it reads the ticket, the stack trace and the affected rows.
2.  **An Agent Skill** holds your triage policy — severity ladder, escalation thresholds, the exact template your team expects.
3.  **Function calling** happens invisibly underneath, when the model emits the structured call your MCP client executes.
4.  **A2A** delegates anything billing-related to the finance team's agent, which owns credentials you should never hold.

Remove the Skill and the agent files sloppy, inconsistent tickets. **Remove MCP and it cannot see the incident at all.**

That asymmetry is the answer to the whole debate. They fail differently because they do different jobs.

## Five Expensive Mistakes

**1\. Wrapping documentation in an MCP server.** If the tool just returns static text, it should have been a Skill. You are paying schema tokens for a Markdown file.

**2\. Expecting a Skill to fetch live data.** A Skill has no network of its own. It can only tell the agent to use tools the agent already has.

**3\. Writing vague descriptions.** The `description` field is the entire retrieval signal. "Helps with PDFs" will never fire; naming the trigger conditions will.

**4\. Connecting every MCP server you find.** Tool schemas compound. Eight servers of marginal value can crowd out the two that matter.

**5\. Shipping either one untested.** Teams test the model and skip the tool layer. Then a renamed parameter breaks production silently. Build [MCP evals](/blog/what-is-an-mcp-eval) before you need them.

## How to Test the MCP Layer

Skills are easy to review — they are Markdown, you read them. **The MCP layer is where things break quietly.**

I use MCP Playground for this. Paste a server URL, see every tool and schema the model would receive, then let a real model try to call them.

That last part matters. A server that passes `tools/list` can still confuse a model into never calling the right tool. Only a live model run reveals that.

Skills are Markdown. Your MCP server is production software.

Test it against Claude, GPT and Gemini in the browser — no install, no config file, no local setup.

[Test any MCP server free →](https://mcpplaygroundonline.com/mcp-test-server) [Chat with your server in Agent Studio](https://mcpplaygroundonline.com/mcp-agent-studio)

## The Decision, In One Paragraph

Ask whether the gap is knowledge or access. **Knowledge gaps are Skills. Access gaps are MCP servers.**

Keep function calling for single-app tools you own outright, and reach for A2A only when a separate team's agent owns the work.

Then test the layer that can actually fail at runtime. [Test any MCP server free →](https://mcpplaygroundonline.com/mcp-test-server)

## Frequently Asked Questions

**Do Agent Skills replace MCP?+**

No. Skills package procedural knowledge as a SKILL.md folder with no runtime; MCP is a live client-server protocol that gives an agent access to external systems. A skill cannot query a database or call an API on its own. Most production agents use both, and the MCP Skills over MCP working group is standardising a Skills Extension so one server can deliver tools and instructions together.

**Which is cheaper on context, a Skill or an MCP server?+**

A skill, by a wide margin, when idle. Skills use progressive disclosure: only the name and description load at startup, roughly 100 tokens each, and the full body loads only when the task matches. Most MCP clients load every connected server's complete tool schemas into the system prompt at session start, whether or not those tools are ever used.

**Are Agent Skills Claude-only?+**

No. Anthropic released the format as an open standard on 18 December 2025 at agentskills.io. The same SKILL.md folder is read by Claude and Claude Code, ChatGPT and Codex, Cursor, GitHub Copilot, VS Code, Gemini CLI, JetBrains Junie, AWS Kiro, Block Goose and roughly forty other clients listed on the official showcase.

**Is MCP just function calling with extra steps?+**

No, though MCP sits on top of function calling. Function calling is a model capability: you pass JSON schemas per request and write all the execution, auth and error handling yourself, per provider. MCP standardises discovery, transport, auth and execution so one server works with any MCP client. An MCP client still converts tools into function-calling schemas before sending them to the model.

**What are the required fields in a SKILL.md file?+**

Two: name and description. The name is max 64 characters, lowercase letters, numbers and single hyphens, and must match the parent directory name. The description is max 1024 characters and should state both what the skill does and when to use it. Optional fields are license, compatibility, metadata and the experimental allowed-tools.

**Are the "skills" in an A2A Agent Card the same as Agent Skills?+**

No, and the naming collision causes real confusion. A2A skills are capability advertisements inside an Agent Card, telling other agents what a remote agent can do. Agent Skills are SKILL.md folders of instructions loaded into a single agent's context. Different specs, different purposes, same English word.

**Can I test a Skill and an MCP server the same way?+**

Not really. A skill is Markdown, so review is reading it and running the agent against sample tasks. An MCP server is running software with a wire protocol, so it needs connection, handshake, tool schema and error testing against a real model. A browser tester such as MCP Playground covers the second case without any local setup.

## Related Guides

-   [What Is the Model Context Protocol (MCP)? A Developer's Guide](/blog/what-is-model-context-protocol)
-   [MCP vs Function Calling vs REST APIs: When to Use Each](/blog/mcp-vs-function-calling-vs-api-comparison)
-   [MCP vs A2A: Model Context Protocol vs Agent2Agent](/blog/mcp-vs-a2a-agent2agent-protocol)
-   [AI Agent + MCP Explained: What Every Developer Needs to Know](/blog/ai-agent-mcp-explained)
-   [What Is an MCP Agent? Tool Calling Explained](/blog/what-is-mcp-agent-tool-calling)
-   [Migrating to the 2026-07-28 Stateless MCP Spec](/blog/migrate-mcp-server-2026-07-28-stateless)
-   [What Is an MCP Eval, and Why You Need One](/blog/what-is-an-mcp-eval)

## Further Reading

-   [Official: Agent Skills Specification](https://agentskills.io/specification)
-   [Agent Skills spec and reference library on GitHub](https://github.com/agentskills/agentskills)
-   [Claude Code: Extend Claude with skills](https://code.claude.com/docs/en/skills)
-   [OpenAI Codex: Skills documentation](https://developers.openai.com/codex/skills/)
-   [Official: MCP Specification (2026-07-28)](https://modelcontextprotocol.io/specification/latest)
-   [MCP: Skills over MCP Working Group charter](https://modelcontextprotocol.io/community/working-groups/skills-over-mcp)
-   [SEP-2640: Skills Extension proposal](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2640)
-   [Official: A2A Protocol Docs](https://a2a-protocol.org/)

🤖 See which layer your agent is actually missing

Connect your MCP server in [MCP Agent Studio](/mcp-agent-studio) and watch a real model pick tools from your schemas. If it picks the right tool and still does the task wrong, you need a Skill — not another server. Works with Claude, GPT, Gemini and more. Free credits on sign-up.

## Frequently asked questions

### Do Agent Skills replace MCP?

No. Skills package procedural knowledge as a SKILL.md folder with no runtime; MCP is a live client-server protocol that gives an agent access to external systems. A skill cannot query a database or call an API on its own. Most production agents use both, and the MCP Skills over MCP working group is standardising a Skills Extension so one server can deliver tools and instructions together.

### Which is cheaper on context, a Skill or an MCP server?

A skill, by a wide margin, when idle. Skills use progressive disclosure: only the name and description load at startup, roughly 100 tokens each, and the full body loads only when the task matches. Most MCP clients load every connected server complete tool schemas into the system prompt at session start, whether or not those tools are ever used.

### Are Agent Skills Claude-only?

No. Anthropic released the format as an open standard on 18 December 2025 at agentskills.io. The same SKILL.md folder is read by Claude and Claude Code, ChatGPT and Codex, Cursor, GitHub Copilot, VS Code, Gemini CLI, JetBrains Junie, AWS Kiro, Block Goose and roughly forty other clients listed on the official showcase.

### Is MCP just function calling with extra steps?

No, though MCP sits on top of function calling. Function calling is a model capability: you pass JSON schemas per request and write all the execution, auth and error handling yourself, per provider. MCP standardises discovery, transport, auth and execution so one server works with any MCP client. An MCP client still converts tools into function-calling schemas before sending them to the model.

### What are the required fields in a SKILL.md file?

Two: name and description. The name is max 64 characters, lowercase letters, numbers and single hyphens, and must match the parent directory name. The description is max 1024 characters and should state both what the skill does and when to use it. Optional fields are license, compatibility, metadata and the experimental allowed-tools.

### Are the skills in an A2A Agent Card the same as Agent Skills?

No, and the naming collision causes real confusion. A2A skills are capability advertisements inside an Agent Card, telling other agents what a remote agent can do. Agent Skills are SKILL.md folders of instructions loaded into a single agent context. Different specs, different purposes, same English word.

### Can I test a Skill and an MCP server the same way?

Not really. A skill is Markdown, so review is reading it and running the agent against sample tasks. An MCP server is running software with a wire protocol, so it needs connection, handshake, tool schema and error testing against a real model. A browser tester such as MCP Playground covers the second case without any local setup.


---

_Canonical page: https://mcpplaygroundonline.com/blog/agent-skills-vs-mcp — MCP Playground (mcpplaygroundonline.com), the free browser-based tool for testing MCP servers and building AI agents._