Hermes Learning Loop: How Skills Get Written

Contains affiliate links. Disclosure.

Hermes Agent's learning loop is a background review that forks after each turn, reads what just happened, and may write one of two things: a compact memory entry, or a procedural skill saved as a SKILL.md file. Nous Research calls it a "closed learning loop" and documents no confidence score and no similarity threshold anywhere in it. The model decides. You can gate it, watch it, or switch it off.

What Hermes skills are not: they are not a vector index. There is no embedding store and no cosine-similarity cutoff to tune. Skills are Markdown files on disk, listed to the model as metadata and opened in full only when it decides one applies.

Everything below was checked against Nous Research's own documentation on 2026-09-09, against release v0.21.1 (tagged 2026-09-07). This guide assumes the one-container Compose stack is already running.

What this page got wrong before 2026-09-09

An earlier version of this page described a confidence-gated pipeline with a pgvector retrieval store. That mechanism does not exist. It is withdrawn in full, and here is what replaced each part, so anyone who acted on the old text can find the correction.

Withdrawn claim	What the vendor documents
Skills are written when a self-reflection score reaches ≥ 0.7	No numeric gate. The system prompt asks the agent to record a workflow "worth repeating"; the only gate is the optional skills.write_approval
HERMES_LEARNING_LOOP_CONFIDENCE_THRESHOLD, HERMES_SKILL_RETRIEVAL_THRESHOLD	Neither appears in the environment variables reference. The skill env vars are HERMES_BUNDLED_SKILLS and HERMES_OPTIONAL_SKILLS
Retrieval by pgvector cosine similarity, default 0.85	Progressive disclosure: a metadata list first, full skill text on demand. No similarity score
The format is "OpenClaw ClawHub's SKILL.md standard"	Compatibility is with the agentskills.io open standard. ClawHub is one community source among several, not the format
hermes skills reindex, import, deduplicate, delete, export	None of these exist. See the command table below
"40–60% faster on repeated workflows"	Our own single measurement said 66–71%, and it was one task on one day. See the caveats below

What makes Hermes write a skill?

The agent writes skills itself, through a tool called skill_manage, whose actions are create, patch, edit, delete, write_file and remove_file. Nothing counts anything. Per the skills documentation, the system prompt tells the agent to record a workflow for future reuse when it has worked out a multi-step workflow worth repeating, when it hit errors and found a path that worked, or when you corrected its approach.

Three consequences follow, and they are the ones that matter operationally:

1. A correction is a strong trigger. Telling Hermes "no, use the staging endpoint" is more likely to produce a durable skill than running the same clean task ten times.
2. You cannot tune sensitivity. There is no threshold to lower during a training week. If you want more skills, do harder things and correct them.
3. A quiet session is not a broken loop. auxiliary.background_review.enabled defaults to true, and display.memory_notifications defaults to on, which prints a short 💾 Memory updated line when the review acted. Set it to verbose while you are learning the system.

Two related settings shape when the review runs at all: auxiliary.background_review.defer (default auto) queues the review on a local GPU until the box is idle, and auxiliary.background_review.defer_max_age_s (default 1800) forces a queued review to run after half an hour.

If you want the loop off entirely, set auxiliary.background_review.enabled: false. Manual refinement commands still work.

Where do learned skills land in Docker?

In the official Docker layout, /opt/data is the single source of truth and maps to what would be ~/.hermes on a host install. Skills sit in /opt/data/skills, alongside config.yaml, .env, memories/, sessions/ and logs/.

One skill is one directory, not one file:

/opt/data/skills/
├── reporting/weekly-crm-summary/
│   ├── SKILL.md
│   ├── scripts/
│   └── references/
├── .hub/
│   ├── lock.json          # installed hub skills
│   ├── taps.json          # subscribed repos
│   ├── quarantine/        # skills the scanner blocked
│   └── audit.log
└── .bundled_manifest

By default agent-written skills go to the profile-local skills directory. Set skills.create_dir if you want them somewhere else — a git-tracked repo, or a shared volume that several Hermes instances mount. That is the supported way to build a fleet-wide "brain", and it is a config key rather than a copy job.

Back this directory up on its own schedule. It is the only part of the volume that cannot be regenerated by re-running a task.

How do you approve skills before they are written?

