
Agent Skills vs AI Agents: What Each One Does for Your Team
A skill holds your team's method, an agent carries out multi-step work, and a connection reaches your data. Here is how to tell which one a task needs first.
Anthropic's documentation lists an agent's parts as a model, system prompt, tools, connections and skills, so a skill is part of an agent and no rival to it.
The practical question for a small team is whether the AI it already uses needs a better method, which a skill supplies, or a new worker with its own tools.
How skills, agents and connections fit together
The three pieces answer different questions. An agent decides what happens next, a skill says how your company does a task, and a connection reaches the system that holds the data.
The agent decides what happens next
Anthropic's engineering team separates two kinds of AI system. In a workflow, the model and its tools follow predefined code paths. An agent dynamically directs its own process and tool use: it takes a goal, picks the next step, calls a tool, reads the result and decides whether it is done.
A skill holds the method
A skill is a packaged method the agent loads when a task calls for it: instructions, examples and sometimes scripts for one kind of job. Anthropic's Skills explained post draws the line in one sentence: use skills to teach expertise that any agent can apply, and use subagents when you need independent task execution.
A connection reaches the data
A Model Context Protocol (MCP) connection gives the agent access to a system such as your CRM, shared drive or database. The same Anthropic post sums up the pairing: MCP connects Claude to data, and skills teach Claude what to do with that data. A skill without a connection can format a proposal; it cannot look up the client's last order.
What is inside a skill
A skill is a folder with one required file, SKILL.md. Its header needs a name of up to 64 characters and a description of up to 1,024 that says what the skill does and when to use it.

Supporting files in the folder
The Agent Skills specification names three optional folders: scripts/ for code the agent can run, references/ for documents it reads when needed and assets/ for templates, images and data files. For a business, the proposal template, the approved boilerplate and the review checklist can sit in one place, where every person and every agent finds the same version.
The description decides when it is used
At startup the agent sees only each skill's name and description. Anthropic's documentation says the description is what Claude matches a request against when deciding whether to trigger the skill, so it has to say both what the skill does and when to use it. A skill with a vague description can sit unused while the team wonders why the AI ignores its rules; our guide to creating agent skills covers how to word one.
Why a library of skills does not slow the agent down
Skills load in stages, which the specification calls progressive disclosure. A team can keep separate skills for proposals, recaps and supplier reviews without loading every rule into every chat.
Three loading levels
The Agent Skills documentation puts a cost on each stage: about 100 tokens per skill at startup, a recommended ceiling of 5,000 tokens for the instructions once a skill is triggered, and none for bundled files until they are read.
Tokens are the units a model reads, and each conversation has a limited budget of them, called the context window. By that estimate, ten installed skills take about 1,000 tokens before anyone asks for anything, and only the skill a task triggers adds its instructions. The specification recommends keeping the main SKILL.md under 500 lines and moving detailed reference material into separate files.
Scripts return only their output
The third level also covers code. When instructions point to a script, Claude runs it through bash and receives only the output; the documentation says the script code itself never enters the context window. Only a result such as "Validation passed" or a specific error message uses tokens, which is why a script is a cheap way to make one step of a skill exact and repeatable.
The listing still has a cost
Progressive disclosure does not make a skill library free. Claude Code's skills documentation says every skill in the listing adds to the context on every turn, whether or not Claude ever uses it, and it cuts each skill's combined description and when_to_use text at 1,536 characters in that listing. A skill can also stay out of that listing: with disable-model-invocation set to true, Claude Code keeps its description out of context, and the skill loads only when someone runs it by name. Retire skills nobody uses, and put the key use case first in each description.

