The terms tool, skill, and plugin are used differently across every agent platform. Some platforms call everything a plugin. Some call everything a tool. Some distinguish them by whether they are native or third-party, others by whether they are versioned or one-off. The result is that most operators have a rough mental model that works until it does not — and then they spend an hour debugging a problem that stems from confusing the three layers entirely.
Triadive's distinction is sharp:
- Tools are atomic runtime functions. The agent calls them during execution.
- Skills are curated, versioned bundles of prompts and knowledge that the operator composes.
- Plugins are packaged distributions of tools and skills that install as a unit.
All three are extensions. They extend what the agent can do. But they operate at different layers, serve different purposes, and have different failure modes.
Why the confusion is not accidental
The terms were not standardized because the problem they describe was not understood when the platforms were built. Early agent runtimes had one extension layer: the tool. You added a tool, the agent could call it. That was the whole surface area.
Skills emerged when operators realized that a tool call without context is a commodity — the same tool behaves differently depending on what prompt is active, what files are loaded, and what the agent's role is supposed to be. A skill wraps the tool with the prompt discipline that makes the tool reliable.
Plugins emerged when someone wanted to ship a skill and its tools as a single installable unit — to share it, version it, and install it without rebuilding the bundle from scratch every time.
Each layer appeared as a reaction to the limits of the one below it. The confusion exists because platforms did not always build all three layers, or built them inconsistently, or used the terms interchangeably when implementing them.
Tools: what the agent calls at runtime
A tool is a function the agent can invoke during its agent loop. The agent decides to call the tool, passes arguments, receives output, and continues. The tool is atomic: it does one thing, returns one result, and holds no memory of prior calls.
The tool layer is where the agent meets the outside world. File reads, web searches, code execution, sending a message — these are all tool calls. A tool that cannot be called at runtime is not a tool; it is just code.
Tools vary in sophistication:
- Stateless tools take an input, return an output, and are safe to call any number of times. Reading a file is a stateless tool.
- Stateful tools modify state on behalf of the agent. Writing a file is a stateful tool — the agent must reason about when to call it and what to write.
- Blocking tools pause the agent loop until the operation completes. Most tools are blocking. Long-running operations (a cron that fires after 20 minutes, a download that takes 5 minutes) may be non-blocking by design.
The critical operator insight is that a tool's behavior is not fixed. The same tool call can produce different results depending on the agent's current role, the context loaded at intake, and what the prompt explicitly instructs about how to use the tool. A tool is a capability; a skill is what makes that capability reliable.
Skills: curated prompt+knowledge bundles
A skill is a versioned bundle that the operator composes for a specific domain or task. It contains:
- One or more prompt templates that define how the agent should approach the task.
- Knowledge files — reference material the agent reads when the skill is active.
- Metadata — versioning, authorship, a description of what the skill is for and when to activate it.
Skills are the operator's composition layer. The agent loop runs regardless; the skill tells the agent how to run it in this particular context.
The failure mode of skills without versioning is identical to the failure mode of prompts without discipline: the skill degrades over time. Someone updates the prompt template, forgets to version it, and the agent starts behaving slightly differently. The next session loads the modified skill and produces different output. Nobody recorded why the change was made. That is how a workspace drifts from a skill it trusts to a skill it no longer understands.
Plugins: installable distributions of tools and skills
A plugin is a packaged unit that contains one or more tools and optionally one or more skills, along with installation logic, configuration, and metadata. The plugin is what turns a shared skill into something an operator can install in one step and trust to behave consistently.
The three-layer model — tool, skill, plugin — maps directly to the trio that drives any agent stack: the runtime (tools), the composition (skills), and the distribution (plugin).
The failure mode of treating a plugin as just a "bunch of tools" is that you lose the composition layer. A plugin that ships 20 tools and no skill guidance is a pile of capabilities with no discipline. The agent can call every tool, but it has no instruction for when to call which, or how to interpret the results. That is an architectural problem, not a tool problem.
The operational failure mode of confusing the three layers
The most common operational failure looks like this:
The operator installs a plugin, activates it, and sees the tools appear in the agent's available set. The operator then asks the agent to do something that requires the tool — and the agent calls it incorrectly, at the wrong time, or with wrong arguments. The operator concludes the plugin is broken.
In most cases, the plugin is not broken. The plugin installed correctly. The tools are available. The problem is that the plugin shipped no skill guidance for how the tool should be used in context, and the operator did not write a skill to provide that guidance.
The fix is not to find a better plugin. The fix is to add the missing skill layer — a prompt bundle that tells the agent when to call the tool, what arguments to pass, what the output means, and what to do with it.
This is the core architectural insight: a plugin without a skill is capability without discipline. The skill is what converts "can do" into "does reliably."
What each layer is responsible for
| Layer | Responsibility | Failure mode | |---|---|---| | Tool | Runtime capability | Tool calls wrong, wrong time, wrong arguments | | Skill | Context and composition | Agent behaves inconsistently across sessions | | Plugin | Distribution and versioning | Installs wrong version, breaks other plugins |
Each layer has its own failure mode, and each is solved at its own layer. You do not fix a skill problem with a plugin update. You do not fix a tool problem by writing a better prompt.
How the layers compose in practice
A well-designed extension stack looks like this:
The operator installs a plugin. The plugin brings tools (capabilities) and optionally ships with a default skill (basic composition). The operator then customizes the skill — adds workspace-specific knowledge, adjusts the prompt templates, sets the activation context — and that customized skill tells the agent how to use the plugin's tools correctly in this specific workspace.
The agent loop runs the same way whether a plugin is installed or not. The loop decides, executes, evaluates. The plugin's tools are available to call. The skill is what shapes which tools get called, when, and with what interpretation of the results.
Scheduled work — cron jobs, heartbeats, standing workflows — is one of the places where this composition becomes most visible. A cron job activates a skill for a specific task at a specific time. The skill tells the agent which tools to use, in what order, and what output to produce. Without the skill, the cron job fires and the agent has no composition guidance — it falls back to its default behavior, which may be wrong for the task.
A note on the first plugin decision
When you are choosing the first plugin to keep, the question is not which plugin has the most tools. The question is which plugin has a tool you need and a skill that teaches you how to use it correctly. A plugin with three tools and a well-written default skill is worth more than a plugin with twenty tools and no composition guidance.
The three layers matter because the third layer — the skill — is what makes the first layer useful.