The Skills System: How Hermes Writes and Refines Its Own Capabilities

What a Skill Actually Is

A skill is a saved, reusable procedure, written in a standard format, that Hermes can either invoke deliberately (as a slash command) or reach for automatically when a task matches. This is the mechanism behind “self-improving” from Lesson 1: rather than re-deriving how to do something from scratch in every conversation, Hermes accumulates a personal library of things it already knows how to do well.

flowchart LR
    DO["You do a multi-step\ntask in conversation"] --> LEARN["/learn"]
    LEARN --> AUTHOR["Agent gathers material\nwith its existing tools,\nauthors a SKILL.md"]
    AUTHOR --> SAVE[("~/.hermes/skills/\nyour-skill/SKILL.md")]
    SAVE --> CMD["Automatically becomes\na slash command"]
    CMD --> REUSE["Next time: /your-skill\nor auto-matched in\nconversation"]

    style DO fill:#EEF0F7,stroke:#6366F1,color:#0F172A
    style LEARN fill:#EEF0F7,stroke:#6366F1,color:#0F172A
    style AUTHOR fill:#f0fdf9,stroke:#0D9488,color:#0F172A
    style SAVE fill:#fff7ed,stroke:#f59e0b,color:#0F172A
    style CMD fill:#f0fdf9,stroke:#0D9488,color:#0F172A
    style REUSE fill:#EEF0F7,stroke:#6366F1,color:#0F172A

Teaching a Skill with /learn

The fastest way to create a skill is to demonstrate the workflow, then ask Hermes to capture it:

/learn

/learn is open-ended: point it at anything you can describe. The agent gathers material using tools it already has, REST clients, documentation directories, online docs, a workflow you just walked through, or notes you paste in, and authors a skill that follows the house authoring standard: a description under 60 characters, a standard section order, and framing consistent with how Hermes’ own tools are described (the same discipline from Lesson 7.1’s advice on writing good tool descriptions applies here too).

A realistic session:

You: /learn
Hermes: What would you like me to learn? You can describe a workflow,
        paste documentation, or point me at something to explore.
You: Every morning I check our staging health endpoint, our error
     dashboard, and our deploy log, then write a two-line summary.
     Here's the staging URL and dashboard link: ...
Hermes: [explores the URLs, tests the workflow]
        Created skill: daily-status-check
        Try it with /daily-status-check

Writing a Skill by Hand

You don’t have to go through /learn. Since skills are just files, you can author one directly:

# ~/.hermes/skills/daily-status-check/SKILL.md
---
name: daily-status-check
description: Check staging health, error dashboard, and deploy log; write a 2-line summary
---

## Instructions

1. Fetch the staging health endpoint (see project memory for the URL, or ask if not found).
2. Check the error dashboard for anything above the normal baseline.
3. Read the last deploy log entry.
4. Write a two-line summary: one line on health/errors, one line on the last deploy.

## Notes

- If staging is down, lead the summary with that fact before anything else.
- Keep the summary to two lines even if there is a lot to report; link out for detail rather than expanding.

Save the file, and the skill is live immediately, no separate registration or restart step, matching the same “drop a skill in and it’s live” behavior whether the skill came from /learn or from your own editor.

Skills as Slash Commands

Every installed skill, agent-authored or hand-written, automatically becomes a slash command matching its name:

/daily-status-check

This is what makes the skills system feel less like a hidden background feature and more like a personal command palette that grows over time. You can invoke a skill explicitly by name, or simply describe the task in normal conversation and let Hermes match it to an existing skill on its own, both paths work.

What Makes This “Self-Improving” Rather Than Just “Configurable”

The distinction matters: a static config file is something you set once. Skills accumulate through use, refine through repetition (the agent can update a skill’s instructions if it discovers a better approach), and get authored by the agent itself through /learn, not just by you editing files. That’s the loop Lesson 1 described as self-improvement happening entirely at the orchestration layer, no model retraining involved, just a growing, refined library of things the agent already knows how to do well.

Common pitfall: treating every one-off task as worth turning into a skill. A skill earns its keep through repetition. Teaching the agent a workflow you’ll genuinely repeat weekly is worth the /learn investment; a task you’ll do exactly once is not, that’s just a normal conversation.

Exercise: pick a real, multi-step task you do more than once (checking a status page, drafting a specific kind of message, running a recurring diagnostic), and use /learn to capture it. Then start a fresh session and invoke it by its new slash command to confirm it behaves the way you’d expect.