hermes-skill-factory: turning repeated Hermes sessions into saved skills
A meta-skill plugin for Nous Research's Hermes AI agent that watches your workflows and automatically turns them into reusable skills. Every time you work with Hermes and solve something — setting up a project, debugging code, creating a PR — that workflow disappears at the end of the session. You have to explain it again next time.
At a glance
- What is it?
- A meta-skill and plugin pair for Nous Research's Hermes Agent that watches a session, proposes a reusable skill, and writes SKILL.md and plugin.py files into your Hermes config. The idea is sound; the repository is thin on the parts that decide whether it works.
- Who is it for?
- Adopt it if you already run Hermes Agent v2026.3 or later and keep re-explaining the same setup, debug or PR sequence across sessions. Skip it if you are not on Hermes, or if you expect generated plugin.py files to run without editing, since the README shows the scaffold with placeholder steps rather than finished logic.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Activity is slowing. The repository last received commits 6 months ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem is session amnesia, not missing documentation
Hermes Agent sessions end. Whatever sequence you worked out inside one, the venv creation, the dependency install, the pytest run, the branch and PR steps, does not survive into the next session as an executable thing. You can write your own skill by hand, but that means stopping mid-task to formalize something you just did, which is exactly the moment you least want to do it. Skill Factory's pitch is that the formalization happens while you work and arrives as a proposal rather than a chore. The README frames this directly: the workflow disappears at the end of the session and you have to explain it again next time. The target user is someone already inside Hermes who repeats multi-step procedures often enough that the repetition is visible. It is not a general automation tool and it does not pretend to be one.
Two artifacts, two jobs: SKILL.md teaches, plugin.py executes
The mechanism splits cleanly. skills/skill-factory/SKILL.md is the meta-skill, and per the README it teaches the Hermes AI how to observe, detect, and propose skills. That is prompt-level behavior, not code. plugins/skill_factory.py is the code side: it registers the /skill-factory commands and handles file generation. The README's TL;DR states this division in three lines, and the repo layout backs it up, with templates/SKILL_TEMPLATE.md and templates/PLUGIN_TEMPLATE.py sitting between the two. So the data flow is: your session produces observations, the meta-skill decides a pattern is worth proposing, the plugin writes files from the templates into ~/.hermes/skills/<category>/<name>/SKILL.md and ~/.hermes/plugins/<name>.py. What the README does not show is the detection logic itself. It points to docs/how-it-works.md for a full breakdown, and that file is the one to read before trusting the word automatically.
Installation is a copy into ~/.hermes and a reload
The README gives a one-command path and a manual path. The script route is git clone, cd, then bash install.sh. The manual route is explicit about where things land: mkdir -p ~/.hermes/skills/meta/skill-factory, then cp skills/skill-factory/SKILL.md into it, then cp plugins/skill_factory.py into ~/.hermes/plugins/. Activation is two Hermes commands, hermes skills reload followed by hermes skills enable skill-factory. The stated requirement is Hermes Agent v2026.3 or later, and that version floor matters because the plugin registers commands through a hermes.command decorator and the skill format uses YAML front matter with name, category, description and tags. Nothing here is exotic. The manual path is worth preferring over install.sh on a first run, because it makes the two destination directories visible and you can confirm the skill directory is named meta rather than something else.
The /skill-factory command surface
Seven slash commands are documented. /skill-factory propose analyzes the current session and proposes the top detected skill immediately. /skill-factory list shows skills generated this session. /skill-factory status reports how many patterns are being tracked. /skill-factory queue shows detected patterns waiting for proposal. /skill-factory save <name> saves the last proposal under a name you choose. /skill-factory clear wipes the session log. The README also notes that natural language works, with examples like save this as a skill or remember how to do this. That second path is the more interesting one, because it means the meta-skill can be triggered by intent rather than by you remembering the command name. The gap in the documentation is what queue and status actually count. Patterns tracked is not defined anywhere in the README, and without that definition you cannot tell whether the detector is counting distinct command sequences, repeated file edits, or something looser.
Generated plugin.py is a scaffold, and the README shows it that way
This is the limitation worth stating plainly. The generated plugin example in the README is a register function with a decorated async run_skill, and the body is three comment lines: Step 1 create venv, Step 2 install deps, Step 3 run tests. There is no shown implementation. The generated SKILL.md is more complete in appearance, with front matter, a When to Activate section, a Workflow section split into phases, and an Examples section, but the README truncates it with ellipses in several places. So the honest reading is that Skill Factory produces a well-shaped skeleton and a working skill definition, while the plugin needs you to fill in the actual calls. If you expected a slash command that runs your workflow end to end the moment you press C, you will be disappointed. The SKILL.md side is the more immediately useful output, because Hermes can act on instructions without you writing Python.
Compared with writing skills by hand
The alternative is the Hermes native path: author SKILL.md yourself, place it under ~/.hermes/skills/, and reload. That approach gives you full control over the When to Activate triggers and the phase structure, and it costs you the interruption of writing documentation mid-task. Skill Factory's difference is timing and authorship. It proposes at a moment it judges right, and it drafts the file from templates, so your job shifts from writing to reviewing. Whether that is better depends on how good the detection is, and detection quality is precisely what the README does not quantify. A hand-written skill will almost always be more precise, because you know which steps are load-bearing and which were incidental to that one session. The factory's advantage is volume: it can capture workflows you would never have bothered to write down.
Maintenance, the MIT licence, and the missing release history
The README's License section says MIT, which permits commercial use, modification and redistribution with the licence text retained. The repository metadata supplied here lists the licence as unknown, so the README claim and the repository metadata disagree, and that is worth resolving before you vendor anything. No releases were retrieved, so there is no version history to read for breaking changes. The last push is dated 2026-03-18. The stated Hermes floor of v2026.3 means a Hermes upgrade that changes the skill front matter or the hermes.command signature can break generated plugins, and since generated files are copied into ~/.hermes rather than installed as a package, nothing will warn you. Re-running hermes skills reload after a Hermes upgrade is the cheap check. The upgrade cost of Skill Factory itself is low, since it is a single SKILL.md and a single plugin file, but the files it generated for you are your maintenance burden from the moment they are written.
Editorial conclusion
Adopt it if you already run Hermes Agent v2026.3 or later and keep re-explaining the same setup, debug or PR sequence across sessions. Skip it if you are not on Hermes, or if you expect generated plugin.py files to run without editing, since the README shows the scaffold with placeholder steps rather than finished logic. Before installing, open docs/how-it-works.md and confirm it describes the detection mechanism, then read skills/skill-factory/SKILL.md to see what the meta-skill is actually instructed to observe. If those two files are as thin as the README's TL;DR, the value is in the templates, not the detection.
Community notes