What Are Agent Skills? Skills vs MCP Explained (2026)

Key Takeaways

• Agent Skills package reusable instructions and optional scripts in SKILL.md folders, letting compatible AI agents load specialized procedures when needed.
• Anthropic transferred Agent Skills to the Agentic AI Foundation on October 22, 2026, after publishing the open standard in December 2025.
• Agent Skills encode how to perform a task; MCP provides standardized connections to the external tools and data that tasks require.
• More than 70 platforms support the format, but compatible file structures do not guarantee identical permissions, execution environments, or results.

Agent Skills are reusable instruction packages for AI agents, not separate AI models or replacements for software connections. The practical question is whether a task needs repeatable know-how, access to an external system, or both. Comparing individual AI agent products is a separate decision, involving access, autonomy, and reliability rather than the Skill file format.

The simplest way to understand this format is to start with what actually lives inside a skill.

Agent Skills are portable directories that teach compatible AI agents specific tasks through a required SKILL.md file containing metadata and Markdown instructions. Optional scripts, reference documents, and templates extend that package. The Agent Skills open standard defines the file structure; each host agent determines discovery, tool permissions, execution, and supported capabilities.

A folder can travel between systems more easily than a custom application integration. The work it can actually perform still depends on the agent that opens it.

What Are Agent Skills?

An Agent Skill is a reusable set of task-specific instructions and optional resources that an AI agent can consult when a request calls for them. A financial reporting skill might define an approved reporting template, formulas to check, and the order in which to validate a spreadsheet. A research skill might require a source-quality checklist before the agent produces a brief.

The key word is reusable. A prompt tells an assistant what to do now. A skill makes a documented procedure available again when an appropriate task appears. Users can still issue ordinary prompts; a skill helps the agent interpret those prompts according to an established method without requiring someone to retype the procedure on every occasion.

Agent Skills originated in Anthropic's Claude ecosystem, but the format is not restricted to Claude. The underlying idea is straightforward: separate durable domain instructions from a particular conversation. Anthropic says the standard had integrations in more than 70 agent platforms by its October 22, 2026 announcement. That figure measures reported integration, not identical support or independently verified task quality.

What Does an Agent Skill Actually Contain?

A skill directory always needs one central file, SKILL.md. The file begins with YAML frontmatter, a short machine-readable header, followed by ordinary Markdown instructions. Under the official Agent Skills specification, two frontmatter fields are required: name and description. The name identifies the skill and must match its directory; the description tells a compatible agent both what the skill does and when it should be considered.

The same specification allows other fields and files. A references/ directory might hold policy documents; assets/ might contain templates; and scripts/ can hold executable code. Those directories are optional conventions, not mandatory components. A completely useful skill may be only one well-written Markdown file. The format's experimental allowed-tools field also should not be mistaken for a universal enforcement mechanism across all hosts.

A skill is therefore a package of procedure, not a new application account or a general-purpose plugin marketplace. Whether it can edit files, call an API, or execute its scripts is decided outside the folder by the host's tools, security rules, and runtime.

Agent Skills vs Prompts, Tools, and AI Agents

The distinction matters because four different things are often described as an AI "skill." An ordinary prompt states an immediate request. An Agent Skill preserves repeatable instructions for a class of requests. A tool exposes an action, such as searching records or editing a file. An AI agent decides which instructions and tools to apply while pursuing a user goal.

One agent can use several skills, and several skills can call on the same tools. A skill may mention a tool without making that tool available. Conversely, a tool may exist without any skill explaining the preferred workflow for using it. For example, an agent might have a calendar connector but no convention for choosing which meetings belong in a weekly briefing.

This separation explains why installing more skills does not automatically make an agent more autonomous. The agent still needs access, authority, sufficient context, and a way to verify the work. For a product-level comparison rather than a technical-format discussion, see our personal AI agent comparison.

How Do Agent Skills Work?

Agent Skills usually follow a discover, select, load, and apply pattern. The host identifies available skill names and descriptions, decides which skill is relevant to the current request, reads more instruction content, and then performs the task using its permitted capabilities. An individual agent product may expose this process differently or require the user to select a skill manually.

The SKILL.md File Structure

A small, conceptual skill might look like this:

weekly-meeting-brief/
├── SKILL.md
├── references/
│   └── briefing-rules.md
└── assets/
    └── weekly-brief-template.md

The directory name and the YAML name field should agree. Files inside references/ and assets/ are optional. The agent does not automatically gain the right to read company calendars merely because a Markdown instruction asks it to do so. Appropriate permissions and an integration would still be needed.

Progressive Disclosure: Loading Only What Is Needed

