Whether your team runs Atlan’s MCP Server, GitHub’s, or one built with LangChain, CrewAI, or Arcade.dev, the tool-vs-skill boundary shows up first as a token bill: a single server can expose 90-plus tools and 50,000-plus tokens of schema before your agent reads one message. A skill composes those calls into judgment about sequence; a tool alone never does.
| Dimension | Tools (function calling) | Agent skills |
|---|---|---|
| What it is | A single callable function: name, description, input/output schema | A folder of instructions (SKILL.md) that packages procedural knowledge |
| What it does | Executes one discrete action | Decides which tools to call, in what order, and why |
| Layer | Execution | Procedure and orchestration |
| Format | Function with JSON schema | Frontmatter plus SKILL.md body plus optional scripts and resources |
| Best for | Single, well-defined API calls | Repeatable multi-step workflows with judgment calls |
| Question it answers | What does this call do? | Which tool, when, and in what sequence? |
| Token cost | Full schema loaded per tool, every turn (5,000-50,000-plus tokens for large tool sets) | Metadata about 100 tokens; instructions under 5,000 tokens load only when triggered |
Inside Atlan AI Labs and the 5x Accuracy Factor
Both depend on the data they touch being current. See how governed context drove a 5x accuracy gain.
Download E-BookAgent skills vs tools: what’s the difference?
Permalink to “Agent skills vs tools: what’s the difference?”A tool executes one discrete action with a defined input and output. An agent skill decides which tools to call, in what order, and under what conditions, the newest rung in the skill engineering lineage. Anmol Tomer puts it plainly: “Tools = functions. Skills = capabilities.” Akshay Kokane draws the same line: a tool is extract_text_from_pdf(file); a skill sequences which tools a PDF task needs, plus the post-processing that follows.
Anthropic published Agent Skills as an open standard on December 18, 2025, driven by schema bloat: a single GitHub MCP server can expose 90-plus tools, consuming 50,000-plus tokens of JSON schema overhead before a single user message is processed, per Alex Salazar of Arcade.dev. Layered System’s analysis measured the same server at 60 tools, 60 to 65 percent sharing identical field definitions, schema duplication driving the bloat more than raw tool count. Skills manage that overhead by loading full instructions only when a task triggers them.
AIQuinta argues that “the distinction between an Agent ‘Tool’ and an Agent ‘Skill’ is largely a semantic convenience rather than a technical necessity, as in many advanced LLM frameworks, a ‘skill’ is simply a high-level abstraction of a tool call.” That holds in some frameworks, where a skill is built as one meta-tool. But the reader-facing question survives: is this one deterministic call, or a place where the agent exercises judgment over sequence and necessity? Atlan’s enterprise skills governance guide already maps this boundary against a third primitive, MCP, in a three-way table this page’s composition mechanic extends.
What is a tool in AI agent development?
Permalink to “What is a tool in AI agent development?”A tool is a single, callable function: a name, a description, and an input/output schema. The agent decides to call it, but the call itself is a deterministic, one-shot action with no internal branching. Claude’s Tool Use overview frames it the same way: the application executes the operation once Claude decides to call it, and the result returns as a tool result.
The cost of this shape shows up at scale, not in a single call. Arcade.dev’s 90-plus-tools, 50,000-plus-token figure and Layered System’s SEP-1576 schema-duplication finding converge on the same problem: every available tool’s full schema loads into context on every turn, whether or not the agent calls it. MCP standardizes how a tool is delivered and authenticated without changing that one-input, one-output shape. See MCP vs. function calling, when to use MCP vs. an API, why MCP matters for AI agents, and the MCP server implementation guide for the delivery mechanics.
Core components of a tool call
Permalink to “Core components of a tool call”- Name: the function identifier the agent references when it decides to call the tool
- Description: natural-language text explaining what the tool does and when to use it
- Input schema: the defined parameters, typically JSON, the agent must supply before the call executes
- Output: the single, structured result returned to the agent once the call completes
For a deeper look at how agents apply tools in practice, see AI agent tool use.
What is an agent skill?
Permalink to “What is an agent skill?”An agent skill is a SKILL.md file plus optional scripts and resources an agent loads to decide which tools to reach for, in what order, and why. Barry Zhang, co-creator of Agent Skills at Anthropic, puts it simply: “Skills are organized collections of files that package composable procedural knowledge for agents. In other words, they’re folders.” Anthropic’s own Agent Skills overview puts the composition claim outright: skills exist to “compose capabilities: combine Skills for complex, multistep tasks.”
Progressive disclosure keeps this affordable: metadata (Level 1) costs about 100 tokens and stays loaded; instructions (Level 2) cost under 5,000 tokens and load only once triggered, per the Agent Skills overview. An arXiv preprint, SoK: Agentic Skills, frames skills as “callable modules that package procedural knowledge with explicit applicability conditions, execution policies, termination criteria, and reusable interfaces,” contrasted against “one-off plans or atomic tool calls.”
Core components of an agent skill
Permalink to “Core components of an agent skill”- Frontmatter (Level 1): name and description metadata, always loaded, about 100 tokens
SKILL.mdbody (Level 2): the instructions the agent reads once triggered, under 5,000 tokens- Bundled scripts and resources (Level 3): the tools and files the instructions point toward
- Sequencing logic: the judgment the
SKILL.mdbody encodes about which tool to call first, and when
A skill’s sequencing logic runs against whatever context layer tools the agent has access to, and is only as sound as the context engineering tools and enterprise AI context management tools feeding it. For how those stack up, see context layer tools compared.
Agent skills vs tools: how do they compare head-to-head?
Permalink to “Agent skills vs tools: how do they compare head-to-head?”The sharpest difference is who decides what happens next. Clelia Astra Bertelli and Tuana Çelik of LlamaIndex put it cleanly: “For the agent, the challenge it faces with an MCP tool is deciding which tool to run and when only. Whereas the challenge it faces with a skill is to decide which skill to use, when, and how.”
| Dimension | Tools (function calling) | Agent skills |
|---|---|---|
| Decision the agent faces | Which tool to run, when, only | Which skill to use, when, and how |
| Granularity | One action, one call | One or more tool calls, sequenced |
| Where judgment lives | Outside the call, in the agent’s per-turn reasoning | Inside the SKILL.md body, as pre-authored sequencing logic |
| State across steps | Stateless; each call is independent | Tracks what’s already been checked across a sequence |
| Failure mode | Wrong single call, wrong single result | Wrong sequence or wrong condition, compounding across steps |
| Update mechanism | Change the function’s schema or code | Edit the SKILL.md body’s instructions |
| Token cost per invocation | Full schema loaded every turn | Metadata always-on (~100 tokens); full body loads only when triggered |
| Composability | Not composable; the agent composes calls itself | Designed to combine with other skills for multistep tasks |
| Governance surface | Permission scope on the single call | Ungoverned reach across every tool the skill sequences |
Anthropic’s pdf-processing skill makes this concrete: Claude reads SKILL.md, decides whether the task needs form-filling, then runs fill_form.py, a bundled script, the mechanic sources in this cluster name “skills orchestrate tools” without showing how.
The pattern generalizes past PDFs: inside an AI agent framework or an agent harness, the boundary sits underneath both. Drag-and-drop agent builder tools increasingly expose both side by side.
How do agent skills and tools work together?
Permalink to “How do agent skills and tools work together?”A skill and a tool aren’t competing choices; a skill is only useful because it eventually calls a tool. Three patterns describe how that handoff works.
A skill sequencing a fixed pipeline
Permalink to “A skill sequencing a fixed pipeline”A skill’s SKILL.md body has the agent call tool A, inspect the result, then decide whether tool B is needed, the pattern pdf-processing generalizes.
A skill reducing schema overhead across a large tool surface
Permalink to “A skill reducing schema overhead across a large tool surface”A skill’s instructions, loaded only when triggered, reference just the tools a task needs, instead of loading 90-plus schemas per turn.
MCP as the delivery surface both draw on
Permalink to “MCP as the delivery surface both draw on”MCP standardizes how a tool is exposed and authenticated. A skill can call tools via MCP, API, or any protocol, the access and protocol boundary covered in full on Agent Skills vs MCP.
Tool alone: a single, well-defined action, one API call. Build a skill: the same sequence keeps repeating, or the order or necessity of calls depends on conditions the agent evaluates. One caveat: a capability used 100% of the time belongs in the system prompt, not a skill.
Not every practitioner agrees: one scan of Japanese-language AI discussion ranked MCP and tool access as more foundational than skills for enterprise builds. Neither layer replaces how to standardize AI tooling across business units, the question above both. Harness engineering builds the control system a skill runs inside, distinct from harness engineering vs. prompt engineering and the skill engineering vs. prompt engineering comparison up a level. Sequencing decisions also lean on a semantic layer or knowledge graph tools to know what a result means.
Neither a tool’s schema nor a skill’s instructions certify what a tool call returns, a separate, governed layer where this page’s argument starts.
AI Agent Context Readiness Checklist
Check whether your skills' and tools' data is ready for production agent use.
Check ReadinessReal stories from real customers: context behind every tool call
Permalink to “Real stories from real customers: context behind every tool call”"We're excited to build the future of AI governance with Atlan. All of the work that we did to get to a shared language at Workday can be leveraged by AI via Atlan's MCP server…as part of Atlan's AI Labs, we're co-building the semantic layer that AI needs with new constructs, like context products."
— Joe DosSantos, VP of Enterprise Data & Analytics, Workday
"Atlan is much more than a catalog of catalogs. It's more of a context operating system…Atlan enabled us to easily activate metadata for everything from discovery in the marketplace to AI governance to data quality to an MCP server delivering context to AI models."
— Sridher Arumugham, Chief Data & Analytics Officer, DigiKey
Neither quote is about the tool/skill boundary directly; both point at the same layer underneath, the MCP server and semantic layer a skill’s tool calls run against.
See It in Action: Live Context Layer Demos
Watch how teams connect governed context to the agents, skills, and tools depending on it.
Watch the DemosHow Atlan approaches agent skills and tools
Permalink to “How Atlan approaches agent skills and tools”Every source in this cluster treats “did the skill correctly decide to call the tool” as the only question, never “was what it retrieved actually current or certified.” A skill can sequence tool calls flawlessly and still hand the agent a stale or uncertified answer, sequencing logic and data trust being two separate problems that look like one.
The context-layer architecture names Skills as one of three parts of the context foundation, alongside AI-Ready Data and Knowledge Graph and Semantics and Ontology: “A skill is the new primitive that does for procedural knowledge what code did for logic in software.” It separates the protocol layer skills and tools draw on from the governed layer underneath: “One Context Layer. Many Protocols. Many Tools.” MCP is one delivery protocol a skill’s tool calls can run through; the MCP server is the concrete surface, and the enterprise data graph behind it certifies what comes back.
This mirrors a distinction practitioners already draw: a registry tells you a capability exists; a trust layer tells you whether what it returns is true, developed in full in governed context for agent skills. As tool surfaces keep growing, the composition layer skills provide will matter more, not less. That discipline, Build, Test, Review, Approve, Deploy, Learn, is the same rigor already applied to the agent harness a skill runs inside, and to what the enterprise context layer actually is.
FAQs about agent skills vs tools
Permalink to “FAQs about agent skills vs tools”1. What is the difference between agent skills and tools?
Permalink to “1. What is the difference between agent skills and tools?”A tool is a single, deterministic function call: one input, one output. An agent skill is procedural knowledge deciding which tools to call, in what sequence, and under what conditions. Tools execute; skills orchestrate.
2. Is an agent skill just a wrapper around tool calls?
Permalink to “2. Is an agent skill just a wrapper around tool calls?”In some frameworks, yes, architecturally. But the distinction holds: a tool call is one deterministic action; a skill’s SKILL.md body makes a judgment call about sequence and necessity.
3. Can a skill call multiple tools?
Permalink to “3. Can a skill call multiple tools?”Yes. That’s the defining feature of a skill: its instructions direct an agent to call one tool, inspect the result, and decide whether another call is necessary.
4. Are Claude Skills the same as tools?
Permalink to “4. Are Claude Skills the same as tools?”No. Claude’s tool use lets the model call a single defined function with a schema. Agent Skills are a separate primitive: folders directing the model to use tools in sequence, with conditional logic a raw call doesn’t encode.
5. What’s the difference between a skill and a subagent?
Permalink to “5. What’s the difference between a skill and a subagent?”A skill is instructions a single agent loads to guide its own tool use. A subagent is a separate agent process with its own context window, invoked for a delegated task. The two combine but solve different problems.
6. How do skills reduce token usage compared to tool schemas?
Permalink to “6. How do skills reduce token usage compared to tool schemas?”A tool’s full schema loads every turn it’s available, costing up to 50,000-plus tokens across a large tool set. A skill’s metadata costs roughly 100 tokens and stays loaded; instructions load only once triggered, keeping most cost off the context window.
7. Does Atlan’s context layer make tool calls inside a skill more reliable?
Permalink to “7. Does Atlan’s context layer make tool calls inside a skill more reliable?”Yes. A skill’s sequencing logic decides which tool to call. Atlan’s context layer governs whether the data returned is current and safe to act on, problems a skill’s instructions alone can’t solve.
Sources
Permalink to “Sources”- Agent Skills Overview, Claude Platform Docs. https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
- Tool Use Overview, Claude Platform Docs. https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview
- Equipping agents for the real world with Agent Skills, Anthropic. https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
- Skills vs Tools for AI Agents: Production Guide, Arcade.dev. https://www.arcade.dev/blog/what-are-agent-skills-and-tools/
- MCP Tool Schema Bloat: The Hidden Token Tax, Layered System. https://layered.dev/mcp-tool-schema-bloat-the-hidden-token-tax-and-how-to-fix-it/
- Skills vs MCP tools for agents: when to use what, LlamaIndex. https://www.llamaindex.ai/blog/skills-vs-mcp-tools-for-agents-when-to-use-what
- Tools & Agent Stack: MCP, Skills, Hooks Explained, Medium. https://medium.com/@anmol_tomer/tools-the-agent-stack-mcp-skills-hooks-explained-82d7b661de81
- Skill.md vs. Agent Tools: Are We Reinventing the Wheel?, Medium/Data Science Collective. https://medium.com/data-science-collective/skills-md-vs-agent-tools-are-we-reinventing-the-wheel-1eb0308110a2
- Agent Tools vs Agent Skills: Practical Differences, AIQuinta. https://aiquinta.ai/blog/agent-tools-vs-agent-skills-practical-differences/
- SoK: Agentic Skills: Beyond Tool Use in LLM Agents, arXiv. https://arxiv.org/abs/2602.20867
- Agent Skills Overview, agentskills.io. https://agentskills.io/home
- Skills for organizations, partners, the ecosystem, Hacker News. https://news.ycombinator.com/item?id=46315414
