In October 2025, Anthropic released Agent Skills as a feature for Claude. Within two months, early Agentic Skills had been built by partners like Atlassian, Figma, Canva, Stripe, Notion, and Zapier. How did a brand-new feature evolve into a pattern adopted so quickly across the enterprise?

The rapid ascent of agent skills speaks to their usefulness, as well as the broader need for reliable agentic standards. What are agent skills, though, and how are they different from the other agentic protocols already out there?

Agent Skills Definition

Agent skills are collections of instructions, packages, and scripts that give agents expanded abilities and domain knowledge. They tell agents what the tool does so that it can pick the right tool for the job when a query is made. Agent skills were popularized by Anthropic, but the pattern is also being incorporated into other AI coding environments, such as Microsoft Agent Skills.

An agent skill that allows an agent to look something up on the internet might be named web-search, for instance. Skills are described in a Markdown file using a standardized format containing YAML front matter followed by markdown content. An example of the YAML front matter looks like:

---
name: expense-report
description: File and validate employee expense reports according to company policy. Use when asked about expense submissions, reimbursement rules, or spending limits.
license: Apache-2.0
compatibility: Requires python3
metadata:
  author: contoso-finance
  version: "2.1"
---

Only the name and description fields are required, however. Everything else is optional. The YAML frontmatter is always loaded, but the instructions are only invoked when the agentic system determines a skill is the right one for the job.

The markdown content should describe how to use the skill, including step-by-step instructions for using the agent skill, examples of inputs and outputs, common edge cases, or any content that helps the agent perform the task. According to Anthropic, a skills.md file should be less than 500 lines, so detailed reference material should be moved to a separate file.

For example, take the sample instructions file for an agent skill that defines how to process PDFs using AI agents.

# PDF Processing

## Quick start

Use pdfplumber to extract text from PDFs:

```python
import pdfplumber

with pdfplumber.open("document.pdf") as pdf:
    text = pdf.pages[0].extract_text()
```

For advanced form filling, see [FORMS.md](FORMS.md).

This example is using Claude, as Agent Skills were originally created by Anthropic, which uses a uniform structure for Agent Skills. An example of Claude’s file structure for Agent Skills looks like this:

<username>/.claude/skills/
└── weather-research/               <-- Skill ID (kebab-case)
    ├── SKILL.md                    <-- REQUIRED: Entry point
    ├── scripts/                    <-- Optional: Executable code
    │   ├── get_history.py
    │   └── validate_location.sh
    ├── references/                 <-- Optional: Deep documentation
    │   ├── api_spec.md
    │   └── regional_codes.csv
    └── assets/                     <-- Optional: Templates/Static data
        └── report_template.docx

Since Anthropic’s Agent Skills emerged as a de facto pattern, most other agentic systems have followed Anthropic’s lead in terms of file structure. If you’re planning on using agent skills outside of GitHub Copilot or Cursor, it’s recommended that you implement a <username>/.agents/skills file structure, as most agentic systems will know to check that location.

Agent Skills have a similar goal as other agentic protocols: extending the reasoning abilities of agents. However, they differ in some fundamental ways. Agentic protocols like Model Context Protocol (MCP), Agent2Agent (A2A), or Agent Network Protocol (ANP) tell agents how to retrieve the assets they need while agent skills package the assets and instructions together.

A treasure map might serve as a useful analogy. Agentic protocols are the map itself, as well as the tools you’ll use to dig up the treasure, telling you what steps you need to take to unearth the loot and then acting as the shovel that actually does the digging. Agent skills would be the folder full of secrets buried beneath the X.

Why Agent Skills are Important

Agent skills were developed to help provide context necessary for large language models (LLMs) to function properly. LLMs aren’t true reasoning machines, they simply return the result most likely to complete the request, essentially acting as a very sophisticated autocomplete function.

To make matters worse, LLMs rely on the model they’re trained on, essentially freezing them in time. LLMs are also notoriously bad at complex reasoning like math or writing code.

