Claude Skills vs Agents vs MCP: What's the Difference?

Claude Skills, agents, and MCP solve three different problems: a Skill is know-how, MCP is access, and an agent is the worker that uses both. A Skill teaches Claude how to do a task your way. MCP connects Claude to external tools and data. An agent is an LLM using tools in a loop. They compose rather than compete: one agent uses both at once.

The one-line version

• Skill: how to do a task. A folder of instructions (a SKILL.md file plus optional scripts) that Claude loads only when a request matches it.
• MCP: access to a task's tools and data. A protocol and servers that connect Claude to systems it can't otherwise reach.
• Agent: the doer. An LLM that plans and acts in a loop, using whatever Skills and MCP connections are available.

If you remember one thing: MCP gets Claude to the data, a Skill tells Claude what to do with it, and the agent is the thing running the loop. That framing is Anthropic's own, and it's the fastest way to stop conflating the three.

Skills vs agents vs MCP, side by side

What each one actually is

A Claude Skill is procedural knowledge stored as files. Claude reads a Skill's one-line description at startup, then pulls the full instructions into context only when a task calls for them. Anthropic shipped Skills in October 2025 and published the SKILL.md format as an open standard that December. A Skill doesn't think or plan on its own; it's a runbook Claude follows. Our best Claude Skills roundup and the record-a-skill walkthrough both cover Skills you can use or build without writing much code.

An agent is, in Anthropic's words, an LLM autonomously using tools in a loop. It takes a goal, plans, calls tools, reads the results, and adjusts, over and over, until the job is done. Anthropic draws a useful line here: a workflow runs LLMs and tools through predefined code paths, while an agent dynamically directs its own process. In the Claude Code world you'll also hear subagent, which is a narrower thing: a separate Claude instance with its own context and tools that you delegate a side task to so your main thread stays clean. Either way, the agent is the actor. Skills and MCP are things it uses.

MCP (the Model Context Protocol) is an open standard Anthropic introduced in November 2024 for connecting AI applications to external systems. It exposes tools that let Claude read data, call APIs, and act on outside services. MCP doesn't tell Claude the right way to use those tools for your workflow; that's a Skill's job. MCP is the plumbing that makes the connection exist. It has since been adopted well beyond Anthropic, the same open-standard pattern as llms.txt, and Anthropic reports MCP passed 400 million monthly SDK downloads by mid-2026.

How they fit together

The three compose. A realistic setup: an agent is asked to produce your monthly revenue report. It uses MCP to reach your CRM and pull the raw numbers, then loads a Skill that encodes your team's cleaning steps, the metrics you care about, and your house report format. MCP supplied the access. The Skill supplied the procedure. The agent ran the loop that stitched them into a finished document.

Because they solve different problems, "Skills vs MCP" is usually the wrong question. You rarely choose between them:

• Claude doesn't know how you want a task done → write a Skill.
• Claude can't reach the system the task needs → add an MCP connection.
• You want the whole job done without babysitting each step → that's the agent doing its thing, using both of the above.

What changed with MCP in 2026

If you read an older MCP explainer, one detail is now wrong: MCP used to be a stateful, session-based protocol. The 2026-07-28 spec (the fifth spec release) changed that. In the spec's own words, "MCP moves from a bidirectional stateful protocol to a request/response model." Concretely:

• The initialize handshake and the Mcp-Session-Id header are gone. Each request is self-describing, so a server can sit behind a plain load balancer and run on serverless or edge infrastructure.
• A versioned extensions framework now carries capabilities that used to require core changes, including MCP Apps (interactive UIs rendered inside a conversation) and Tasks (a poll-based path for reliable long-running work via tasks/get and tasks/update).
• Authorization was hardened to align with production OAuth 2.0 / OIDC, so MCP servers can plug into enterprise identity systems like Microsoft Entra and Okta without workarounds.

None of that changes the mental model. MCP is still access, and a Skill is still procedure. But if you're describing MCP in 2026, call it stateless, not session-based.

Which one do you need?

Match the tool to the failure you're hitting:

• You keep re-explaining the same process to Claude. Write a Skill. Encode it once and it loads automatically every time a task matches.
• Claude can't see or touch the system you need. Add MCP. That's what it exists for.
• You want a goal handled end to end, not step by step. You're describing an agent. Give it the Skills and MCP connections it needs, then let it run the loop.

The trap is treating these as three options for one job. They're three parts of one system: the agent decides, MCP connects, and the Skill standardizes. Build the piece that fixes your actual bottleneck, and add the others when the work demands them.