AI Agents

How Agent Skills Are Reshaping Agentic Workflows in 2026

Q: Do installed skills slow down every agent request?

Not meaningfully. Only lightweight metadata, roughly 100 tokens per skill, stays loaded for every request. Full instructions load only when a task actually triggers that specific skill.

Q: Is there public data on how widely Agent Skills have been adopted?

Not yet. Anthropic's launch documentation describes the mechanism in detail but publishes no install counts or adoption percentages specific to Agent Skills as of this writing.

August 23, 2026·12 min read·by Kunal Gaba

LLM EngineeringAgentic WorkflowsMCPProduction AI

A team building an internal support agent hits a familiar wall: the agent needs to fill out a specific PDF form, follow a 40-step refund policy, and generate spreadsheets in a house style — none of which fits cleanly into a system prompt, and none of which justifies a fine-tuning run. Six months ago the answer was "cram it into the prompt and hope." In 2026, the answer increasingly is: package it as a skill, and let the agent load it only when the task calls for it.

That shift — from stuffing instructions into context up front to letting an agent pull in exactly the capability a task needs, on demand — is what "skills" mean in agentic workflows. This post covers how the pattern works, how it differs from raw tool-calling and fine-tuning, and what to actually do about it if you're building agents in production.

Key Takeaways

Anthropic's Agent Skills load in three tiers: ~100 tokens of always-on metadata per skill, under 5,000 tokens of instructions only when triggered, and near-zero cost for bundled scripts until referenced (Anthropic, Oct 2025)

88% of organizations now use AI in at least one business function, but only 23% are scaling agentic AI anywhere, and no more than 10% are scaling it in any single function (McKinsey, State of AI 2025)

Just 14.1% of developers use AI agents daily and 9% weekly, while 37.9% have no plans to adopt them at all (Stack Overflow, 2025 Developer Survey)

Gartner projects more than 40% of agentic AI projects will be canceled by the end of 2027 over unclear ROI and inadequate risk controls (Gartner, Jun 2025)

Anthropic frames skills and MCP as complementary, not competing: skills teach an agent how to do a workflow, MCP gives it the tools to reach external systems

What Are "Skills" in an Agentic Workflow?

A skill is a folder containing a SKILL.md file — a short YAML-fronted markdown document describing when and how an agent should use a specific capability — plus optional bundled scripts, templates, or reference docs. Anthropic introduced this as Agent Skills in October 2025, describing it as a way to "equip agents for the real world" without bloating every prompt with instructions the current task doesn't need (Anthropic Engineering Blog, Oct 2025).

The core idea isn't new — engineers have hand-rolled versions of this for years, keeping playbooks in a docs folder an agent reads on request. What Skills formalizes is the loading mechanism: an agent doesn't read the whole library up front. It scans lightweight metadata for every installed skill, decides which one matches the current task, and only then reads the full instructions. That single design choice is why skills scale differently than either prompt-stuffing or fine-tuning.

A humanoid AI robot representing autonomous agents that select and load capabilities on demand

How Does Progressive Disclosure Keep Context Costs Low?

Agent Skills load in three tiers, and the token cost of each tier is what makes installing dozens of skills viable without drowning the context window (Anthropic Platform Docs, Agent Skills Overview, 2025). Level 1 metadata — just a skill's name and description — stays loaded at roughly 100 tokens per skill so the agent always knows what's available. Level 2, the actual SKILL.md body, only enters context once the agent matches a task to that skill, and stays under 5,000 tokens by convention. Level 3 — bundled scripts and reference files — costs close to zero until the agent specifically opens or runs them.

Cost scales with what a task actually uses, not with how many skills are installed. Source: Anthropic, Agent Skills Overview, 2025.

That tiering is the real difference from earlier "big system prompt" agent design. A team can install fifty skills covering fifty different workflows, and a task that only touches one of them pays for one skill's Level 2 cost — not fifty. The failure mode this replaces is the bloated system prompt that grows every time someone adds a new capability, until every request pays the token cost of instructions it never needed.

How Do Skills Differ From Tool-Calling and MCP?

Skills and MCP solve different halves of the same problem, and Anthropic is explicit that one doesn't replace the other: skills teach an agent how to carry out a workflow, while MCP gives it the connections to reach external systems in the first place (Anthropic Engineering Blog, Oct 2025). An MCP server might expose a "create spreadsheet" tool; a skill tells the agent your company's specific formatting conventions, which columns to include, and when to use that tool at all.