By default Hermes writes skills without asking, including from the background review. On a shared or regulated box, that is worth changing. It is also worth changing when you run a small local model, which is more likely to misjudge what it learned.

The equivalent gate for memory is memory.write_approval, also false by default. Memory entries are small enough to read inline in chat; skills are not, which is the practical reason the two are separate switches. The Hermes architecture overview covers how the two stores differ and how long each lives.

Which hermes skills commands actually exist?

These are the subcommands Nous Research documents on the skills page, with the vendor's own description of each (checked 2026-09-09).

Command	What it does
hermes skills list	Lists installed hub skills
hermes skills browse / search	Browse or search the hub sources
hermes skills inspect	Preview before install: repo URL, weekly installs, security audit status
hermes skills install / uninstall	Add or remove a hub skill
hermes skills check	Reports which installed hub skills changed upstream
hermes skills update	Reinstalls only the changed ones; skips locally-edited skills unless --force
hermes skills audit	Re-scans all hub skills for security. Not a staleness report
hermes skills reset	Un-sticks a bundled skill from "user-modified". --restore also re-copies the bundled version
hermes skills opt-out	Stops future seeding of bundled skills for the profile by writing a .no-bundled-skills marker; --remove also deletes bundled skills you have not edited
hermes skills opt-in	Removes the marker and re-enables bundled-skill seeding; --sync syncs immediately
hermes skills snapshot export	Exports skill config
hermes skills pending / diff / approve / reject	The write-approval queue; also available as /skills … slash commands in a session
hermes skills approval on / off	Toggles the skills.write_approval gate from the CLI
hermes skills tap add / remove / list	Subscribe to a GitHub repo of skills
hermes skills trust / untrust	Trust project-local skills in .hermes/skills or .agents/skills
hermes skills publish	Publish a skill to a provider repo

Note what is missing. There is no reindex, because nothing is indexed. There is no import or bare delete. There is no hermes skills export for a single skill — snapshot export writes skill config, not a portable skill bundle. To move one skill somewhere else, copy its directory.

audit is the command most often misread. It re-runs the security scanner, which checks for data exfiltration, prompt injection, destructive commands and supply-chain risks, quarantining what it blocks in .hub/quarantine/. It will not tell you which skills have gone stale. Nothing will; that is your job.

What does a Hermes skill file look like?

The frontmatter fields Nous Research documents are name, description, version, author, license and platforms, plus a nested metadata.hermes block carrying tags, category, related_skills, requires_toolsets, requires_tools, fallback_for_toolsets, fallback_for_tools, a config array and an optional blueprint for scheduled runs. Credential needs are declared in required_environment_variables and required_credential_files.

---
name: weekly-crm-summary
description: Weekly CRM activity summary with week-over-week deal velocity.
version: 1.0.0
metadata:
  hermes:
    category: reporting
    tags: [crm, reporting]
    requires_toolsets: [terminal]
---
# Weekly CRM summary

## When to Use
## Quick Reference
## Procedure
## Pitfalls
## Verification

That body order is the vendor's recommendation, and it is not cosmetic. Loading is progressive: the model first sees only metadata for every skill (around 3k tokens for the whole library), then opens one skill's full text, then a specific reference file if it needs one. Common path first keeps the token cost of a routine task low.

The description field is what the model reads when deciding whether to open a skill. Generated descriptions tend to be too specific — "summary for the week of April 28" instead of "weekly CRM summary comparing this week to last". Widening that one line is the highest-value edit you can make to a generated skill.

Skills are invoked as slash commands (/weekly-crm-summary), stacked (/skill1 /skill2 instruction), or picked up from ordinary conversation.

Does a learned skill make the second run faster?

We measured this once, and once is what you should treat it as.

Run	Task	Time
Cold, no skill	Weekly CRM summary	6m 14s
With the learned skill	Weekly CRM summary	2m 07s
After widening the skill's description	Weekly CRM summary	1m 49s

Tested 2026-05-01 on local Docker, 4 vCPU / 16 GB, with a hosted Anthropic model over the API. That is 66% and 71% faster respectively.

Do not budget against these numbers. It is one task type, one dataset, one day, n=1, and it was run against a build several minor versions before v0.21.1. We have not re-run it. The mechanism behind the saving is not mysterious — the skill supplies a procedure the agent would otherwise have to discover with exploratory API calls — but the size of the saving depends entirely on how much discovery your task needs. A task that was already one obvious API call will not get 66% faster.