Agent skills help agentic AI systems pick the right approach for a task or series of tasks, which can be transmitted along with the agent or referenced at runtime. Transforming common functions into agent skills improves governance in a variety of ways, enforcing compliance across projects as well as enhancing discoverability and reusability.

How to Use Agent Skills

Using agent skills requires moving from a chat-based mentality to an action-based way of thinking. Early LLMs essentially acted as advanced chatbots, summarizing texts and predicting what answers were most likely to resolve a query.

Agentic systems require a whole different way of thinking, as they allow AI systems to make things happen. This requires a subtle-but-important mentality shift, as it requires thinking like a rubrics engineer, breaking down a task into smaller, modular chunks to complete a task. This will help train you to think like an AI agent.

To illustrate the point, let’s imagine a hypothetical scenario. Imagine you’re asking Claude to optimize a section of code. Claude receives this query, identifies the intent, and then scans the connected agent skills to find the appropriate one. In this instance, an agent skill called ‘code-optimization-service’ might fit the bill. Claude then formats the query, specifying the function and specifying any necessary constraints. The agent then crafts a structured JSON block executing the agent skill.

On the backend, an agent skill may invoke external tools or services to complete its task. For example, this defines a callable tool that an agent could use when executing a skill:

# A simple MCP Skill definition in Python
from mcp.server import Server

app = Server("code-optimization-service")

@app.tool()
async def optimize_code(code_snippet: str, constraints: str = "") -> str:
    """
    Optimizes a given section of code based on specified constraints.

    Args:
        code_snippet (str): The code to optimize.
        constraints (str, optional): Performance or style constraints.

    Returns:
        str: Optimized version of the code.
    """
    optimized_code = f"Optimized version of your code with constraints '{constraints}':\n{code_snippet}  # [optimized]"
    return optimized_code

This uses an MCP SDK to implement a MCP server using Python. It also tells the agent to run the optimize_code function as well as how to format the retrieved data.

Potential Drawbacks of Agent Skills

Considering their power and potential, it’s tempting to imagine using agent skills for every agentic application. The appeal is understandable, but you’ll want to be careful for a few reasons.

Agent skills are often allowed to run with the full permission of the agent, using simple bash scripts once they’ve been invoked. This raises the potential for shadow AI, as an agent skill used improperly can gain access to shell access, read environment variables, and expose sensitive local data. In some circumstances, it’s a better idea to use MCP, which uses a server-client architecture that requires explicit permissions for granting access to sensitive assets.

Agent skills can also be rather taxing on a system, as the entire skill might be processed through the LLM when it’s invoked. This means that very elaborate agent skills could potentially run thousands of lines long, all of which would need to be processed via the LLM. If you know an agent skill is likely to be heavy and demanding on resources, it might be a better idea to handle some of the tasks locally using a different agentic protocol like MCP. You could even set up an agentic daisychain, using an MCP server to summarize resource-heavy agent skills before sending them through to the LLM.

Finally, agent skills don’t always play well with others. They’re designed to allow a single agent to learn a single task. Agent skills can falter a bit if multiple agents are working on the same task or a request involves multiple agents. If you suspect that an activity is going to involve complex reasoning, you may be better off using a protocol like A2A.

Final Thoughts on Agent Skills

Production-grade agentic AI can seem like magic when you first encounter them. There’s no denying the impressive sophistication of the math and programming happening under the hood, but it doesn’t take too long attempting to use this new technology to realize that it still takes a fair deal of knowledge and even more wisdom to use this new technology effectively.

Agent skills are the latest tool in the battle to get AI to not only think but reason effectively, one of the most challenging aspects of implementing a truly useful agentic AI. Most importantly, agent skills offer a model of how to think about skills, similar to the leap when developers first started including SDKs with digital tools and services.

Not only does it show just how integrated agentic AI has already become, it’s also an important step towards standardization, one of the last great hurdles before widespread adoption. Together, they loudly proclaim “agentic AI is here!” Considering how quickly it’s caught on, it seems safe to say that agent skills are going to play a part in the coming agentic future.