Agent Skills vs MCP: what's the difference?
If you're deciding between agent skills vs MCP, the honest answer is: you probably want both. The confusion is understandable — both extend what an agent can do, both come from Anthropic's ecosystem, and both show up in the same setup guides. But skill vs MCP is not a versus at all. Agent Skills package expertise (the how-to), while MCP (Model Context Protocol) packages connectivity (the access). One teaches the agent a procedure; the other hands it the tools. This page draws the line clearly, then shows how they work together.
What each one is
The fastest way to stop confusing them is to separate know-how from connectivity. A skill tells the agent *what to do and how*. MCP gives the agent *the means to reach external systems*. They live at different layers, so comparing them as rivals is a category error.
Agent Skills (SKILL.md)
An Agent Skill is packaged expertise. Concretely, it's a folder containing a SKILL.md file — YAML frontmatter with a required name and description, plus a markdown body — and optionally bundled reference files and executable scripts. Anthropic describes skills as "organized folders of instructions, scripts, and resources that agents can discover and load dynamically."
The key mechanism is progressive disclosure, which keeps context cheap:
- Level 1 — metadata: the
name+description(~100 tokens per skill) are always loaded at startup. You can install many skills without a context penalty. - Level 2 — body: the full
SKILL.md(under ~5k tokens) is read into context only when the skill is triggered. - Level 3 — resources: bundled files and scripts load only when accessed — effectively unlimited, consuming zero tokens until used. Script *code* never enters context; only its output does.
So a skill is a playbook the model reads on demand. It encodes workflows, domain standards, and best practices — "format Excel reports with these formulas," "always filter our database by date range first."
MCP (Model Context Protocol)
MCP is packaged connectivity. It's an open standard Anthropic introduced on November 25, 2024 to solve the N×M integration problem — the mess of writing a custom connector for every model-to-tool pairing. The official framing: MCP is "a USB-C port for AI applications," a universal connector between any model and any tool.
Architecturally, MCP is client-server. A host application (an IDE, chat app, or agent runtime) embeds an MCP client that opens connections to one or more MCP servers, exchanging JSON-RPC 2.0 messages. Each server exposes three primitives:
- Tools — executable functions the runtime can call (usually gated by user approval).
- Resources — file-like data and context the client can read (files, API responses).
- Prompts — reusable templates.
Servers run locally as a subprocess over stdio, or remotely over HTTP (the current spec uses Streamable HTTP; the older HTTP+SSE transport is deprecated). MCP is a wire protocol for capability discovery and invocation at runtime — not a natural-language instruction format. Adoption went near-universal through 2025 (OpenAI, Google, and Microsoft all adopted it; 10,000+ public servers by late 2025), and in December 2025 Anthropic donated MCP to the Linux Foundation's Agentic AI Foundation.
Skill vs MCP at a glance
| Dimension | Agent Skills (SKILL.md) | MCP |
|---|---|---|
| What it is | Instructions / know-how — packaged expertise the model reads | Connectivity / tools — an open protocol giving access to systems |
| Mechanism | Markdown + optional scripts read into context via progressive disclosure | Client-server protocol; servers expose tools, resources, prompts |
| Execution | Model reads and follows the instructions; bundled scripts run on the host | Runtime calls an MCP server's tools and reads back results |
| Best for | Teaching workflows, standards, and procedures | Connecting to databases, APIs, SaaS, and files |
| Context cost | On-demand — near zero until triggered (metadata ~100 tokens each) | Tool definitions registered up front and counted while connected |
The last row is the sharpest technical contrast. Skills defer context via the filesystem — nothing but a one-line description is loaded until the skill fires. MCP registers tool definitions (name, description, input schema) with the model when a server connects, and those definitions count against the window for as long as the connection is live. (Anthropic's "code execution with MCP" work specifically targets reducing that tool-definition overhead.)
When to use which
A simple decision guide:
- Need to reach an external system? Use MCP. Google Drive, Slack, GitHub, a Postgres database, local files, your IDE — anything the agent must connect to and act on lives behind an MCP server.
- Need to teach a procedure or standard? Use a skill. "Here's how we write release notes," "here's our report format," "query the API this way first" — that's a
SKILL.md. - Do you have a tool the agent keeps misusing? That's a skill problem, not a connectivity problem. The connection works; the agent needs the playbook.
- Building an MCP server for others? Ship a companion skill that teaches agents how to use it well.
Rule of thumb: need connectivity → MCP; need to teach an approach → skill.
Use them together
The most capable setups use both, because a skill can describe a workflow that calls MCP tools. MCP is the hands; the skill is the playbook that drives them.
Concrete example — a release-notes skill. The SKILL.md encodes your process:
```markdown
name: release-notes description: Draft release notes from merged PRs since the last tag.
Steps
1. Use the GitHub MCP server to list merged PRs since the last release tag. 2. Group them by label: Features, Fixes, Breaking. 3. Write each entry in past tense, one line, linking the PR. 4. Put Breaking changes first with a migration note.
Here the **skill** supplies the domain expertise — grouping rules, tone, ordering, the migration-note convention. The **GitHub MCP server** supplies connectivity — the actual `list_pull_requests` tool the runtime calls to fetch real data. Neither replaces the other. Strip the MCP server and the skill has no data; strip the skill and the agent has raw PRs but no idea how you want them shaped.
Anthropic states the relationship directly: "MCP connects Claude to data; Skills teach Claude what to do with that data." Use both together — MCP for connectivity, Skills for procedural knowledge.
One shared caution: install skills **only from trusted sources**. A malicious `SKILL.md` or bundled script can direct the agent to misuse tools or exfiltrate data — and that risk is amplified precisely because a skill often orchestrates MCP-provided hands. Treat installing a skill like installing software.
## Keep reading
- [Agent Skills pillar](/learn/agent-skills-and-skill-md) — the full guide to skills and `SKILL.md`.
- [What are agent skills](/learn/what-are-agent-skills) — the concept from the ground up.
- [SKILL.md vs CLAUDE.md vs AGENTS.md](/learn/skill-md-vs-claude-md-vs-agents-md) — how the instruction files differ.
Ready to build the know-how half of your stack? [Browse skills](/browse) for ready-made expertise, or open the [Skill Builder](/create) to package your own.