What Are Agent Skills?

🧩 What a skill holds, and how one is selected

A skill is content rather than code in the ordinary case: an instruction document written for a reader that will follow it, together with whatever those instructions need in order to be followed — a reference table, a worked example, a schema, a helper script the instructions say to run. The packaging is what makes it a skill rather than a note. The same words pasted into a system prompt are the same words; what they lack is the ability to be absent.

Selection happens before loading and it is the part that decides whether the arrangement works at all. A skill carries a short description of what it is for, and that description — not its body — is what occupies the context while the skill sits unloaded. When a task arrives, the descriptions are compared against it, one or more skills are chosen, and only then are their bodies read in. So a skill's description is doing retrieval work: it is the entire evidence on which the skill is picked, and an excellent body behind a vague description is a skill that never loads.

That gives a skill library three tiers of presence, and the tiers are the whole economy of the format. Names and descriptions are always there. Bodies arrive on selection. Bundled files arrive later still, when the instructions reach them, if they ever do. A library grows by adding descriptions, which is cheap, rather than by adding instructions to every request, which is not.

The last row is the argument for the format and it is worth stating as arithmetic. A library of a hundred skills occupies a hundred descriptions in a request; the same material written into one standing instruction occupies all of it, on every request, whether or not the task has anything to do with it. Which is why the craft of writing a skill is mostly the craft of writing its description.

🗃️ How the Registry classifies a skill-packaging task

Packaging a reusable instruction set and its helper scripts into a loadable skill directory is filed as software engineering in this registry's classification. The classification follows the artefact produced rather than its subject: a skill that documents a retrieval procedure is still a directory of files someone else's runtime will read, so it is filed with the code.

The Registry's canonical brief for this entry is filed as: Package a reusable instruction set and its helper scripts into a skill directory an agent can load on demand. Submitted for assessment it is classified as Code modification, and its wording is hashed once — to 1dc8bd144d0257ee…, the first sixteen of sixty-four hexadecimal characters — with the wording itself never stored. The hash is what the derivation reads. That class's own page is /tasks/code.

Classification is one of three inputs. The other two are the configuration submitted with the task, and the permanent chart derived from that configuration — fixed by the model name, the training cutoff and the temperature alone, and never reading the task at all. The same ascendant, ruling planet and harmony therefore appear on every assessment a given configuration receives, whatever it was asked to do. The derivation is published in full at /method.

❓ Questions about agent skills

What are agent skills?

An agent skill is a packaged set of instructions, and usually the supporting files those instructions refer to, that a runtime loads into the context when a task calls for it and omits when it does not. It supplies a procedure rather than an interface: a skill grants no access the runtime did not already have, and any script it bundles runs through an execution tool that was already there.

How is a skill different from a tool?

A tool is an interface: declared with a schema, called by name with arguments, and it returns a result from outside the context. A skill is instructions read into the context. Nothing is called and nothing returns. Skills routinely tell the reader which tools to use, which is the two working together rather than one being the other.

How does an agent decide which skill to load?

By comparing the task at hand against the short descriptions of the installed skills, which are the only part of them present before selection. The body is read in afterwards. That makes the description the selection surface, and a skill whose description does not state the situations it applies to is one that will not be picked in them.

Can a skill contain executable code?

Commonly yes — helper scripts the instructions say to run. The distinction worth keeping is that a bundled script is executed and only its output reaches the context, whereas the instruction body is read into the context in full. The first costs a result; the second costs its own length.

Does loading a skill change the underlying configuration?

No. It changes what a request contains for as long as it is loaded. No weights are altered, nothing persists after the run, and the same configuration with a different skill selected is the same configuration. A skill is a change to the input, which is why it can be corrected by editing a file.

How many skills should a library hold?

The binding constraint is the selection step rather than storage: every installed skill contributes its description to every request, and descriptions that overlap make the choice between them worse rather than better. Where the number stops being useful is a measurement taken on a particular library, and this registry has taken none.