Skills: teach your Hermes agent repeatable workflows

Once your agent has tools, you will notice something: you keep explaining the same multi-step job over and over. “Pull the numbers from these three sites, in this order, watch out for that pitfall.” A skill captures that know-how once, so the agent does it the same right way every time. If tools are the agent’s hands, skills are its trained habits.

This builds on Hermes tools 101 — a skill is mostly a recipe for using tools well.

What a skill is

A skill is a single Markdown file called SKILL.md with two parts:

• Frontmatter — at minimum a name and a description; optionally version, platforms, author, license and other metadata.
• Body — the trigger condition, numbered steps, exact commands, known pitfalls, and how to verify the result.

The clean way to think about it: a skill is procedural memory. Regular memory stores facts (“the user prefers concise replies”). A skill stores how to do something (“here is exactly how to run a price-research batch across these marketplaces”). Facts versus procedures.

The anatomy of a skill

A minimal skill looks like this:

---
name: price-research
description: Use when doing price research across NL/BE marketplaces — Tweakers, Geizhals, Amazon.
version: 1.0
---

# Price research

## When to use
The user asks to compare prices for a product across marketplaces.

## Steps
1. Search each marketplace in this order: Tweakers, Geizhals, Amazon.
2. Record price, seller, and stock for each.
3. Note shipping separately — it is not in the headline price.

## Pitfalls
- Some listings hide shipping until checkout. Always check.

## Verify
Cross-check the cheapest result against the source page before reporting.

The trigger is everything

The agent decides whether to load a skill from its description field. At the start of a session it sees only a compact list of every skill name and description, and picks from that — so the description is the trigger, and it has to be specific about when the skill applies:

• Good: “Use when doing price research across NL/BE marketplaces — Tweakers, Geizhals, Amazon.”
• Bad: “Use when doing research.”

A vague trigger means the skill either never fires or fires at the wrong moment. Spend most of your effort here — a precise trigger is worth more than a perfect body.

When to create a skill

The rule is simple: if you have done the same multi-step job twice, that is a skill. If it is a single quick tool call, just do it — do not bureaucratise a one-liner. Skills earn their keep on repeatable, multi-step procedures where getting the order and the pitfalls right actually matters.

Two ways to make one: write it, or let Hermes

You do not have to hand-write every skill. There are two routes, and in practice you use both:

• Write it yourself. Create the SKILL.md by hand when you know exactly what the procedure should be. You get full control over every step, command and pitfall — best for anything precise or safety-sensitive.
• Let Hermes write it. Describe the workflow in plain language and ask the agent to save it: “we just did that — store it as a skill so you do it the same way next time.” It drafts the SKILL.md for you with its skill_manage tool. Because Hermes is self-improving, it often offers this itself after finishing a complex, multi-step task.

The pattern that works best is a hand-off: let Hermes draft from what it just did, then you tighten the trigger and check the steps. The agent captures the procedure well; you are better at judging when it should fire and where it could go wrong.

Managing your skills

From the CLI you can see what is installed and what you have changed:

hermes skills list            # all skills (built-in, custom, community)
hermes skills list-modified   # only skills you have changed from the bundled version

The agent also has skill tools of its own — skills_list, skill_view, and skill_manage — so it can look up and manage skills mid-task without you leaving the chat.

If you prefer clicking to typing, the Hermes Desktop app has a Skills tab that does the same thing visually: it lists your installed skills with enable/disable toggles, and below them the full catalog of optional skills that ship with Hermes but are switched off by default. Each has a one-click Install button that flips it into your active set — so “turn on an extra skill” is usually just a toggle away, no command needed. The same controls live on the /skills dashboard.

The lifecycle: create, use, patch, prune

A skill is not “write once and forget.” It lives:

• Patch immediately. A skill with a missing step or a wrong command is worse than no skill — the agent will follow it faithfully and fail. The moment you spot an error, fix it.
• Prune when stale. If a skill describes a tool you no longer use, delete it. A bloated skill library is harder to trust and maintain than a lean one.

Treat the collection like a garden, not an archive.

Getting skills from others — and checking them

You do not have to build everything yourself. Beyond the optional skills that ship with Hermes, there are official add-ons, community registries like agentskills.io and HermesHub, and any public GitHub repo. Installing one is a single command:

hermes skills browse                           # see what is available
hermes skills install official/research/arxiv     # an official optional skill
hermes skills install owner/repo/skills/name      # one skill from any GitHub repo

But a skill is executable — it runs commands on your machine — so a downloaded one deserves the same caution as any software you did not write. The reassuring part: Hermes does not just trust it. Every install is quarantined and scanned for the usual dangers — data exfiltration, prompt injection, malicious payloads — with the source URL and a content hash recorded, and a third-party warning panel shown the first time you install from an untrusted source. Hub installs can run an extra static security scan (NVIDIA SkillSpector) as a second opinion.

That scanner is a safety net, not a substitute for reading. Before you trust an unknown skill, still check four things yourself:

• What does it actually do? Read the whole thing.
• What commands does it run? Anything destructive or surprising?
• Does it fit your setup? Your OS, your Python, your paths.
• Does it read or send data anywhere? Especially anything leaving your machine.

One setting is worth knowing before you trust a source: inline shell snippets inside a SKILL.md are off by default, because otherwise any snippet would run on your host without asking. Only turn that on for sources you genuinely trust. And none of this is paranoia — a community skill installed without reading once ran commands that did not match the environment and had to be pulled within the hour. The habit was born from exactly that near-miss.

Write for a diligent intern

The mental model that produces good skills: write them as instructions for a diligent intern who has never seen your setup. Assume nothing. If the skill says “use a browser,” the agent will use one badly; if it says “use the browser on this port, with this profile flag, and check for that cookie,” the agent will do it right. Precision in the skill is precision in the result.

Skills give the agent trained habits. The next step is a persistent memory, so the agent remembers who you are between sessions; later in the series, MCP extends things further by plugging in entirely new sets of tools and data sources, from GitHub to your own APIs.