MCP itself has grown fast enough to make this distinction matter at scale. The protocol's public registry grew from an initial batch in September 2025 to roughly 2,000 entries by November 2025, with a Discord community of 2,900+ contributors and 58 maintainers adding 100+ new contributors weekly (Model Context Protocol Blog, Nov 2025). As more tools get exposed through MCP, the question of which tool to use and how to sequence a multi-step task becomes the harder problem — which is exactly the gap skills are built to fill.

A robotic hand reaching into a glowing digital network, representing an AI agent connecting to external tools through a protocol layer

The practical distinction engineers should hold onto:

Layer	What it provides	Analogy
MCP / tool-calling	Access to external systems and actions	The API
Agent Skills	Instructions for using that access correctly	The runbook
Fine-tuning	Behavior baked into model weights	Training the employee from scratch

Why Are Teams Choosing Skills Over Fine-Tuning?

Skills add a new capability for close to zero marginal context cost, while fine-tuning requires a retraining pass regardless of how often the new behavior gets used — and no independent, controlled study yet compares the two head-to-head on cost or latency, so that framing should stay qualitative rather than pinned to a specific dollar figure. What is well documented is the token accounting behind skills: Level 1 metadata at ~100 tokens and Level 2 instructions under 5,000 tokens, loaded only when needed (Anthropic Platform Docs, 2025). Fine-tuning carries that cost once, up front, whether or not the resulting behavior gets used on a given day.

This matters more given how often agentic projects stall before they ever reach the point where fine-tuning would pay off. Gartner's June 2025 analysis projects more than 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls (Gartner Newsroom, Jun 2025). A pattern that lets a team add or drop a capability by editing a markdown file — instead of committing to a training run before knowing whether the workflow is worth automating — fits that risk profile better.

For a deeper look at where fine-tuning still earns its cost versus lighter-weight context strategies, see the fine-tuning vs. RAG vs. prompting comparison.

What Do the Adoption Numbers Actually Show?

Adoption is broad but shallow, and that gap is exactly the space skills are trying to close. McKinsey's State of AI in 2025 survey — fielded June 25 to July 29, 2025 — found 88% of organizations now use AI in at least one business function, up from 78% a year earlier. But only 62% are experimenting with AI agents specifically, just 23% report scaling agentic AI in any function, and no more than 10% are scaling it in a given function (McKinsey & Company, 2025). Only 5.5% of surveyed organizations qualify as "AI high performers," meaning more than 5% of EBIT is attributable to AI.

Broad experimentation, thin scaling — the gap most agentic AI investment is currently stuck in. Source: McKinsey, State of AI 2025.

The picture from individual developers looks similar. Stack Overflow's 2025 Developer Survey — 49,000+ responses across 177 countries — found 84% of developers now use or plan to use AI tools, but only 14.1% use AI agents daily and 9% weekly; 37.9% have no plans to adopt agents at all (Stack Overflow, Dec 2025). Among developers who do use agents, 69% report a productivity increase, but only 17% say agents improved team-wide collaboration — the weakest-rated benefit in the survey. 87% are concerned about output accuracy and 81% about privacy and security of agent data handling.

It's worth being direct about a data gap here: Anthropic hasn't published adoption metrics specific to Agent Skills — no install counts, no percentage of Claude Code users with custom skills configured. The mechanism is well documented; how widely teams have actually adopted it isn't yet public.

What Are the Security Risks of Installing Third-Party Skills?

A skill is executable instruction, not passive documentation, and Anthropic's own documentation is direct about the resulting risk: skills should only be installed from trusted sources, because a malicious SKILL.md or bundled script can direct an agent to exfiltrate data or misuse its existing tool access. That's the same indirect-injection risk class covered in depth in the post on tool-calling and agent sandboxing security — a skill with a poisoned instruction set doesn't need to defeat a guardrail, because the guardrail was never built to inspect a file the agent was told to trust.

The practical implication: treat a new skill the way you'd treat a new dependency, not the way you'd treat a config change. Review the SKILL.md body and any bundled scripts before installing, pin skills to a specific version or commit rather than pulling from a mutable source, and apply the same read/write/destructive tiering to what a skill's bundled scripts can execute as you would to any other tool call.

