playbook/outfitter-agents/plugins/outfitter/skills/skills-dev/references/invocations.md

Skills Invocations

How each tool activates and invokes skills.

Invocation Patterns Overview

Tool	Pattern	Description
Claude Code	Model-invoked	Agent autonomously decides based on request + description
Claude (claude.ai)	Auto + Model	Pre-built skills auto-activate; custom skills when relevant
GitHub Copilot	Model-invoked	Based on prompt + skill description
VS Code (Copilot)	Model-invoked	Auto-activates, follows progressive disclosure
OpenAI Codex	Explicit + Implicit	/skills command or $skill mentions, or model decides
Cursor	Model-invoked	Agent determines relevance automatically
Amp	Lazy-loaded	On-demand loading when relevant
Letta	Tool-based	Agent calls Skill tool to load into memory
Goose	Model-invoked	Loads skills, accesses files via file tools
OpenCode	Tool-based	Skills registered as dynamic tools via plugin

Detailed Invocation Methods

Claude Code

Type: Model-invoked (autonomous)

Claude autonomously decides to use skills based on:

• Current request context
• Skill name and description from frontmatter

Contrast with slash commands:

• Skills = model-invoked (agent decides)
• Slash commands = user-invoked (explicit)

---

Claude (claude.ai)

Type: Automatic + Model-invoked

• Pre-built skills (document actions): Activate automatically
• Custom skills: Load when model determines relevance

---

GitHub Copilot

Type: Model-invoked

Copilot decides activation based on:

• User's prompt content
• Skill description field

When activated:

• SKILL.md content injected into agent context

---

VS Code (Copilot)

Type: Model-invoked (auto-activation)

• No manual skill selection required
• Follows progressive disclosure pattern
• Model determines when skills are relevant

---

OpenAI Codex

Type: Explicit + Implicit

Explicit invocation:

• /skills slash command — Opens skill selector
• $<skill-name> mention — Reference specific skill in prompt (e.g., $plan, $skill-creator)

Implicit invocation:

• Codex decides based on skill descriptions
• Automatic activation when task matches skill description

Surface support:

• CLI and IDE extensions support explicit invocation
• Web and iOS don't support explicit invocation yet (but can prompt Codex to use repo skills)

Built-in skills:

• $plan — Research and create implementation plans
• $skill-creator — Bootstrap new skills
• $skill-installer — Download skills from GitHub

---

Cursor

Type: Model-invoked ("agent-decided rules")

• Agent determines relevance automatically
• No manual intervention required
• Skills applied without user selection

Constraint: Skills cannot be configured as "always apply" or manually invoked — agent-decided only.

---

Amp

Type: Lazy-loaded

• Skills loaded on-demand when relevant
• Described as "lazy-loaded instructions"
• No explicit invocation required

---

Letta (Letta Code)

Type: Tool-based

Model invocation:

• Agent calls the Skill tool to load skills into memory
• Agent decides when to load based on context
• Skill tool commands: load, unload, refresh

Explicit invocation:

• Prompt: "Use the testing skill..." to force specific skill
• /skill command: Extract new skill from recent work

Memory integration (Two Blocks):

• skills block: Always visible — list of available skills (names + descriptions)
• loaded_skills block: Session state — full content of currently loaded skills
• Both blocks are read-only (modified only via Skill tool)

Alternative access:

• Can read .skills/<name>/SKILL.md directly for one-time preview (without loading)

---

Goose

Type: Model-invoked

• Loads skills when relevant
• Accesses supporting files via file tools
• Treats skills as filesystem resources

---

OpenCode

Type: Tool-based

• opencode-skills plugin registers skills as dynamic tools
• Skills become tool-like affordances
• Agent invokes skills as it would any other tool

Invocation Pattern Comparison

Model-Invoked (Autonomous)

The agent decides when to use skills without explicit user action.

Pros:

• Seamless user experience
• Agent can combine skills as needed
• No learning curve for users

Cons:

• Less predictable
• May miss relevant skills
• User has less control

Tools: Claude Code, Claude, GitHub Copilot, VS Code, Cursor, Amp, Goose

Explicit Invocation

User directly requests skill usage via commands or mentions.

Pros:

• Predictable behavior
• User maintains control
• Clear audit trail

Cons:

• Requires user to know available skills
• More friction
• May miss opportunities

Tools: OpenAI Codex ($skill, /skills)

Tool-Based

Skills are exposed as tools the agent can call programmatically.

Pros:

• Fits existing tool-use patterns
• Clear invocation semantics
• Integrates with agent memory

Cons:

• Requires tool infrastructure
• More complex implementation

Tools: Letta, OpenCode

Progressive Disclosure in Invocation

Most tools follow a staged loading pattern:

┌─────────────────────────────────────────────────────────────┐
│ Stage 1: Index                                              │
│ Load: name, description                                     │
│ When: Startup / cache refresh                               │
├─────────────────────────────────────────────────────────────┤
│ Stage 2: Activate                                           │
│ Load: Full SKILL.md body                                    │
│ When: Agent decides skill is relevant                       │
├─────────────────────────────────────────────────────────────┤
│ Stage 3: Execute                                            │
│ Load: scripts/, references/, assets/                        │
│ When: Skill instructions reference them                     │
└─────────────────────────────────────────────────────────────┘

This minimizes context usage while maintaining full capability access.