The fastest way to get confused about agent skills is to treat every agent extension as a "tool." In real systems, several different layers are being mixed together: instructions, reusable workflows, executable functions, external servers, contextual resources, and templates. They can cooperate, but they should not be collapsed into one word.
"open-source standard for connecting AI applications to external systems" Model Context Protocol introduction
The short version
| Layer | What it is | Who controls it | Best use |
|---|---|---|---|
| Prompt | One-off instruction text placed into a conversation or system context. | User, developer, or host application. | Conversation-specific behavior and small preference changes. |
| Agent skill | A reusable folder centered on SKILL.md, with optional scripts, references, and assets. | Skill author, installed into a skills-compatible client. | Repeatable procedures, domain craft, project workflows, output standards, and validation loops. |
| Tool | An executable function the model can request or the host can call. | Host or tool provider, subject to user approval and runtime policy. | Actions: search, file operations, API calls, calculations, deployments, and data mutation. |
| MCP server | A program exposing capabilities to an MCP client through the protocol. | Server implementor and MCP host/client configuration. | Connecting AI apps to external systems through a standard client-server contract. |
| MCP resource | URI-addressed context data exposed by a server. | MCP server and host application. | Files, database schemas, records, docs, and other context that should be read rather than executed. |
| MCP prompt | A reusable template or workflow exposed by a server. | MCP server; usually selected by a user or application surface. | Reusable interaction patterns attached to an integration. |
Why skills are not just prompts
A prompt is text in a context window. A skill is a file-backed package that can survive across sessions, hold supporting files, and be discovered by metadata before the full instructions are loaded. That matters for teams. A brand-writing skill, a release-gating skill, or an MCP-server design skill can encode a living procedure without asking every user to paste the same guidance into every conversation.
The distinction is not about magic. When activated, a skill still becomes instructions the model can read and follow. The difference is operational: the skill can be installed, versioned, distributed, tested, and split into references or scripts. It is closer to a compact onboarding packet for an agent than a single message.
Why tools are not skills
A tool is an action surface. It lets the agent call a function, query an API, mutate a file, or ask a server for data. A skill can tell the agent which tools to prefer, how to sequence them, how to validate results, and what failure modes matter. The tool performs the operation; the skill teaches the agent how to carry the work through.
This difference is visible in MCP. MCP tools include names, descriptions, input schemas, and
optionally output schemas. Hosts discover tools through tools/list and invoke them
with tools/call. A skill might explain that a deployment workflow must run a build,
check generated artifacts, deploy through a particular command, and curl the live URL. The skill
is the procedure. The commands and APIs are the tools.
Why MCP is not a skill format
MCP is a protocol. It specifies how a host application, client, and server exchange capabilities and context using JSON-RPC messages. Agent Skills are an authoring and packaging format. A skill can teach an agent to build an MCP server, test an MCP server, or decide which MCP server to use, but the skill is not itself the MCP connection.
Conversely, MCP can expose resources and prompts that feel skill-like because they contain knowledge or reusable interaction patterns. The boundary is still useful. MCP resources and prompts are served over a protocol by an integration. Skills live as capability packages in an agent client and can include procedural instructions, references, scripts, and templates.
Where the overlap is real
Real agents blur boundaries. A skill can include a script. A script can call an API. An MCP server can expose prompt templates. A host can use progressive tool discovery so it does not stuff hundreds of tool schemas into the context window. These are not contradictions; they are composition points.
Teaches the workflow: when to use it, what to read, what to run, and what output counts as good.
Standardizes the connection to external systems: servers expose tools, resources, and prompts.
Performs the action: query, write, compute, deploy, transform, or retrieve.
A decision rule
If the agent needs to remember a repeatable way of working, write a skill. If it needs to take an action, expose a tool. If the action or data source should be reachable across hosts through a protocol, build or connect an MCP server. If the problem is a one-off instruction for this conversation, use a prompt.
The useful stack is therefore not "skills versus MCP." It is skills plus MCP: portable procedure on top of standardized context and action surfaces.