How Should Engineering Teams Start Using Skills in Production?

Start by treating skills as versioned code, not prompt tweaks. A SKILL.md file belongs in git, reviewed in a pull request, with the same scrutiny given to a change in context engineering — because a badly worded description field is exactly the kind of subtle bug that causes an agent to silently pick the wrong skill, or none at all, for a given task.

Close-up of source code on a screen representing skill files managed as versioned engineering artifacts

A few concrete practices worth adopting early:

Write the description field for the router, not the reader. Level 1 metadata is what the agent matches against a user's task, so a vague description ("helps with documents") triggers less reliably than a specific one ("fills out the Q3 expense reimbursement PDF using the finance team's approved categories"). Test trigger accuracy the same way you'd test a retrieval system — with a labeled set of tasks and the skill you expect each one to select.

Keep Level 2 instructions scoped to one workflow. A SKILL.md that tries to cover five loosely related tasks makes triggering ambiguous and instructions harder to maintain. Smaller, single-purpose skills compose better — an agent can load three narrow skills for a multi-step task more reliably than it can correctly apply one sprawling one.

The failure teams hit first isn't a broken skill — it's two skills with overlapping descriptions that both look relevant to the same task, and the agent picks inconsistently between them. Auditing for description overlap before shipping a new skill catches this before it shows up as an intermittent bug report.

Instrument which skills actually get triggered. The same tracing discipline used for tool calls applies here — log which skill loaded for which task, and treat a skill that never triggers, or one that triggers on unrelated tasks, as a signal to rewrite its metadata rather than something to debug in the instructions body.

Frequently Asked Questions

Are Agent Skills the same thing as MCP tools?

No. MCP gives an agent access to external systems and actions; skills tell the agent how and when to use that access correctly for a specific workflow. Anthropic explicitly designed the two to work together — a skill can call tools exposed through MCP as part of its instructions (Anthropic Engineering Blog, Oct 2025).

Do installed skills slow down every agent request?

Not meaningfully. Only Level 1 metadata — roughly 100 tokens per skill — stays loaded for every request. The full instructions in Level 2 (under 5,000 tokens) load only when a task actually triggers that specific skill, so installing more skills doesn't add cost to unrelated tasks (Anthropic Platform Docs, 2025).

Is skills-based packaging replacing fine-tuning?

Not for everything. Skills add new workflow-level behavior for near-zero marginal context cost and no retraining, which fits capabilities that change often or need a fast iteration loop. Fine-tuning still has a place for changes that need to live in the model's weights rather than its context — see the fine-tuning vs. RAG vs. prompting comparison for where that line sits.

How risky is installing a third-party skill?

Meaningfully risky if the source isn't trusted, since a skill's instructions and bundled scripts execute with whatever tool access the agent already has. Anthropic's own documentation warns against installing skills from untrusted sources for exactly this reason — the same threat model covered in the post on agent sandboxing security.

Is there public data on how widely Agent Skills have been adopted?

Not yet. Anthropic's October 2025 launch documentation and platform docs describe the mechanism in detail but publish no install counts, active-user figures, or adoption percentages. Broader agentic AI adoption data exists — McKinsey found only 23% of organizations are scaling agentic AI in any function — but nothing skill-specific has been published as of this writing.

Conclusion

Skills fill a gap that both raw tool-calling and fine-tuning left open: a way to give an agent new, well-scoped behavior without either bloating every prompt or committing to a retraining cycle. The token accounting behind progressive disclosure — ~100 tokens of always-on metadata, under 5,000 tokens loaded only on trigger — is what makes that gap closeable at all.

The adoption data says this pattern is arriving at the right moment. 88% of organizations use AI somewhere, but only 23% are scaling agents anywhere, and Gartner expects 40% of agentic projects to be canceled by 2027 over unclear ROI. A mechanism that lets a team add or remove a capability by editing a markdown file, instead of committing to a training run before knowing if the workflow is worth automating, matches exactly the risk profile those numbers describe.

If you haven't yet mapped where tool-calling access needs sandboxing in your own agent stack, treat that as the prerequisite — a skill only inherits the permissions your agent already has, for better and for worse.

Sources