Abstract
Vercel's skills.sh directory listed roughly 669,670 agent skills by June 11, 2026, five months after it opened, with the single most-installed package, Vercel's own find-skills, past 2 million installs. Source: Ry Walker Research, "skills.sh," June 11, 2026; Source: Vercel, "Introducing skills, the open agent skills ecosystem," January 20, 2026. Anthropic shipped Agent Skills as a Claude Code feature in October 2025 and opened the format as an independent standard two months later; by the following spring, dozens of competing agent platforms, Cursor, GitHub Copilot, and OpenAI's own tooling among them, were reading the identical file. Source: Anthropic, "Equipping agents for the real world with Agent Skills"; Source: Simon Willison, "Agent Skills," December 19, 2025. Almost none of the coverage of that growth calls the mechanism what it actually is: a compression algorithm wearing a product name. A skill's name and one-line description load into context at boot. The full instructions load only when a task needs them. Anything else bundled in the folder loads only if a specific step calls for it. That is progressive disclosure, and it is the same principle this blog has argued for on the production request side, cheap check first, full payload only on demand, aimed instead at the tool catalog and instruction set an agent carries around all day. A March 2026 audit of 55,315 public skills found the same numbers prompt-compression research keeps finding everywhere else, applied to this new surface: descriptions cut 48%, bodies cut 39%, and functional quality that went up, not down, once the excess was gone. Source: Gao et al., "SkillReducer: Optimizing LLM Agent Skills for Token Efficiency," arXiv:2603.29919, March 2026.
A folder of instructions is still a context bill
A skill, in the format Anthropic published, is a directory with a SKILL.md file at its root: YAML frontmatter carrying a name and a description, then markdown instructions, and optionally scripts or reference files a task can reach for. Source: Anthropic, "Equipping agents for the real world with Agent Skills". Nothing about that is novel; it is a slightly more disciplined version of the system-prompt snippets teams have been pasting into agent configs for two years. What is novel is that Anthropic didn't just document a convention, it built a loading order into the runtime, and then handed the format to a standards body instead of keeping it proprietary.
That loading order is the entire point, and it is worth being precise about it because most of the coverage of Agent Skills skips straight to the marketplace numbers without explaining the mechanism underneath them:
- Level 1, always resident. Every installed skill's name and description sit in the system prompt from the first token of every conversation, so the agent always knows what it has access to.
- Level 2, loaded on trigger. When a task looks like a match for a skill's description, the full
SKILL.mdbody loads into context, instructions, conventions, worked examples. - Level 3, loaded on demand. Files the skill body references, a longer style guide, a script, a data schema, load only when a specific step in the task actually needs them, and an agent with file access never has to load them into the context window at all if it can just read and execute them directly.
Anthropic's own framing for this is almost identical to the language prompt-compression research uses for context budgets: "the amount of context that can be bundled into a skill is effectively unbounded," because nothing beyond level 1 is paid for until it is used. Source: Anthropic, "Equipping agents for the real world with Agent Skills". That is the same tradeoff this blog has covered for MCP tool schemas, which load their entire catalog on every call whether a tool gets used or not, and for bloated system prompts, which accumulate instructions nobody ever prunes. Skills are the same failure mode, addressed at the format level instead of left to individual teams to discover the hard way.
Research question
Does the Agent Skills format actually deliver the token savings its architecture implies, does the ecosystem that formed around it confirm the same compression gains this blog has tracked elsewhere, and what does a team building its own agent, not on Claude's runtime, still need to do to get the same effect?
Methodology
This analysis separates three kinds of source:
- Anthropic's own published design documentation for the progressive-disclosure architecture and its October 2025 launch and December 2025 open-standard release. Source: Anthropic, "Equipping agents for the real world with Agent Skills".
- An independent, peer-reviewable measurement of token compression across a large sample of real, public skills: the SkillReducer paper's audit of 55,315 skills with a held-out evaluation set of 600. Source: Gao et al., arXiv:2603.29919.
- Ecosystem and vendor tracking data on adoption speed and marketplace scale (Vercel's skills.sh, Simon Willison's independent commentary on the standard, and one practitioner audit of what progressive disclosure saves in a running Claude Code session), each marked by source.
Results: an independent audit put real numbers on the excess
The SkillReducer paper is the closest thing this space has to a controlled study, and it did not start from Anthropic's own examples, it scraped the public ecosystem: 55,315 skills pulled from live marketplaces, with a 600-skill held-out set used to validate a two-stage compression pipeline against five different model families. Stage one rewrote verbose, redundant skill descriptions using delta-debugging with adversarial routing tests, cutting description length by a mean of 48% while keeping routing accuracy at 100% on the non-obsolete subset, 536 of 536 skills still triggered on the right task after compression. Stage two split each skill body into a core rule set, the paper found this was typically only 38.5% of the original content, and supplementary examples, then rebuilt the skill as a tiered file that loads the supplementary material only on demand, cutting body length by a mean of 39%. Source: Gao et al., arXiv:2603.29919.
The result that should get more attention than the compression ratios themselves: functional quality did not just survive the cut, it improved on 2.8% of tested skills, and held at 86% overall pass rate against the original, uncompressed version, with 0.965 mean behavioral retention across five different model families. Source: Gao et al., arXiv:2603.29919. The paper's own name for this is a "less-is-more effect": a shorter, better-organized skill gives a smaller model less to get distracted by, not less to work with. That finding lines up exactly with what this blog found reviewing context rot across 18 frontier models, more tokens in the window is not a neutral cost, it is an active tax on the model's ability to find the part that matters.
Results: adoption moved faster than most standards ever do
Anthropic published Agent Skills as a Claude Code and Claude Developer Platform feature on October 16, 2025, then opened the specification and reference SDK as an independent format on December 18, 2025, no longer gated to Anthropic's own products. Source: Anthropic, "Equipping agents for the real world with Agent Skills". Simon Willison, reviewing the release the next day, called the spec "deliciously tiny," readable "in just a few minutes," while flagging that fields like metadata and experimental options like allowed-skills were still under-specified. Source: Simon Willison, "Agent Skills," December 19, 2025. His list of platforms already building against the format on day one, OpenCode, Cursor, Amp, Letta, Goose, GitHub, VS Code, is the kind of adoption curve most agent-tooling specs never get, and OpenAI, conspicuously absent from that initial list, had formalized its own support within about 48 hours. Source: Simon Willison, "Agent Skills," December 19, 2025.
The marketplace layer built on top of that spec moved just as fast. Vercel opened skills.sh, a CLI and public directory for installing and tracking skill packages, on January 20, 2026, integrated with 18 agent platforms at launch. Source: Vercel, "Introducing skills, the open agent skills ecosystem". By June 11, 2026, independent tracking put the directory at roughly 669,670 listed skills, with the top package, Vercel's own find-skills, past 2 million installs and Anthropic's frontend-design skill past half a million. Source: Ry Walker Research, "skills.sh," June 11, 2026. None of that growth required a new model, a new API, or a new pricing tier. It required a file format that made it cheap enough to advertise a capability without paying for it until it's actually invoked.
Discussion: the same architecture, wearing a new name
Progressive disclosure is compression with a scheduling policy attached. Every prompt-compression technique this blog has covered, LLMLingua's token-level pruning, semantic caching's deduplication of repeated calls, prefix caching of stable system-prompt content, is a bet that most of what's sitting in context on any given turn isn't the part the model actually needs right now. Agent Skills makes that same bet structural: assume most of an agent's installed capability is irrelevant to the current task, and only pay the token cost for the sliver that isn't. The mechanism is different, load order instead of a compression model, but the wager is identical, and it's the same discipline this blog has already named context engineering: deciding what goes into the window, in what order, and what gets left out entirely.
The "less is more" finding is not new, it is the same finding this blog keeps re-confirming. Berkeley's RouteLLM work found 74% of GPT-4-tier calls didn't need GPT-4-tier quality. Chroma's context-rot benchmark found every one of 18 frontier models degraded measurably as context grew, before hitting any hard limit. SkillReducer's 2.8% quality improvement from cutting bloat is the same shape of result, spend and volume are not a proxy for usefulness, and the gap between the two is often large enough to fund the fix.
The MCP problem this blog already flagged is exactly the problem skills were built to avoid, and most teams haven't finished migrating. MCP servers load their entire tool catalog on every call, and one practitioner audit of a running Claude Code session found a single feature-rich MCP server adding up to 18,000 tokens per turn, with three servers combined burning past 50,000 tokens before a conversation even starts working the actual task. Source: BetterClaw, "Skills That Reduce Token Usage: 5 Proven Patterns". The same practitioner analysis estimated that stacking output compression, first-pass accuracy, and context-injection pruning together took a session from roughly 150,000 tokens down to 25,000-40,000, a 75-85% reduction, without changing which model answered a single turn. Source: BetterClaw, "Skills That Reduce Token Usage: 5 Proven Patterns". A separate analysis of Anthropic's own 17 official skills put the metadata-only cost of making an agent aware of all of them at roughly 1,700 tokens total, a median of about 80 tokens per skill, against a claimed 98% reduction versus loading every skill body up front whether it triggers or not. Source: Code With Seb, "Claude Code Skills: The 98% Token Savings Architecture Nobody Explains". That last figure is one blog's own measurement rather than a peer-reviewed number, and it's presented here as exactly that, but it's consistent with the direction every other source in this piece points: the discovery cost of "the agent knows this exists" is close to free, and the expensive part only gets paid when it's earned.
None of this replaces routing or model selection, it sits upstream of it. A perfectly compressed skill catalog still gets sent to whatever model answers the request, and that request still has the same cascade-of-models economics this blog has covered since FrugalGPT. Skills shrink what goes into the call. Routing decides what the call costs once it's sent. Compression and routing multiply, they don't compete, and that's just as true when the thing being compressed is a tool catalog instead of a document.
Implementation guide
- If you're building on Claude's own agent runtime, use the format as shipped. Progressive disclosure is already the default behavior; the work is writing tight, single-purpose
SKILL.mdfiles instead of one sprawling document, since the compression gain depends on the description alone being enough to trigger correctly. - Audit your own skills the way SkillReducer audited the ecosystem. Split each skill into a core rule set and supplementary reference material, and check whether the reference material can move to a level-3, load-on-demand file instead of living permanently in the level-2 body.
- If you're on a different agent framework, one that assembles a system prompt, tool schemas, and instructions manually, the format doesn't save you automatically. The SKILL.md convention is portable across the 30-plus platforms that now read it, but a hand-rolled agent loop that still concatenates every instruction into every call needs the same discipline applied by hand: short descriptions kept resident, long instructions fetched only when a task matches.
- Wherever your loop still assembles the full payload manually, route and compress what actually gets sent. Whatever context survives your own progressive-disclosure logic, a multi-skill task, a long reference file a step genuinely needed, is still a normal chat completions call, and it still benefits from being routed to the cheapest model that can handle it.
- Measure discovery cost separately from execution cost. The SkillReducer numbers matter because they're a mean across tens of thousands of real skills; your own catalog's numbers will differ, and they're worth knowing before assuming the format is doing all the work for you.
# Even with a well-compressed skill catalog, the call that actually
# executes a triggered skill is a normal chat completions request.
# Point it at Nadir and the loaded skill body, plus whatever reference
# files got pulled in for this task, still get routed to the cheapest
# model that can handle them - compression and routing stacking instead
# of competing.
import openai
client = openai.OpenAI(
base_url="https://api.getnadir.com/v1", # was: https://api.anthropic.com/v1
api_key="YOUR_NADIR_KEY",
)
response = client.chat.completions.create(
model="auto", # Nadir routes per call; your skill loader doesn't have to guess
messages=[
{"role": "system", "content": TRIGGERED_SKILL_BODY}, # level 2, loaded on match
{"role": "user", "content": task_prompt},
],
)Conclusion
Nobody marketing Agent Skills called it a compression play, and there's a reason for that: "install a skill" is a much better pitch than "we implemented lazy loading for your system prompt." But the mechanism underneath 669,670 marketplace listings and a 30-plus-platform standard is the same wager this blog has tracked since its first post on prompt compression: most of what an agent could know is irrelevant to what it's doing right now, and the fix is never loading it until it is. SkillReducer's audit of 55,315 real skills confirms the wager pays off at scale, shorter descriptions, shorter bodies, and quality that holds or improves. What it doesn't do is replace the decision of which model answers the call once the right context is assembled. Nadir sits at exactly that seam: whatever your own agent loop still has to build into a single completions call, a triggered skill body, a reference file, a tool schema that didn't fit the level-1 pattern, gets routed to the model that can actually handle it, on top of whatever you've already trimmed.
Sources: Anthropic, ["Equipping agents for the real world with Agent Skills"](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills). Gao, Li, Yuan, Ji, Ma, and Wang, ["SkillReducer: Optimizing LLM Agent Skills for Token Efficiency,"](https://arxiv.org/html/2603.29919v1) arXiv:2603.29919, March 2026. Simon Willison, ["Agent Skills,"](https://simonwillison.net/2025/Dec/19/agent-skills/) December 19, 2025. Vercel, ["Introducing skills, the open agent skills ecosystem,"](https://vercel.com/changelog/introducing-skills-the-open-agent-skills-ecosystem) January 20, 2026. Ry Walker Research, ["skills.sh,"](https://rywalker.com/research/skills-sh) June 11, 2026. BetterClaw, ["Skills That Reduce Token Usage: 5 Proven Patterns"](https://www.betterclaw.io/blog/skills-that-reduce-token-usage). Code With Seb, ["Claude Code Skills: The 98% Token Savings Architecture Nobody Explains"](https://www.codewithseb.com/blog/claude-code-skills-reusable-ai-workflows-guide).