An Agent Skill is, at its simplest, a folder with a SKILL.md file in it —
and yet that folder is one of the more important ideas in how agents are built today. This paper
explains skills from the basics and then in depth: the concept, the format, the
progressive-disclosure technique that keeps them cheap, how a skill is triggered and run,
and the full implementation across the Claude Developer Platform, Claude Code, the Agent SDK,
and the open standard. Every claim is cited to official documentation.
Modern models are capable, but capability is not the same as competence at your task. Anthropic frames the gap plainly: “Claude is powerful, but real work requires procedural knowledge and organizational context.” A model knows how to write Python in the abstract; it does not know your company's brand guidelines, your spreadsheet conventions, or the exact steps your team follows each month to finalize its financial accounts. An Agent Skill is how you give it that knowledge.
The official definition: “Agent Skills: organized folders of instructions, scripts, and resources that agents can discover and load dynamically to perform better at specific tasks. Skills extend Claude's capabilities by packaging your expertise into composable resources for Claude, transforming general-purpose agents into specialized agents that fit your needs.” The recurring analogy is worth remembering, because it explains nearly every design decision that follows: “Building a skill for an agent is like putting together an onboarding guide for a new hire.”
Sources: anthropic.com · Equipping agents for the real world with Agent Skills (problem statement; definition; onboarding analogy) · platform.claude.com · Agent Skills · Overview · anthropic.com · Introducing Agent Skills.
You could paste your conventions into every conversation, or grow your system prompt until it covers every task. The problem is the context window. Anthropic treats it as a scarce shared resource: “The context window is a public good. Your Skill shares the context window with everything else Claude needs to know.” Loading all of your procedural knowledge up front — most of which is irrelevant to any given request — leaves less room for the conversation itself. Skills solve this with the design principle covered in section 3: they make the loaded cost of knowledge proportional to its relevance. As the engineering team puts it, because agents can read files on demand, “the amount of context that can be bundled into a skill is effectively unbounded.”
Sources: platform.claude.com · Agent Skills · Best practices (“The context window is a public good”) · anthropic.com (“effectively unbounded”).
“At its simplest, a skill is a directory that contains a SKILL.md file. This file must
start with YAML frontmatter that contains some required metadata: name and
description.” Everything else — extra instructions, reference docs, scripts, templates
— is optional and lives alongside it in the folder.
SKILL.md is the entry point; everything else is optional and loads only when the agent needs it.
The frontmatter is YAML between --- fences. Two fields are required, and the docs specify
exact validation rules for each — because these strings end up in the model's system prompt and
are how it chooses the right skill.
---
name: pdf-processing
description: Extracts text and tables from PDF files, fills forms, and merges
documents. Use when working with PDF files or when the user mentions PDFs,
forms, or document extraction.
---
# PDF Processing
## Instructions
[Step-by-step guidance for Claude to follow]
## Additional resources
- For form-filling, see [FORMS.md](FORMS.md)
- For the full API reference, see [reference.md](reference.md)
pdf-processing description; reference pattern) · anthropic.com (“a directory that contains a SKILL.md file… required metadata: name and description”).nameClaude Platform validation: max 64 chars; lowercase letters, numbers, and hyphens only; no XML tags; not the reserved words anthropic/claude. The open spec adds that the name must match the parent directory and forbids leading, trailing, or consecutive hyphens.
descriptionNon-empty, max 1024 chars, no XML tags. Must say both what the Skill does and when to use it — it is the trigger signal.
Markdown instructions. Keep it under ~500 lines; split into separate files when it grows. SKILL.md works “like a table of contents.”
name rules: parent-directory match; no leading/trailing/consecutive hyphens).The whole design rests on one idea: “progressive disclosure: Claude loads information in stages as needed, rather than consuming context upfront.” A skill is loaded in three levels, and most of it usually never loads at all. This is what lets you install a hundred skills without overwhelming the context window.
| Level | When loaded | Token cost | Content |
|---|---|---|---|
| 1 · Metadata | Always — at startup | ~100 tokens / skill | name + description, injected into the system prompt |
| 2 · Instructions | When the skill is triggered | Under 5k tokens | The SKILL.md body, read from the filesystem via bash |
| 3+ · Resources | As needed | Effectively unlimited | Bundled files & scripts — executed/read without loading contents into context |
The best-practices “runtime environment” section explains the mechanics behind the table:
description matters enormously: “The description is critical for skill selection:
Claude uses it to choose the right Skill from potentially 100+ available Skills.” A vague
description means the skill never triggers; a precise one (what it does and when) makes it
trigger at the right moment. That's why section 7 covers in detail how to write it.
Source: Best practices · the description is critical for skill selection.
Put the format and the disclosure model together and you get the full runtime picture. Anthropic walks through it as a four-step sequence on the context window — from a request arriving, to the skill being read off disk, to the task being done. Crucially, none of this is a special “skill engine”: the agent simply uses ordinary bash and file reads against a filesystem.
“To start, the context window has the core system prompt and the metadata for each of the installed skills, along with the user's initial message.” The agent matches the request against descriptions and decides a skill is relevant.
“Claude triggers the PDF skill by invoking a Bash tool to read the contents of pdf/SKILL.md.” Now — and only now — the instructions enter context.
“Claude chooses to read the forms.md file bundled with the skill.” Bundled scripts run via bash, and “only the script's output consumes tokens” — the code and the data it processes stay out of context.
“Finally, Claude proceeds with the user's task now that it has loaded relevant instructions from the PDF skill.” Deterministic steps were handled by code; the rest by the loaded guidance.
Source: anthropic.com · Equipping agents for the real world with Agent Skills (the four numbered “Skills and the context window” steps; the deterministic-code rationale) · Best practices (“Only the script's output consumes tokens”).
container, and run inside the code-execution sandbox.
On the API, “Skills integrate with the Messages API through the code execution tool… both
require code execution and use the same container structure.” You name the skills you
want in container.skills[], enable the code execution tool, and pass the beta headers.
The skill's files are then copied into the sandbox at /skills/{directory}/ and loaded
via the same progressive-disclosure mechanism described above.
response = client.beta.messages.create(
model="claude-opus-4-8",
max_tokens=16000,
betas=["code-execution-2025-08-25", "skills-2025-10-02"],
container={"skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]},
messages=[{"role": "user",
"content": "Create a presentation about renewable energy with 5 slides"}],
tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
Every entry has a type, a skill_id, and an optional version. There are two kinds:
| Aspect | Anthropic (pre-built) | Custom |
|---|---|---|
type | anthropic | custom |
skill_id | Short names: pptx, xlsx, docx, pdf | Generated: skill_01AbCd… |
version | Date-based: 20251013 or latest | Epoch: 1759178010641129 or latest |
| Availability | Maintained by Anthropic; available to all | Uploaded via the Skills API; private to your workspace |
/skills/{directory}/).The /v1/skills endpoints “give developers programmatic control over custom skill versioning and management” — create, list, and version skills. A bundle is “a directory containing a SKILL.md file at the top level… plus any supporting scripts or resources,” uploaded as a zip (or via the SDK's files_from_dir helper) and capped at 30 MB. To delete a skill you must first delete all its versions, or you get a 400.
/v1/skills) · Skills API guide (bundle rules, 30 MB, versioning, delete behavior) · API reference · List Skills.Three exact strings: code-execution-2025-08-25 (required for skills), skills-2025-10-02 (enables the Skills API), and files-api-2025-04-14 (upload/download container files).
Python 3.11.12, Linux x86_64, 5 GiB RAM, 5 GiB disk, 1 CPU. Containers expire 30 days after creation. Internet access is completely disabled — no outbound requests, full isolation.
Code execution is free when paired with web search/fetch; otherwise each org gets 1,550 free hours/month, then $0.05 per hour per container (5-minute minimum).
pptx,
xlsx, docx, pdf — available on claude.ai, the Claude API,
Claude Platform on AWS, and Microsoft Foundry. (Code execution, and therefore API-hosted skills,
is not currently available on Amazon Bedrock or Vertex AI.)
Source: Overview (pre-built skills & surfaces) · Code execution · platform availability.
In Claude Code and the Agent SDK, skills are filesystem artifacts rather than API objects. Claude
Code “skills follow the Agent Skills open standard… Claude Code extends the standard with
additional features like invocation control, subagent execution, and dynamic context injection.”
A notable consolidation: “Custom commands have been merged into skills” — a file at
.claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md
both create /deploy.
| Location | Path | Applies to |
|---|---|---|
| Enterprise | Managed settings | All users in the org |
| Personal | ~/.claude/skills/<name>/SKILL.md | All your projects |
| Project | .claude/skills/<name>/SKILL.md | This project only |
| Plugin | <plugin>/skills/<name>/SKILL.md | Where the plugin is enabled |
On name clashes, “enterprise overrides personal, and personal overrides project,” and any of these overrides a bundled skill of the same name. Plugin skills use a plugin-name:skill-name namespace, so they can't collide.
Claude Code adds optional fields beyond name/description — including when_to_use, allowed-tools, disallowed-tools, disable-model-invocation, user-invocable, context: fork (run in a subagent), model, effort, and paths (glob-gated auto-activation). It also supports the ${CLAUDE_SKILL_DIR} substitution and !`command` dynamic context injection, which “runs shell commands before the skill content is sent to Claude… so Claude receives actual data, not the command itself.”
---
name: deploy
description: Deploy the application to production
context: fork # run in a forked subagent context
disable-model-invocation: true # only the user can trigger it, via /deploy
allowed-tools: Bash(python3 *) # pre-approved while the skill is active
---
## Current changes
!`git diff HEAD` # output is injected before Claude sees the skill
## Instructions
Summarize the changes above, then deploy using ${CLAUDE_SKILL_DIR}/scripts/deploy.sh
A subtlety: allowed-tools grants, it doesn't restrict
Read this carefully, because it is easy to misread: “The allowed-tools field grants permission for the listed tools while the skill is active… It does not restrict which tools are available: every tool remains callable, and your permission settings still govern tools that are not listed.” And it behaves differently across surfaces — in the Agent SDK the field is ignored entirely: “The allowed-tools frontmatter field… is only supported when using Claude Code CLI directly. It does not apply when using Skills through the SDK.”
By default both you and the model can invoke a skill. disable-model-invocation: true makes it manual-only; user-invocable: false hides it from the / menu (model-only). skillOverrides in settings can control visibility without editing the SKILL.md.
Skills are filesystem artifacts loaded per settingSources; the skills option ("all", a name list, or []) filters them. “The SDK does not provide a programmatic API for registering Skills.”
Add a .claude-plugin/plugin.json and a skill folder “can bundle agents, hooks, and MCP servers.” Skills can also be distributed through plugin marketplaces, or provided by an MCP server.
On December 18, 2025, Anthropic published Agent Skills “as an open standard for cross-platform
portability.” The format — the same SKILL.md-in-a-folder you've seen throughout — is
documented at agentskills.io and is no longer Claude-specific:
“The Agent Skills format was originally developed by Anthropic, released as an open standard, and has
been adopted by a growing number of agent products.”
Sources: anthropic.com (the Dec 18, 2025 open-standard update banner) · agentskills.io · Home.
The result is one creator, one spec, and many independent implementations — including tools from
Anthropic's direct competitors. The agentskills.io quickstart states it plainly: “Agent Skills are an
open format. The same skill works in any compatible agent, including Claude Code and OpenAI Codex” —
and it demonstrates the format in VS Code (where skills live under .agents/skills/ by default).
Beyond those, the standard's client showcase lists dozens more implementations — among them Google's
Gemini CLI, GitHub Copilot, Cursor, Mistral AI Vibe, Block's Goose, and
data platforms like Databricks and Snowflake — each entry linking to that client's own
skills documentation. In short, this is not a Claude-only format.
Sources: agentskills.io · Quickstart
(“The same skill works in any compatible agent, including Claude Code and OpenAI Codex”; VS Code default
path .agents/skills/) · agentskills.io · Client Showcase
(lists each named client, with a link to that client's own setup instructions). The list grows over time — treat the
named examples as a snapshot as of the research date.
The portable spec is deliberately small. It defines a directory with a SKILL.md (optionally
plus scripts/, references/, assets/), YAML frontmatter followed by
Markdown, and a tight frontmatter field set: required name and description,
plus optional license, compatibility, metadata, and an
experimental allowed-tools. It restates the same progressive-disclosure budgets —
“Metadata (~100 tokens)… Instructions (< 5000 tokens recommended)… Resources (as needed)” — and
the “keep SKILL.md under 500 lines” guidance.
when_to_use,
disable-model-invocation, context, model, paths, …)
are Claude Code extensions to the standard, not part of the base spec. A skill that uses only the
portable fields runs across compatible agents — the agentskills.io quickstart demonstrates the same
skill working in VS Code, Claude Code, and OpenAI Codex (note: some clients default to a different
skills path, e.g. .agents/skills/).
Source: code.claude.com (“Claude Code extends the standard”) · agentskills.io · Specification · agentskills.io · Quickstart (cross-client portability).
Skills are powerful precisely because they carry instructions and code — which is also why they carry risk. Anthropic is direct: “a malicious Skill can direct Claude to invoke tools or execute code in ways that don't match the Skill's stated purpose.” The guiding rule is to “treat [a skill] like installing software.”
How much damage a skill could do depends entirely on where it runs — and the three surfaces differ sharply on network access. This is the single most important operational distinction:
| Surface | Network access | Isolation / boundary | Package installs |
|---|---|---|---|
| Claude API | None — “Skills cannot make external API calls or access the internet” | Isolated sandbox container, fully isolated from host; files limited to the workspace | Pre-installed packages only; no runtime installs |
| claude.ai | Varying — “Depending on user/admin settings, Skills may have full, partial, or no network access” | Code-execution sandbox; admin/plan-gated | Managed environment |
| Claude Code | Full — “Skills have the same network access as any other program on the user's computer” | Your machine, but not unrestricted by default — access is gated by Claude Code's permission prompts, workspace trust, and permission/deny rules (and disallowed-tools), not a sandbox. (allowed-tools only broadens pre-approved access; it does not restrict it.) | Local installs (global installs discouraged) |
A skill packages instructions, scripts, and resources so a general-purpose agent becomes a specialist — “like an onboarding guide for a new hire.” It's procedural knowledge, not a new capability.
A directory with a required SKILL.md: YAML frontmatter (name, description) plus Markdown, optionally bundling reference files and scripts. Keep the body under ~500 lines.
Three levels: metadata always (~100 tokens), the body when triggered (<5k), resources as needed (unbounded). This is what makes 100+ skills affordable.
The agent triggers a skill by reading its SKILL.md via bash, follows references, and runs scripts whose code never enters context. There's no special engine — it's a filesystem and code execution.
On the API: container.skills[] + the code execution tool + beta headers, with a no-network sandbox. In Claude Code / the SDK: folders under .claude/skills/, discovered automatically.
The format is now an open standard (agentskills.io). Treat skills like installing software: use trusted sources, audit bundled code, and remember Claude Code skills run with full machine access.
name, description) followed by Markdown instructions.skills[] (each with type, skill_id, version) and runs them in the code-execution sandbox.code_execution_20250825) that skills run inside on the API; “enables Claude to use Agent Skills.”pptx, xlsx, docx, pdf, maintained by Anthropic.skill_01…), uploaded/managed via the /v1/skills endpoints; workspace-private.