What an agent is made of
Anthropic's documentation lists the parts of an agent, and Claude Code shows a real agent definition in a short file that looks a lot like a skill, with two lines more.
Model, prompt, tools and skills
In Claude Managed Agents, Anthropic's hosted agent service, an agent is the model, system prompt, tools, MCP servers and skills. It runs in an environment, either a cloud sandbox Anthropic manages or one you host, and each run on a specific task is a session. Anthropic lists tasks that run for minutes or hours with multiple tool calls among the work it is built for.
A real subagent file
The Claude Code subagent documentation shows a complete agent definition, a code reviewer: it opens with a name and description like a skill, then adds a tools line limiting it to Read, Glob and Grep, and a model.
The body under that header becomes the subagent's system prompt. The documentation says subagents receive only that prompt plus basic environment details, such as the working directory, and each one runs in its own context window with its own tool access and permissions. When it finishes, its results return to the main conversation. If the tools line is left out, the subagent inherits every tool available to subagents, so that line is where a narrow agent starts.
What the extra autonomy costs
Anthropic's Building effective agents post says agentic systems "often trade latency and cost for better task performance." In Claude Code, a subagent's requests also count toward the same usage limits as the main conversation, so each extra worker draws on the same budget.
When a skill is enough
Anthropic's advice is to find the simplest solution possible and add complexity only when needed. When the AI already does the task but not in the house style, that solution is a skill.
Signs the method is what is missing
A skill fits when these hold:
- The same kind of output is produced again and again, such as proposals, reports or summaries.
- Quality depends on house rules: tone, structure, required sections, things to never say.
- A person starts the task and reviews the result.
- The steps are known; what is missing is the method.
- The work happens in one conversation with back-and-forth, which Claude Code's documentation keeps in the main conversation.
Example: client recaps
A six-person accounting office writes a recap after every client call. A skill holds the recap format, the rule that every action item gets an owner and a date, and two past recaps the partners liked. Staff paste their notes, the AI loads the skill, and the recap comes out in the same shape each time, with a person checking it before it goes out.
Check where the skill will run
A skill's reach depends on the product. Anthropic's documentation says skills on the Claude API run without network access and cannot install packages, network access in claude.ai depends on user and admin settings, and Claude Code skills have the same network access as any other program on the computer. Custom skills also do not sync across surfaces: one uploaded in claude.ai must be uploaded separately to the API, and Claude Code skills are separate from both.
When you need an agent
The case for an agent starts when the work has to run on its own: several steps, choices between tools, and output too long to keep in the conversation where the request began.
Signs the work needs its own worker
Anthropic says agents suit open-ended problems where it is difficult or impossible to predict the required number of steps. Claude Code's documentation adds three signs for handing a task to a subagent:
- The task produces verbose output you do not need in the main conversation.
- You want to enforce specific tool restrictions or permissions.
- The work is self-contained and can return a summary.
The same page keeps work in the main conversation when it needs frequent back-and-forth, when several phases share a lot of context, or when latency matters, because a new subagent starts fresh and may need time to gather context.
Example: supplier research
A small manufacturer needs three packaging suppliers compared against a list of requirements. An agent searches, reads each supplier's pages, notes gaps and returns a table with sources. It loads a supplier review skill for the method, uses an MCP connection to save the table in the shared drive, and a buyer reviews it before anyone is contacted.
When the steps never change
If the steps are always the same, such as copying a web form into the CRM and sending a confirmation, the job is a workflow, and nobody pays for judgment the task does not need. Our post on agents and workflows covers that choice in depth.
How skills and agents work together
Skills and agents combine in both directions. An agent can start with skills already loaded, and a skill can hand its task to a separate agent that runs it in a clean context.
An agent that carries skills
A Claude Code subagent can preload skills through a skills field in its header. The documentation says the full skill content is injected at startup, where a regular session loads only the description until the skill is used, and the subagent can still call other skills it finds. In Managed Agents, skills are attached in the agent's skills array.
A skill that runs as an agent
Going the other way, a skill with context: fork in its header runs in a new subagent, of the type named in its agent field. That subagent does not see the conversation history, so the documentation warns that the skill's instructions have to stand on their own. This suits a research or summary task that would otherwise fill the main chat with search results.
Matching the problem to the piece
When a request comes in, start from the problem the team describes and match it to one piece:
| If the problem is… | Build… |
|---|---|
| "The AI does not do it our way" | A skill |
| "The AI cannot see our data" | An MCP connection |
| "The task floods the chat or needs its own tool limits" | An agent |
| "The steps never change" | A workflow |
Treat skills and agents like software you install
A skill can include scripts and an agent can call tools, so both can act on your systems. Each one deserves the review you would give a browser extension with access to company files.
Trusted sources and full audits
Anthropic's Agent Skills documentation advises using skills only from trusted sources, such as ones you created or obtained from Anthropic, and auditing every bundled file of any other skill: SKILL.md, scripts, images and other resources. A malicious skill can direct Claude to call tools or run code in ways that do not match its stated purpose.
Content fetched from outside
The same page singles out skills that fetch data from external URLs, since the fetched content might contain malicious instructions, and warns that even a trustworthy skill can be compromised if its external dependencies change. For a team, that means keeping skills in a shared, version-controlled folder and reviewing each change before it reaches everyone.
Tool limits for agents
For agents, the tools line is the first control. Claude Code's own built-in subagents follow that rule: the two that research a codebase run read-only, and the general-purpose one gets every tool. Claude Code's subagent page lets a definition list allowed tools, deny specific ones and set a permission mode, so a research agent that only reads can run without write or command tools. Claude Enterprise organizations can also turn on content scanning for custom skills uploaded in claude.ai and Claude Cowork; the documentation says scanning does not cover skills uploaded through the Skills API or the Claude Console.

FAQs About Agent Skills and Agents
Short answers on whether skills work outside Claude, how skills combine, whether agents can start other agents and how Anthropic retains skill data, as documented in November 2026.
Are skills only for Claude?
No. The Agent Skills site says the format was originally developed by Anthropic, released as an open standard and adopted by a growing number of agent products. Check that the tools your team uses can load skills before building a large library.
Can one agent use several skills?
Yes. An agent can load a research skill for one step and a formatting skill for the next, and each one loads its instructions only when its description matches the task.
Can an agent start other agents?
In Claude Code, yes. By default a subagent can start subagents of its own, up to three layers below the main conversation. Leaving the Agent tool out of a subagent's tool list stops it from starting any.
Does Anthropic keep skill data?
Anthropic's documentation says Agent Skills are not covered by zero data retention arrangements, and skill definitions and execution data are kept under its standard retention policy. Keep confidential records in your own systems and reach them through connections with proper permissions.
Start with the piece the task needs
If your team gets inconsistent results from an AI it already uses, start with a skill. If the work needs its own tools and context, it needs an agent, and both may need a connection.
Our AI agents and skills service builds either one, tested on your real cases, and our MCP tools and integrations service adds the data access. Show us the task and an example of good output, and we will tell you which piece it needs.
Last checked: November 16, 2026, against Anthropic's Agent Skills documentation, the Agent Skills specification and overview, Claude Code's skills and subagents documentation, the Claude Managed Agents overview, and Anthropic's Skills explained and Building effective agents posts. Products change; check the linked pages before relying on a detail.
Technical details come from Anthropic's documentation and the Agent Skills site, checked November 16, 2026.



