Hermes v0.19 Skill Combos: Chain 3 Skills in One Message and Let Order Shape the Outcome

In previous versions of Hermes Agent, you loaded one skill at a time. If a task needed the browser, a code-research tool, and a Docker helper, you either installed all three and hoped the model picked them up, or you manually flipped between sessions. Hermes v0.19.0 changes that with stacked slash-skill invocations: you can now write /skill-a /skill-b /skill-c do XYZ and Hermes loads all three skills in order inside a single turn.

This is not just syntactic sugar. The order matters. Earlier skills shape context, set up tools, and often own the “first pass” of a task. Later skills refine, operate, or commit. Chaining skills in the right sequence lets you compress multi-step workflows into one message.

In this post I will show what stacked skill invocations actually do, why sequence is part of the prompt, and three practical 3-skill combos you can use today.

For the broader v0.19.0 overview, see our v0.19.0 release notes and the Quicksilver feature roundup.

What Are Stacked Skill Invocations?

The official v0.19.0 changelog describes the feature in one line:

Stacked slash-skill invocations — /skill-a /skill-b do XYZ loads both skills in order.

Hermes already supports slash-style skill commands. In older versions, typing /docker-management would activate the Docker skill for the current turn. In v0.19.0, you can prefix a message with several slash skills separated by spaces. Hermes loads each one, then executes the rest of your prompt.

/gitnexus-explorer /code-wiki /subagent-driven-development
Review the last 30 merged PRs in NousResearch/hermes-agent, map the changed modules against our local codebase, and split the resulting migration plan into parallel subagent tasks.

Hermes will:

Load gitnexus-explorer to query GitHub.
Load code-wiki to ground the findings against local project knowledge.
Load subagent-driven-development to parallelize follow-up work.
Run the user instruction across all three toolsets.

You can also trigger the feature from the CLI or TUI. The v0.19.0 release added autocomplete and ghost text for the slash commands, so the client will suggest available skills as you type.

Why Order Matters: Skills as a Pipeline

A stacked invocation is a pipeline, not a bag of tools. Each skill can:

Inject tools into the current turn.
Register context the model should use before planning.
Modify behavior such as output format or approval rules.
Claim a role that the later skills should not override.

If you swap the order, the same three skills can behave differently. For example:

/subagent-driven-development /code-wiki /docker-management
Refactor the payment service to use the new database schema and deploy it in a local container.

Here subagent-driven-development is loaded first. It can set the “task decomposition” pattern and spin up subagents before code-wiki provides local knowledge and docker-management handles the container layer. The final result is the same three skills, but the orchestration is now front-loaded.

Three practical patterns emerge:

Pattern	Order	Best for
Discovery → Knowledge → Execution	`gitnexus-explorer` / `code-wiki` / `subagent-driven-development`	Research and planning across codebases
Orchestration → Knowledge → Operations	`subagent-driven-development` / `code-wiki` / `docker-management`	Refactoring and shipping to local environments
Observe → Extract → Publish	`watchers` / `page-agent` / `fastmcp`	File or web monitoring that feeds into external systems

Order does not guarantee deterministic output—this is still an LLM-driven agent—but it shifts the planning prior. Earlier skills get mentioned earlier in the system context and are more likely to be treated as the primary frame.

3 Real-World 3-Skill Combos

These examples use skills already covered in our 8 must-have advanced skills guide. If you do not have them installed, run hermes skills install <name> first.

Combo 1: Research, Map, and Parallelize

/gitnexus-explorer /code-wiki /subagent-driven-development
Find the five most important upstream changes in Hermes v0.19.0 that affect the MCP server format, map them to our local MCP adapter code, and assign one subagent per change to write the migration patch.

What each skill does:

gitnexus-explorer reads the upstream release notes, PRs, and issues.
code-wiki matches the upstream concepts against your local module and function names.
subagent-driven-development splits the work into parallel subagents, each owning one migration patch.

Why this order: research first, then grounding, then parallel execution. If you put subagent-driven-development first, the agent might start assigning work before it understands the upstream changes, producing vague tasks.

Combo 2: Refactor, Test, and Deploy Locally

/subagent-driven-development /code-wiki /docker-management
Split the user authentication refactor into backend, frontend, and test tasks. Use the local codebase wiki to keep naming consistent. When all subagents finish, build a Docker image from the branch and run the integration tests in a container.

What each skill does:

subagent-driven-development creates the task plan and launches backend/frontend/test subagents.
code-wiki enforces project conventions and prevents renaming drift across subagents.
docker-management packages the branch and runs the integration suite in an isolated container.

Why this order: orchestration first, shared knowledge second, and the environment layer last. If Docker were loaded first, it might spend the turn inspecting images before the refactor plan exists.

Combo 3: Watch, Extract, and Forward

/watchers /page-agent /fastmcp
Watch the Cloudflare status RSS feed. If a new incident is posted, open the incident page, extract the affected products and regions, and publish a structured summary to our Slack channel via the internal MCP server.

What each skill does:

watchers polls the RSS feed and triggers the turn on a new item.
page-agent opens the incident page and scrapes the details.
fastmcp connects to your internal MCP server and pushes the summary to Slack.

Why this order: the trigger must be first, the extraction second, and the output connector last. Reversing page-agent and fastmcp would still work, but the mental model of “observe → extract → publish” is clearer and less error-prone.

How to Discover and Install the Skills You Need

Hermes has a built-in skills hub. You can search, install, and list skills from the terminal:

# Browse all available skills
hermes skills browse

# Search for a specific skill
hermes skills search docker

# Install a skill
hermes skills install docker-management

# See what is currently installed
hermes skills list

Most skills are loaded automatically when you invoke them. If a skill is not installed, Hermes will usually tell you and suggest the install command. In v0.19.0, slash-skill autocomplete also shows which skills are already installed.

Common Pitfalls

Treating order as invisible. Swapping two skills can change the plan. If you notice inconsistent results, log the order you used and compare runs.
Loading too many skills. Three to four skills is usually the sweet spot. Stacking every skill you have dilutes the context window and can make the model indecisive.
Assuming skills compose perfectly. Some skills want to own the same tool namespace or output format. Test your combo in a safe workspace first.
Forgetting the fallback. If a stacked invocation fails, you can fall back to single-skill turns to isolate which skill caused the problem.

Key Takeaways

Hermes v0.19.0 lets you stack slash skills in one message: /skill-a /skill-b /skill-c do X.
Skills are loaded in order, and that order shapes the model’s plan and context.
Three practical combos are: research → map → parallelize; orchestrate → ground → deploy; watch → extract → publish.
Keep combos to 3–4 skills, test them in a safe workspace, and iterate on the order.
Use hermes skills browse and hermes skills install to discover the skills you need.

References: