Definition
Skill invocation is the runtime step where an agent matches the current task against the trigger conditions of skills in its library and loads the matching skill into context before acting — the step that determines whether a stored skill ever influences a run.
Skill invocation is the runtime step where an agent matches the task in front of it against the trigger conditions of the skills in its library and loads the matching skill before acting. It is the step that decides whether a stored skill ever influences a run. A library can hold a team’s best procedures, but if the right skill never loads at the right moment, the library does nothing.
Quick breakdown
Invocation depends on a skill describing when it applies. That description is the trigger.
| Task type | The class of work the skill is for, such as setting up a service or triaging a class of error. |
|---|---|
| Error signature | A symptom string or failure mode that signals this skill is relevant. |
| Context | A file, tool, or environment whose presence makes the skill apply. |
| Goal | A stated user or run objective the skill is meant to serve. |
| Boundaries | Conditions under which the skill should not fire, to keep it from over-applying. |
What a skill trigger encodes
A trigger is the part of a skill that answers one question: when should an agent consider this? It is what separates a skill from a document. A document sits there until someone reads it. A skill says, in effect, “if you see this kind of task, here is the procedure that worked.”
A skill without a usable trigger is just a document the agent never opens.
Triggers can be coarse or fine. A coarse trigger fires on a broad task type. A fine trigger keys off a specific error signature or a particular tool. The right grain depends on the skill: a deploy workflow wants a coarse trigger, while a fix for one provider’s rate-limit error wants a precise one.
How an agent knows which skill to use
At the start of a run, the agent has a task and a library. Matching is the step that connects them.
Task starts │ ▼ Compare task against skill triggers in the library │ ├── one or more match → load matching skill(s) into context │ │ │ ▼ │ Agent acts with the procedure in hand │ └── nothing matches → agent proceeds without a skill
The match is not all-or-nothing across the library; it is per skill. Several skills can apply to one task, and a well-scoped library loads the few that fit rather than everything. When nothing matches, the agent proceeds as it otherwise would. Invocation adds a skill when one is relevant; it does not block a run when none is.
Why skill libraries fail at the invocation layer
A surprising number of skill libraries go unused, and the cause is usually triggers rather than content.
| Trigger problem | What happens at runtime |
|---|---|
| Too narrow | Fires only on the exact session it came from; never matches new work |
| Too broad | Fires on everything, produces noise, and gets distrusted and ignored |
| Absent or vague | The agent has no signal to load the skill, so it stays on the shelf |
This is why a library can be full of good skills and still have a low invocation rate. The skills are fine; the matching is broken. Fixing invocation is often a matter of rewriting triggers, not rewriting skills.
How to write skill triggers that fire correctly
A few habits keep triggers honest:
- Name the situation, not the session. Describe the class of task, not the one run the skill came from.
- Add a boundary. State when the skill should not fire, so it stops short of over-applying.
- Test against real runs. Check whether the trigger fires on the tasks you expect and stays quiet on the ones you don’t.
- Revisit after drift. When a tool or error changes, the trigger may need to change with it.
How skill invocation differs from RAG retrieval
Invocation and retrieval both pull something into a run based on the task. They differ in what they pull and why.
| RAG retrieval | Skill invocation |
|---|---|
| Retrieves reference text by similarity | Loads a procedure by matching trigger conditions |
| Informs what the model writes | Influences what the agent does |
| Returns information for context | Returns a course of action |
| Tuned with embeddings and ranking | Tuned with trigger conditions and boundaries |
The two are complementary. A run can retrieve reference material and invoke a skill in the same step. What invocation adds is a path of action keyed to the situation, which retrieval on its own does not provide.
How Paper Compute surfaces skills to a run
Skills generated and stored in paper console carry the structure invocation depends on: a type, and content that can express when the skill applies. Whether a skill actually fires is observable once runs are captured by paper cli — the share of runs that load a skill is a signal you can read, and a low share usually points back to triggers. Measuring that signal over time is part of continuous agent improvement: a library is only working when its skills are being invoked on the runs that need them.
Invocation is the last gap between a stored skill and a better run. Close it, and the library starts paying off.