If you need a defensible number for your own workflow, time it yourself: run the task cold, let the review write the skill, run it again the next day.

Can you move skills between Hermes and other agents?

Hermes skills are documented as compatible with the agentskills.io open standard, and the hub can install from several sources: a bundled official/ set, the skills-sh public directory, well-known URL discovery, direct GitHub repos, and the community marketplaces including ClawHub, LobeHub and browse.sh. Default GitHub taps are openai/skills, anthropics/skills, huggingface/skills and NVIDIA/skills.

Trust is tiered: builtin, then official, then trusted (those default taps), then community — the lowest, installable only past the scanner or with --force.

The honest limit: portability is a shared file format, not a runtime guarantee. A skill written against Hermes toolsets can be read anywhere and will still fail anywhere that lacks those tools. If you want portable procedures, write them as hand-authored skills with explicit shell and HTTP steps rather than harvesting generated ones.

When is a hand-written skill the better choice?

	Hand-written skill	Learned skill
Available on first run	Yes	No — the loop needs a completed task first
Authorship cost	Yours, up front	None
Correctness	As good as the author	As good as the run it was distilled from
Behaviour when the target API changes	Fails visibly, you fix it	Degrades quietly; the agent improvises around it
Review burden	One review, at authoring time	Ongoing, unless skills.write_approval is on

If the workflow is one you will run for years and cannot afford to have drift, write the skill yourself and put it in a tap. The learning loop earns its place on the messier half of the work: the tasks you do not know you will repeat until you have repeated them.

If you are still choosing between agents, the self-hosted assistant comparison covers where an agent-first design like Hermes costs more to operate than a gateway.

What the loop will not do for you

• It will not notice that a skill went stale. No command reports staleness. Set your own reminder for skills that touch third-party APIs.
• It will not keep credentials out by magic. skills.guard_agent_created scans for dangerous patterns, but it is false by default. Turn it on before you let the loop run unattended.
• It will not deduplicate. Two similar skills stay two similar skills until you merge them by hand.
• It will not learn from a failure the way it learns from a fix. A correction that leads to a working path is the trigger; an abandoned task mostly is not.

🖥️

Liquid Web

Run this on a Managed VPS

The learning loop does not change Hermes's sizing — skills are Markdown files, and Nous Research's own guidance is 2–4 GB. What does change is what a lost disk costs you: the skills directory is the one part of /opt/data nobody can regenerate. A Managed VPS is worth paying for here mainly for the backup and patching, not for the RAM.

From $72/mo list ($36/mo intro) · 99.99% uptime SLA · Managed security · 24/7 support · Prices subject to change

View Managed VPS plans →

Frequently Asked Questions

A background self-improvement review that forks after each turn in a Hermes Agent session. It reads the conversation and may write a compact memory entry or a procedural skill file. Nous Research's README calls it a closed learning loop: skills are created after complex tasks and refined during use. Checked against the vendor docs on 2026-09-09.

None that Nous Research documents. Skill creation is prompt-driven: the agent is told to record a multi-step workflow worth repeating, a path it found after hitting errors, or an approach you corrected. The only documented gate is skills.write_approval, which stages writes for manual review and defaults to false. Any numeric threshold you have read about, including on an earlier version of this page, is unverified.

Under the data volume. In the official Docker layout /opt/data is the single source of truth and maps to ~/.hermes, so skills land in /opt/data/skills, one directory per skill with a SKILL.md inside. Set skills.create_dir to send agent-written skills elsewhere, such as a git-tracked repo or a shared volume.

Point both at the same directory with skills.create_dir, or add external directories with skills.external_dirs. Do not share a whole data directory between two running gateways: Nous Research's guide is explicit that session files and memory stores are not built for concurrent writes. Share the skills path, not the volume.

Yes, provided the data directory survives. Skills are plain Markdown on the mounted volume, not in the image, so pulling a new tag and recreating the container keeps them. They do not survive docker compose down -v. Take a tarball of ./data before any upgrade anyway.

Delete its directory under the skills path. There is no hermes skills delete for agent-written skills: uninstall removes hub-installed skills, and reset un-sticks a bundled skill that Hermes has marked user-modified. Neither applies to something the learning loop produced.