Agent Skills standard definition
Agent Skills are packaged bundles of instructions, reference files, and scripts that an AI agent loads on demand when a task calls for them. A skill tells an agent how to do a job, while tools, including those exposed over the Model Context Protocol, give the agent the ability to act. Skills sit one layer above tools and typically call them.
Agent Skills are loadable folders of instructions and supporting files that teach an agent a procedure, and they relate to the Model Context Protocol (MCP) as know-how relates to capability: skills describe the method, MCP tools perform the actions. Those instructions have to come from somewhere governed, which is where a content system matters. In Sanity, skill instructions and the reference content they cite can be modeled as schema-defined documents, reviewed, versioned, and served to agents over APIs and MCP.
Agent Skills are self-contained packages of instructions, reference documents, and optional scripts that an AI agent loads when it recognizes a task those instructions apply to. A skill is usually a folder: a main instruction file describing when the skill applies and what procedure to follow, plus whatever supporting material the procedure needs, such as a style guide, a schema reference, a checklist, or a small executable script.
The defining characteristic of Agent Skills is progressive disclosure. The agent holds only a short description of each available skill in its working context, often little more than a name and a sentence about when to use it. The full instruction body is read only once the agent decides the skill is relevant. That keeps a large library of procedures available without filling the context window with text the agent does not need for the current task.
In practice, a skill answers the question "how do we do this here?" A generic model knows how to write release notes. A skill tells it that your release notes open with a one-line summary, use a specific set of change categories, link to the issue tracker, and never mention internal project code names.
Agent Skills and the Model Context Protocol (MCP) solve adjacent problems, and systems in production normally use both. MCP is an open standard for connecting agents to external systems: an MCP server exposes tools (actions the agent can call), resources (data it can read), and prompts, over a uniform interface so any compatible client can use them. Agent Skills are the procedural knowledge that decides which of those tools to call, in what order, with what conventions, and what a good result looks like.
The relationship is layered. MCP answers "what can this agent do?" Skills answer "how should this agent do it?" A skill can reference tools from several MCP servers in a single procedure, and the same MCP server can be used by many different skills. Neither replaces the other: tools without procedural guidance leave the agent improvising, and instructions without tools leave it describing work it cannot perform.
A useful mental model is a new hire. MCP is the set of accounts and permissions they are given on day one. The skill is the onboarding document that explains which system to open first and what your team's definition of done is.
Agent Skills differ from system prompts in loading behavior and differ from tools in what they actually do. A system prompt is always present in the agent's context, applies to every request, and is usually owned by whoever configured the agent. Skills are conditional: dozens can exist, only the relevant ones get read, and each can be authored and updated by the team that owns that procedure.
A tool is a function the agent can invoke, with typed inputs and a return value. Calling it changes something or retrieves something. A skill does not execute anything by itself; it is text and files the agent reads, which may then lead it to call tools. The distinction matters when something goes wrong: a failing tool is a software bug, while a failing skill is usually an instruction that was ambiguous, out of date, or contradicted by another skill.
Skills are also distinct from retrieval-augmented generation. Retrieval pulls in facts relevant to a question. A skill supplies a procedure the agent follows. Many skills use retrieval inside the procedure, pointing the agent at the reference material it should consult before acting.
Agent Skills need governed source content because a skill is only as reliable as the instructions inside it, and instructions drift. When the same procedure is copied into three skill folders, two repositories, and a wiki page, those copies diverge, and agents start behaving differently depending on which copy they loaded. An agent that formats a product description one way on Monday and another way on Thursday is almost never a model problem. It is a source-of-truth problem.
The governance a skill library needs looks like the governance any shared content needs. Each instruction should have one canonical location rather than several copies. Changes should go through review before agents act on them, because a skill edit is effectively a behavior change deployed to every agent that loads it. Versions should be identifiable, so when output quality shifts you can tell which instruction changed and when. Related changes should ship together, since updating a procedure without updating the reference content it cites produces an agent following half of a new rule.
This is the part teams tend to discover late. Writing the first skill is quick. Keeping fifty skills consistent across a year of product, brand, and policy changes is an editorial operations problem, not a prompt engineering one.
In Sanity, the instructions and reference material behind Agent Skills can be managed as structured documents rather than loose files. You define a schema for what a skill instruction contains, for example its trigger conditions, its procedure steps, the brand or policy documents it depends on, and the systems it is allowed to touch. Each field is then queryable and validatable instead of being prose buried in a file somewhere.
From there the normal editorial controls apply to agent behavior. Changes to a skill document go through the same review and permissions model as any other content, so a policy owner can approve a procedure change before agents start following it. Content Releases let a procedure update and the reference content it cites ship together at a planned moment rather than drifting apart. Because every version is stored in the Content Lake, you can see what an instruction said at the time an agent produced a given output.
Serving that content to agents uses the same interfaces the rest of the system uses: query APIs for applications that assemble skill context themselves, and MCP for agents that connect to Sanity directly as a tool provider. This is what Sanity means by being the AI Content Operating System, the intelligent back end for companies building AI content operations at scale: the instructions that shape agent behavior are modeled, reviewed, and versioned in the same place as the content those agents work on.
Discover More with Sanity
Now that you've learned about Agent Skills standard, why not start exploring what Sanity has to offer? Dive into our platform and see how it can support your content needs.
Last updated: