Agent Skills or MCP — which to choose and how they really differ

Open a fresh session with your agent and look at how much context is already spent before you type a single word. With a few MCP servers connected, it can be tens of thousands of tokens: every server lays out descriptions of all its tools up front, whether today's task needs them or not.

Now look at your skills folder. Twenty skills, twenty one-line descriptions. The rest loads only if a task matches.

That asymmetry is what started the whole "skills vs MCP" argument. Except the argument is fake: they solve different problems. Let's lay out which.

The difference in one paragraph

MCP (Model Context Protocol) is a connection protocol. A running server gives the agent a live link to an external system: a database, a tracker, a browser, a mailbox. The agent calls a tool and the server goes and does it.

An Agent Skill is a folder with instructions (SKILL.md, optionally scripts and references). No process, no network. The agent reads it and follows it.

The short formula that holds up almost everywhere:

MCP gives the agent the ability to do something. A skill gives it the knowledge of how it's done properly.

On the criteria that actually decide it

• What you get. MCP: access to a system and fresh data. Skill: a procedure — order of steps, format, prohibitions.
• Context cost. MCP loads tool schemas at session start; the more servers, the less room for your actual task. A skill costs one line of description until it fires.
• What it takes to run. MCP: a process — local (started on your machine) or remote over HTTP, often with auth and keys. A skill: a text file in the repository, nothing to launch.
• Who's behind it. Both are open standards, not one vendor's feature. MCP was donated in December 2025 to the Agentic AI Foundation under the Linux Foundation (co-founded by Anthropic, Block and OpenAI), and there are already more than ten thousand public servers. Skills have their own open spec, and SKILL.md is read by several tools.
• How they break. MCP: the server didn't start, the token expired, the network died. A skill: it never fired, because the description didn't match your phrasing.
• Live data. MCP sees the current state of a system. A skill only knows what's written in it — it goes stale exactly like documentation.

Who should pick what — no fence-sitting

Take MCP when the agent needs to get somewhere. Read tickets in a tracker, run a database query, open a page in a browser, create a pull request. Anything needing outside data or an action in someone else's system is tool use — that's MCP.

Take a skill when the agent can already do it but not your way. It can write code — it just doesn't know your folder structure. It can cut a release — it just skips your checklist. That's missing knowledge, not missing access.

Take both when the task reads "go there and do it our way." The classic pairing: an MCP tracker server fetches the ticket, a skill describes how to turn it into a branch, a commit and a pull request. The server covers "from where", the skill covers "how".

The common mistake: MCP where a folder would do

The temptation makes sense — MCP looks more serious. But there's a daily price.

A server has to be started, updated, watched for expired keys and crashes. And its tool schemas sit in context the whole session, even on days you never touch them. Three or four unnecessary servers and the agent noticeably dulls on long tasks: room that could have held your code is filled with descriptions of buttons nobody pressed.

Test yourself with one question: do I need data the agent doesn't have? If the answer is "no, it can see everything, it just does it wrong" — the server is dead weight and what you need is instructions. You can write them in an evening: how to write an Agent Skill.

Will skills replace MCP?

No. A text file physically cannot go fetch yesterday's orders from a database. They live at different layers: the protocol handles the connection, the skill handles the procedure. "MCP is dead" headlines show up every six months and fail to come true every six months.

Which is cheaper in tokens?

The skill, almost always, because it costs one line until it fires. But the comparison is only fair at equal tasks: if you need live data, a "cheap" skill simply won't bring it, however frugal it is.

Where should I start if I'm just experimenting?

With a skill. It needs no process, no keys, no network debugging: create a folder, write a file, test it. Add MCP when you hit a concrete wall — the agent needs data it doesn't have.