An Agent Skill is a reusable package that tells an AI agent how to perform a specialised class of work. It is not an identity, permission grant, connector protocol, or orchestration graph. The clean mental model is: agents own identity, Skills own method, tools own capabilities, MCP exposes capabilities, prompts supply the immediate request, and workflows coordinate execution.
That distinction is operational, not semantic. When all six concepts are collapsed into one system prompt, teams cannot reliably answer who is acting, what the actor may access, which procedure was followed, or where a failure should be fixed.
The six layers at a glance #
| Layer | Primary responsibility | Typical change cadence | Security authority |
|---|---|---|---|
| Agent | Identity, role, model, and runtime configuration | Occasional | Receives governed configuration |
| Skill | Repeatable procedure and supporting resources | Versioned | Declares needs; grants nothing |
| Prompt | Immediate goal and conversation context | Every request | None |
| Tool | A callable capability | Integration lifecycle | Enforced by platform and connector |
| MCP | A protocol for exposing tools and context | Protocol and server lifecycle | Server and client policy |
| Workflow / Network | Ordering, routing, approval, and recovery | Process lifecycle | Orchestration policy |
The important line is between declaration and authority. A research Skill can say that web search is useful. That declaration must never silently provision search, reveal a private connector, or widen the current user’s scope.
Agent Skill vs prompt #
A prompt usually contains the immediate job: “Compare these suppliers against our resilience criteria.” It may include documents, constraints, and a desired format. That request should remain specific to the moment.
A Skill carries the maintained operating method behind many such requests. It can define which criteria to clarify, how to separate evidence from inference, how to handle missing data, and what a decision-ready output contains. The Skill has a stable name and version; the prompt supplies the variable business context.
This division reduces prompt sprawl. Teams stop pasting the same procedural block into every conversation, and editors can improve one reusable asset instead of finding dozens of copied prompts.
Agent Skill vs tool #
A tool does something concrete: search the web, read a file, query connected knowledge, create a document, or propose an external update. It has an input contract, an output contract, and an authorisation boundary.
A Skill makes several decisions around that capability. The Web Research Skill, for example, can guide query design, evidence comparison, date checking, synthesis, and citation. Search and crawling tools provide the underlying access. If those tools are not assigned to the agent, the procedure cannot call them.
This produces a useful failure mode. The builder can report a missing capability during configuration instead of discovering at runtime that prose in a system prompt was mistaken for a permission.
Agent Skill vs MCP #
Model Context Protocol gives systems a shared way to expose tools, resources, and prompts. It solves an interoperability problem: how a client discovers and invokes capabilities from a server.
Agent Skills solve a procedure problem: how an agent recognises a specialised task and applies an appropriate method. A Skill can refer to MCP-exposed tools, but the two layers remain independent. One MCP server may support many Skills, and one Skill may rely on tools from several servers.
Agent Skill vs agent #
An agent is the accountable runtime identity. It has a role, model configuration, prompt, knowledge connections, tool assignments, and operating controls. A Skill is one capability package attached to that identity.
That separation enables reuse without cloning agents. A knowledge assistant and a document analyst can both use Connected Knowledge Search, while retaining different models, audiences, system instructions, and tool scopes. Conversely, one agent can combine research, document review, and file-deliverable Skills when its authorised job requires all three.
Agent Skill vs workflow #
A workflow determines what runs next. It may branch, aggregate evidence, request approval, retry a failed step, or route work to another agent. A Skill guides the work performed inside a model-driven step.
In VDF AI Networks, Skills attach to LLM Agent, Aggregator, and Router nodes through agent inheritance or node-level override. This is deliberately not a new “Skill node.” Treating a procedure as a node would blur the distinction between an execution unit and contextual operating guidance.
An original architecture test #
Use this six-question test when reviewing an agent system:
- Who acts? Name the agent identity.
- What method applies? Name the Skill and version.
- What is being asked now? Preserve the user prompt.
- What can be called? Enumerate assigned tools and connector scopes.
- How are capabilities exposed? Record MCP or other integration boundaries.
- What controls the sequence? Identify the Network route, approvals, and recovery rules.
If one configuration field is doing several of these jobs, the system will be harder to test and govern.
What VDF AI implements today #
The current VDF AI Cloud source contains eight included system Skills that pass strict validation: Web Research, Connected Knowledge Search, Document Review, File Deliverables, Option Comparison, Data Quality Review, Safe Write Actions, and Ticket Writing. Builders can also create private Skills or import supported Skill content from a compatible ZIP.
Skills support version snapshots, explicit slash-command invocation, and progressive . Network runs can return activation and file-read telemetry. The runtime does not currently execute bundled Skill scripts, and automatic model-triggered activation can vary by provider; those are compatibility boundaries, not footnotes.
A practical selection rule #
Use a prompt for context that is unique to this request. Use a Skill when a method deserves a name, owner, validation, and version. Use a tool when the system must access or change something. Use MCP when capabilities need a standard exposure layer. Use an agent when the runtime needs an accountable identity. Use a workflow when several controlled steps must coordinate. Explore the Agent Skills catalog, read the implementation-neutral guide to SKILL.md and governance, or follow the VDF AI Skills documentation.