Progressive disclosure describes the design pattern of showing an agent concise skill metadata first, then supplying the full instructions and relevant supporting files when needed. In a well-designed workflow, the agent does not need to carry dozens of long instruction manuals in every prompt. It starts with a small index and brings detailed knowledge into context for the appropriate task.

This pattern can reduce unnecessary context, but it is not a guarantee of lower cost or perfect skill selection. Long descriptions compete for attention; a vague description may fail to match a relevant request; and some clients handle loading differently. A task should be tested in the actual target agent, not judged solely by whether the folder follows the standard.

Instructions, Scripts, and Reference Files

Instructions express how work should be done: sequence, output structure, checks, and exceptions. Reference documents explain what information the work relies on: internal policy, schemas, or domain definitions. Scripts can automate specific operations, such as validating a CSV or generating a formatted report, when the runtime permits execution.

These functions overlap, but they are not interchangeable. A script is useful for deterministic checks; a reference file helps with factual consistency; and procedural instructions tell the agent when to use each. A skill that demands a particular command-line package will not work unchanged in a restricted environment that lacks that package. A skill that only formats text may be much easier to move between agent products.

Agent Skills vs MCP: What's the Difference?

Agent Skills describe task procedures; the Model Context Protocol (MCP) standardizes how AI applications connect to outside tools and information. Both can support the same workflow, but they operate at different levels. Treating them as competing replacements leads to avoidable architectural mistakes.

The boundary is clearer when the two standards are considered together.

Agent Skills standardize reusable task instructions, metadata, and optional local resources through SKILL.md packages. Model Context Protocol standardizes connections between AI applications and external systems, exposing tools, resources, and prompts through MCP servers. Skills provide procedural guidance; MCP provides interoperable access pathways. A single agent workflow can use either standard or both.

In ordinary terms, a skill may specify how a briefing should be written, while an MCP connection may supply the calendar events and documents the briefing needs. Neither standard, on its own, guarantees a reliable final result.

What Agent Skills Do

Skills are useful when an agent repeatedly performs the same kind of reasoning or production task. A customer-support team can keep escalation criteria, tone requirements, and handoff templates in a skill. An analyst can package a research method with citation checks and a required output structure. The benefit is consistency in instructions, not a guarantee that the model will always comply.

A Skill may contain scripts, which means "Skills only contain text" is inaccurate. The script's behavior, however, depends on an execution environment. If the agent can run Python, a script might calculate a metric. If it cannot, the same file may remain an unusable artifact until a compatible runtime is supplied.

What MCP Does

MCP is an integration standard. The official Model Context Protocol introduction describes connections to sources such as databases, files, tools, and specialized prompts. MCP servers can expose tools that perform operations, resources that provide context, and prompts that define reusable interaction templates. An MCP connection can therefore do more than simply retrieve data.

MCP is also not an automatic grant of access. A server may support reading calendar items while withholding the ability to create them; a user may need to authenticate; and an organization may restrict a connection. An agent should confirm the outcome of an action in the destination service rather than report success merely because an instruction was generated.

When to Use Skills, MCP, or Both

Choose a Skill when the missing ingredient is an established method: a reporting format, validation procedure, or domain checklist. Choose MCP when the missing ingredient is access to a system: a CRM, issue tracker, database, calendar, or document repository. Use both when the agent must retrieve live context and then process it according to a standardized business procedure.

Two counterexamples help prevent unnecessary complexity. A self-contained proofreading checklist may work perfectly without MCP. A single request to fetch the newest inventory number may need only an MCP-connected tool and no Skill. Adding both standards is useful only when each solves a distinct part of the task.

A Real-World Example: Using Agent Skills and MCP Together

A weekly meeting brief shows what "instructions plus connections" actually means. Consider a user asking an agent: "Prepare Monday's brief from last week's meetings and the documents discussed." The user expects a concise report with decisions, unresolved issues, owners, and source references rather than a transcript dump.

The Skill can define the workflow: gather eligible meetings; separate decisions from discussion; verify each assigned owner against available notes; mark unresolved items explicitly; and produce a fixed five-section brief. A template in assets/ can define headings, while a reference file can describe the team's preferred terminology. None of these files proves that the agent can see anyone's private calendar.

The MCP layer, where available and authorized, can expose calendar entries or document search tools. The agent asks the connected services for relevant records, applies the skill's procedure to the retrieved data, and produces a draft. If a record is unavailable, the correct behavior is to identify the gap rather than invent missing decisions.

The human review layer still matters. The user should check attribution and dates, especially before sending the brief to colleagues. A write-capable integration would require a separate decision about whether the agent may create tasks or send messages. The reporting skill does not silently supply that permission.

