---
title: What is the difference between agent skills and MCP servers?
url: https://opencontroller.lyzr.com/blog/agent-skills-vs-mcp-servers
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# What is the difference between agent skills and MCP servers?

**An agent skill is a folder of instructions, scripts and reference files that an agent loads into its own context when a task needs it. An MCP server is a separate running program that gives an agent live tools, data and prompts over the Model Context Protocol. Skills change how an agent works; MCP servers change what it can reach. Most enterprises will use both, and each needs its own controls.**

People often ask whether skills replace MCP. They do not. They solve different problems and fail in different ways, so treating them as one category leads to gaps in review and inventory.

## What is an agent skill?

A skill is a directory with a `SKILL.md` file at its root. The file starts with YAML frontmatter that holds at least a `name` and a `description`, followed by markdown instructions. The folder can also hold scripts, templates and reference documents.

Skills use progressive disclosure. Anthropic's documentation describes three levels:

1. **Metadata** (name and description) is loaded at startup, roughly 100 tokens per skill.
2. **Instructions** in the body of `SKILL.md` are loaded only when the agent decides the skill is relevant.
3. **Bundled files and scripts** are read or run only when the instructions call for them.

The format started in Claude products and was published as an open standard at agentskills.io, so other agent tools can read the same folders. Because a skill can include executable scripts, the agent needs a code execution environment to use it fully.

## What is an MCP server?

An MCP server is a process that speaks the Model Context Protocol, a JSON-RPC protocol between an AI client and a server. A server can expose three kinds of capability:

- **Tools**: functions the model can call, such as "create ticket" or "run query".
- **Resources**: data the client can read, such as files or records.
- **Prompts**: templates a user can pick.

Servers run locally over stdio or remotely over Streamable HTTP. Remote servers use OAuth-based authorisation defined in the MCP specification. The server holds the connection to the real system: the database, the SaaS API, the file share.

## How do skills and MCP servers compare?

| Question | Agent skill | MCP server |
|---|---|---|
| What is it? | Files: `SKILL.md`, scripts, resources | A running service speaking MCP |
| Where does it run? | Inside the agent's context and its code sandbox | In its own process, local or remote |
| What does it change? | How the agent approaches a task | Which systems and actions the agent can reach |
| Holds credentials? | Should not, but scripts can read environment secrets | Usually yes, or uses delegated OAuth tokens |
| Main risks | Hidden instructions, malicious scripts, data sent out by scripts | Tool poisoning, excessive permissions, confused deputy, data exfiltration |
| Changes over time | When someone edits the folder | When the server code or its tool descriptions update |
| Unit of review | The folder contents, line by line | The server version, its tools and its permissions |
| Typical owner | Team that wrote the know-how | Team that owns the target system |

The short version: a skill is closer to a playbook plus helper scripts. An MCP server is closer to an integration with its own identity and access.

## When should you use a skill, and when an MCP server?

Use a **skill** when the agent already has the access it needs but lacks know-how. Examples: your brand style for documents, the steps to reconcile a report, the format your finance team expects.

Use an **MCP server** when the agent needs a live connection it does not have. Examples: reading tickets, querying a warehouse, posting to a chat tool.

Use **both** when know-how and access go together. A skill can tell the agent which MCP tools to call, in what order, and what to check before a write. That pairing is common, and it is where governance gaps appear: a skill reviewed in isolation looks harmless, while the tools it orchestrates carry the real permissions.

## How should you govern each one?

Both need an inventory, an owner and a review before use. The detail differs.

**For skills:**

1. Keep an inventory of every skill, where it is installed and who can use it.
2. Review the full folder, not just `SKILL.md`. Scripts are where data leaves.
3. Pin versions and re-review on every change.
4. Restrict who can publish skills to shared workspaces.
5. See [what agent skills governance covers](/blog/what-is-agent-skills-governance) for the full lifecycle.

**For MCP servers:**

1. Approve servers and versions through an internal allow-list.
2. Limit which tools each agent may call.
3. Scope credentials to the least access the task needs.
4. Log every tool call with the server, tool and arguments.
5. Follow the [MCP server governance guide](/blog/how-to-govern-mcp-servers) for the full control set.

The OWASP Top 10 for Agentic Applications groups both under supply-chain risk (ASI04): components an agent loads at runtime that you did not build.

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, and discovers and manages skills in Anthropic Enterprise workspaces. Opencontroller Edge extends discovery to developer devices, coding agents, skills and local MCP servers. Posture flags risky permissions and configurations, and policy as code sets which tools each agent may use. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Are agent skills a replacement for MCP?**
No. Skills add know-how and helper scripts. MCP servers add live connections to systems. A skill can tell an agent how to use MCP tools, but it cannot replace the connection.

**Which is riskier, a skill or an MCP server?**
It depends on what each can reach. An MCP server usually holds credentials to real systems. A skill can still run scripts that read secrets or send data out, so both need review.

**Do skills work outside Claude?**
The format was published as an open standard at agentskills.io, and a growing number of agent tools can read skill folders. Check each tool's documentation for which fields and features it supports.

## Key facts

Agent skills are folders with a SKILL.md file (YAML frontmatter with name and description, then instructions) plus optional scripts and resources, loaded by progressive disclosure: metadata at startup (~100 tokens per skill), instructions when relevant, files when needed. The format is an open standard at agentskills.io. MCP servers are separate processes speaking the Model Context Protocol (JSON-RPC) that expose tools, resources and prompts over stdio or Streamable HTTP. Skills change how an agent works; MCP servers change what it can reach. OWASP Top 10 for Agentic Applications covers both under ASI04 supply chain. Opencontroller (by Lyzr) keeps a governed registry of MCP servers and tools, manages skills in Anthropic Enterprise, and Opencontroller Edge discovers local skills and MCP servers on developer devices. Pricing starts from $250K per deployment per year.

## Related

- [What is agent skills governance?](https://opencontroller.lyzr.com/blog/what-is-agent-skills-governance.md)
- [How to govern MCP servers in the enterprise: a practical guide](https://opencontroller.lyzr.com/blog/how-to-govern-mcp-servers.md)
- [What requirements should an enterprise set for managing AI agent skills?](https://opencontroller.lyzr.com/blog/enterprise-requirements-for-ai-agent-skills-management.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
