Skill Invocation: Commands, Stacking, and Natural Language

Every Installed Skill Is a Slash Command

One of the most useful properties of the Hermes skill system is that installation is invocation-ready. The moment you install a skill — via /learn, Hub installation, or manual creation — it becomes available as a slash command without any additional configuration. A skill named github-pr-workflow is immediately invocable as /github-pr-workflow.

This works because Hermes generates the slash command registry dynamically from the skills directory. Every name field in every installed skill's SKILL.md frontmatter becomes an entry in the command list. The agent maps incoming slash commands to skill names at invocation time, loads Level 1 content, and executes the procedure.

Dynamic slash commands mean there is no separate registration step, no configuration file to update, and no restart required (as long as you run /reload-skills after adding new skills — more on that shortly). The skill's name is the command, and the command is always the skill's name.

Passing Instructions to a Skill

The slash command syntax accepts an optional instruction after the skill name:

/github-pr-workflow fix the auth regression in feature/login-flow

The text after the skill name is passed to the agent as a task-specific instruction alongside the loaded skill content. The skill provides the procedure; the instruction specifies what to apply it to. This pattern works for any skill that operates on a target — a PR, a file, a service name, a bug description.

When no instruction is passed, the agent invokes the skill in the current session context, using whatever task is already in focus. Explicitly passing an instruction is cleaner when you want to redirect the skill to a specific target without ambiguity about what "the current task" means.

Stacking Multiple Skills

You can chain up to five skills in a single invocation by listing their slash commands in sequence:

/github-code-review /test-driven-development /github-pr-workflow implement the rate limiter

Hermes loads all listed skills in parallel — fetching each at Level 1 — and provides the agent with the combined content as a unified context for the task. The instruction at the end ("implement the rate limiter") applies across all loaded skills.

Stacking is most useful when a complex task genuinely requires multiple distinct procedures — for example, a task that involves both reviewing existing code and writing tests before submitting a PR. Rather than running three separate commands, you compose them in one invocation and let the agent apply all three skill frameworks together.

The five-skill limit exists to prevent context bloat. If you find yourself regularly stacking more than three skills, that is a signal that you should probably create a bundle that composes them with explicit workflow guidance — Lesson 7 covers bundles in detail.

Natural Language Invocation

Slash commands require you to know the exact skill name. Natural language invocation is the alternative: start a session with the skills toolset enabled and describe what you need in plain language.

hermes chat --toolsets skills -q "Show me the axolotl skill"

In this mode, the agent uses the Level 0 metadata to match your description against installed skills. If it finds a strong match, it loads the skill and applies it. If it finds multiple plausible matches, it may ask for clarification or apply the best match and report what it chose.

Natural language invocation is well-suited to exploratory use: when you know the general category of what you need but not the exact skill name, or when you want the agent to discover and apply the relevant skill without you specifying it explicitly. Slash commands are better when you want deterministic behavior — precisely this skill, applied right now.

/reload-skills: Keeping the Agent Current

When you add, remove, or rename skills during an active session, the agent's Level 0 directory does not update automatically. The directory is built at session start and cached. To apply changes mid-session, run:

/reload-skills

This command triggers a fresh skills_list() scan and rebuilds the slash command registry. After /reload-skills, newly installed skills become available as commands and removed skills disappear from the agent's awareness.

You do not need /reload-skills if you start a new session after making changes — the scan runs at session start automatically. The command exists specifically for workflows where you want to install a skill via Hub or /learn and immediately use it in the same session without restarting.

How the Agent Resolves Multi-Skill Context

When multiple skills are loaded — whether through stacking or bundles — the agent receives all their content simultaneously and synthesizes a combined approach. Understanding how this synthesis works helps you design stacks and bundles that produce coherent behavior.

The agent does not execute skills sequentially in a rigid order. Instead, it uses all loaded procedure content as a constraint set for the task: "Given these procedures, what is the right way to approach this problem?" When procedures overlap (two skills both cover how to handle merge conflicts, for example), the agent applies judgment about which approach fits the current context better.

The practical implication: when stacking skills, prefer skills that cover genuinely different aspects of a task rather than overlapping procedures. Overlapping content does not cause failures, but it adds context cost without adding behavioral value. If two skills redundantly cover the same procedure, merge them or replace one with a reference to the other.