This architecture is conceptually similar to what enterprise agents do across applications, but commercial implementations have their own constraints. A reader exploring one such product can compare its integration limits in our Google Gemini Agent overview, which covers a different question from the open Skills format.

How to Create Your First Agent Skill

A first Skill should solve one narrow, repeatable problem. A lightweight "meeting brief reviewer" is more testable than a vague "make me productive" package because the expected input, steps, and output are visible. Start with plain Markdown; add scripts only after a repeatable manual process works.

Step 1 ― Define One Repeatable Task

Specify the trigger, accepted inputs, expected output, and important exceptions. For this example, the input is a meeting transcript or human-written notes. The output is a short brief containing decisions, assigned actions, unresolved questions, and citations back to the supplied material. If the notes do not contain an owner or a deadline, the brief should say "not specified" rather than guess.

This deliberately avoids any live connection. The first version can be tested against sample notes pasted by a user. A calendar or document integration can be considered later, once the writing procedure itself is reliable.

Step 2 ― Write a Minimal SKILL.md File

Create a folder named meeting-brief-review and add the following file inside it:

---
name: meeting-brief-review
description: Create an evidence-based meeting brief from supplied notes or transcripts. Use when a user requests meeting decisions, action items, or a weekly brief.
---

# Meeting Brief Review

1. Read only the notes or transcript supplied for this task.
2. Extract decisions, action items, owners, and open questions.
3. Do not infer an owner, due date, or decision that is not stated.
4. Cite the source passage or timestamp for material claims.
5. Output four headings: Decisions, Actions, Open Questions, Sources.
6. Flag missing or conflicting information for human review.

The example uses valid name and description fields and a Markdown instruction body. It is illustrative, not proof of compatibility with every host. Installation steps depend on the agent product, and product-specific conventions may add additional requirements.

Step 3 ― Add References or Scripts Only When Needed

Move a long reporting policy into references/ when the skill's main file becomes difficult to scan. Add a template to assets/ if a consistent deliverable matters. Add a script only for operations with a genuine programmatic advantage, such as checking that every action item has a source line. Document dependencies rather than assuming the host has a particular package or network connection.

Optional resources should reduce repeated explanation, not hide important requirements. A task-critical instruction belongs in the main procedure or in a referenced file the agent is explicitly directed to consult.

Step 4 ― Test the Skill and Review Its Output

Test with three cases: complete meeting notes, notes with no clear action owners, and contradictory notes. Check whether the agent selected the skill, followed its output structure, cited supplied evidence, and admitted uncertainty. Re-run the same cases after edits. This small regression set catches a more meaningful class of failures than simply asking whether the Skill loaded.

A passing local test does not establish portability. Repeat the test in every intended host, especially when the workflow uses tools, scripts, or external connections. Record what worked, what required adaptation, and which permissions were granted.

Why the Open Standard Matters After the 2026 Foundation Transfer

The October 2026 announcement concerns governance, not the original invention of Skills. Anthropic introduced Skills in October 2025 and published the Agent Skills open standard in December 2025. On October 22, 2026, Anthropic announced that it was donating the standard to the Agentic AI Foundation (AAIF) under the Linux Foundation.

The announcement matters because two related projects now share a vendor-neutral governance home. MCP addresses connections; Agent Skills addresses portable procedures. This does not make the two protocols technically identical or make AAIF the operator of every company's agent runtime.

What Changed on October 22, 2026?

According to Anthropic's October 2026 foundation announcement, the contribution includes the Agent Skills name and logo, the GitHub organization, and the agentskills.io domain. The company also identified individual maintainers from multiple organizations and proposed future work on versioned releases, a formal proposal process, and security guidance.

Anthropic reported more than 70 integrated agent platforms, one million published skills, and nearly 280 million installations. These are company-reported adoption figures as of October 22, 2026, not independently audited counts or success-rate metrics. More installations do not demonstrate that a given Skill will produce correct output in a given environment.

Foundation governance can make contributions and specification changes less dependent on a single vendor's product roadmap. It does not automatically impose uniform execution behavior or eliminate host-specific design decisions. The proposed roadmap also remains a proposal until changes are actually adopted and published.

Does an Open Standard Mean Cross-Platform Compatibility?

Portable format and portable execution are different claims. A host may correctly recognize a Skill's name, description, and Markdown body while lacking the same shell, packages, file permissions, connected services, or tool approvals as another host. A compatible reader is not necessarily a compatible runtime.

The distinction can be stated without appealing to a particular AI product.

