Most people think of AI agents as smarter chatbots.
They're not. The difference isn't intelligence — it's capability.
A chatbot generates text. An agent takes actions. And the thing that determines what actions an agent can take is its set of skills.
The Basic Definition
An agent skill is a discrete, callable capability that an agent can invoke to interact with the world outside its context window.
Skills are how an agent:
- Reads and writes files
- Searches the web
- Calls APIs
- Runs code
- Queries databases
- Controls a browser
- Sends messages
- Delegates to other agents
Without skills, an agent can only produce text. With skills, it can produce outcomes.
Skills vs. Tools vs. Functions
These terms are often used interchangeably. The distinction that matters in practice:
Tools are the raw primitives — a function definition the model can call, with a name, description, and parameter schema. The model decides when to call it and with what arguments.
Skills are higher-order compositions of tools. A "research skill" might orchestrate: web search → read page → extract key facts → summarise → store result. The agent doesn't think about the individual steps — it invokes the skill.
Functions are the implementation — the actual code that runs when a tool is called.
In practice, "skill" is the most useful unit to reason about when designing agent behaviour, because it maps to a coherent task rather than an atomic action.
Why Skills Shape Agent Quality
The quality of an agent system is largely determined by the quality of its skill definitions — not the model.
A well-defined skill has:
- A clear name the model can recognise in context
- An accurate description of when to use it and what it does
- Typed parameters so the model knows exactly what to pass
- Predictable output the model can reason about in the next step
A poorly defined skill gets called at the wrong time, with bad arguments, producing unexpected results that the model then hallucinates around.
Most "the AI hallucinated" complaints in agentic systems are actually skill definition failures.
Skill Scope: Atomic vs. Composite
Atomic skills do one thing. search_web(query). read_file(path). send_email(to, subject, body). They're easy to reason about and debug.
Composite skills chain multiple actions into a single invokable capability. research_topic(topic) might run three searches, read five pages, deduplicate facts, and return a structured summary. The model calls it once and gets back a complete result.
The right scope depends on the task. Atomic skills give the model more control but require more reasoning steps. Composite skills are faster and less error-prone for well-defined subtasks.
How I Use Skills in Practice
In the multi-agent pipelines I build — for Montr AI and client projects — skills serve three purposes:
1. Encapsulation. Complex multi-step operations become single callable units. The orchestrator agent doesn't need to understand how content is scored — it just calls score_content(text, criteria) and gets a result.
2. Specialisation. Different agents in a pipeline have different skill sets. A research agent has web search and document reading skills. A writing agent has content generation and revision skills. Neither has access to the other's tools — which prevents cross-contamination and keeps context clean.
3. Reuse. A skill defined once can be used across agents, pipelines, and projects. The publish_to_cms(content, metadata) skill works the same whether it's called by a content agent or a deployment agent.
The Skill Design Question
When I'm adding a skill to an agent, the question I ask is:
Is this something the agent should decide when to do, or something it should always do?
If the agent should decide — it's a skill.
If it should always happen — it's a pipeline step, not a skill.
The distinction matters because skills consume model attention. Every callable skill the model has to consider adds to its decision-making load. A cluttered skill set produces worse decisions than a focused one.
Less is more. Define fewer, clearer skills and the agent performs better.
What's Coming
The evolution from "tools" to "skills" to "skill libraries" is already underway. Projects like Claude Code, OpenAI's tool use APIs, and frameworks like LangChain and CrewAI are all converging on the same idea: the value of an agent is in its composable, reusable capability layer.
The next step is skill marketplaces — shared, versioned, audited skill libraries that agents can pull from on demand, the same way developers pull packages from npm.
We're not there yet. But the direction is clear.
The agent that ships is the one with the right skills for the job — not the one with the largest model.