Rupa Tiwari

Posted on Sep 2 Originally published at mcpplaygroundonline.com

Agent Skills vs MCP vs Function Calling vs A2A: When to Use Each

#mcp #agents #ai #llm

📖 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, which merges the top two.

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 keep seeing.

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.

Optional fields are license, compatibility, metadata, and the experimental allowed-tools.

Progressive disclosure is the whole trick

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

Discovery — only name and description load at startup, roughly 100 tokens per skill.
Activation — the full SKILL.md body loads when a task matches. Keep it under 5,000 tokens.
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, AWS Kiro, Block 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.

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 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.

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.

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.

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.

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.

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.

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 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.

MCP connects it to Linear, Sentry and Postgres. That is how it reads the ticket, the stack trace and the affected rows.
An Agent Skill holds your triage policy — severity ladder, escalation thresholds, the exact template your team expects.
Function calling happens invisibly underneath, when the model emits the structured call your MCP client executes.
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.

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.

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.

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 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.

DEV Community