Agent Skills portability has two separate layers: format compatibility and runtime compatibility. Format compatibility means an agent can interpret the standardized SKILL.md structure. Runtime compatibility requires the host to provide needed tools, dependencies, permissions, and network access. Standardized files improve transferability, but they do not establish identical behavior, security controls, or task outcomes.

A text-only editing procedure may migrate cleanly; a Skill invoking a networked command or external database may require considerable adaptation. A useful portability test therefore includes both file recognition and successful execution with the same documented inputs.

Are Agent Skills Safe to Install?

A third-party Skill should be treated as an instruction package that may contain executable code, not as harmless documentation. A SKILL.md file can tell an agent to access files, invoke a tool, fetch a URL, or run a bundled script. The damage potential depends on what the host environment permits.

The Risks of Untrusted Skills

The most important risks are instruction manipulation, unsafe code execution, unnecessary access, and data exfiltration. A malicious Skill might try to override its apparent purpose, read confidential material, or transmit information outside the approved workflow. A legitimate Skill can also become risky when it references a changed external resource or runs with more permissions than necessary.

An additional failure mode arises when a Skill combines broad file access with an external network tool. Even without an obviously dangerous command in the headline file, that combination can expose data if instructions or dependencies are compromised. For a wider view of permission boundaries and independent verification, see our personal AI agent safety guide.

What to Check Before Running a Third-Party Skill

The following checklist condenses the security questions that matter most for individuals and small teams:

1. Read the entire directory. Inspect SKILL.md, scripts, referenced Markdown files, and templates; a reassuring description is not a security review.
2. Identify every action pathway. Note shell commands, file operations, tool calls, network requests, and MCP server references, especially those unrelated to the stated task.
3. Look for secrets and suspicious instructions. Reject hardcoded credentials and directions to conceal actions, bypass safeguards, or send data to unexplained endpoints.
4. Run a constrained test. Use non-sensitive sample data, least-privilege permissions, and a sandbox when code execution is involved.
5. Pin and re-evaluate changes. Review updated files and dependencies before promoting a new version into a workplace workflow.

A review should also record who approved the Skill, which environment will run it, and what evidence confirms the most recent version is the one that was inspected. For workplace use, assign an owner who can remove access if the Skill behaves unexpectedly.

These checks align with the Claude enterprise Skill security guidance, which calls out script execution, tool references, network access, embedded credentials, and instruction manipulation. A platform's automated scanner can help identify some issues but cannot replace inspection and permission control.

The security boundary is shared: Skill authors should write transparent instructions, tool providers should enforce scopes, host agents should respect authorizations, and users should verify high-impact actions. Neither Agent Skills nor MCP is an assurance of privacy or organizational compliance on its own.

Frequently Asked Questions

Are Agent Skills the Same as Vendor-Specific Skills?

Agent Skills describes an open format; Claude Skills refers to implementations within Anthropic's products. Anthropic helped originate the format, but the standard can be implemented by other agents. Product-specific setup, code execution access, distribution, and supported features may differ even when the underlying SKILL.md structure is familiar.

Do Agent Skills Replace MCP?

No. A Skill can document a repeatable procedure without any MCP server, and an MCP-connected tool can execute a one-off request without a Skill. Tasks requiring both a standard method and access to external services can benefit from both. The decision depends on the work, not a winner-takes-all protocol comparison.

Can Agent Skills Work Across Different AI Tools?

Some products support the Agent Skills format, but support does not imply feature parity. Anthropic named ChatGPT, Cursor, GitHub Copilot, and VS Code among integrated platforms in its October 2026 announcement. A particular skill still needs to be tested for discovery, file loading, execution support, tool permissions, and available dependencies in each product.

Do You Need Coding Skills to Create an Agent Skill?

Not for a text-only Skill. A simple reusable procedure can be written in Markdown with a small YAML header. Coding becomes useful when the workflow needs reliable automation, complex validation, or bundled scripts. Even non-coders should test unclear inputs and verify whether their chosen agent can use the Skill as intended.

Bottom Line: Skills Define the Workflow, MCP Connects the Tools

Agent Skills are best understood as portable instructions for specialized work. MCP is best understood as a standardized route to external capabilities. A structured reporting workflow may need only a Skill; a live data lookup may need only MCP; and a multi-system business process may need both. The important question is not which label sounds more advanced, but which part of the task is missing.

The AAIF transfer gives the Agent Skills format a broader governance structure at a moment of substantial reported adoption. The next test is more practical than organizational: whether developers can move Skills between supported agents, identify environment differences quickly, and keep execution secure. File compatibility is a beginning, not a performance guarantee.