Research brief · October 22, 2026

10 Advanced Hermes Tips for November (Pick Your Top 5)

Ten Hermes upgrades past install week: write approval, bundles, /learn, Curator, skill tests, real-profile cron, YOLO denies, goals, steer, and compress.

Reading time
20 min
Checked
Oct 22, 2026
Paper-cutout Hermes docs overview with Skills, Memory, Tools, Automation, and related feature cards arranged on a desk
Official Hermes features overview. November is for operating these gates, not collecting more cards.
Bottom line

Skip install and first-week basics. Turn on write approval, stack skills deliberately, pin before Curator runs, measure skill lift, and only then automate signed-in browser work behind a deny list and a completion contract.

November is a good month to stop collecting Hermes features and start operating them. If install week is already done, including what Hermes is, first run, skills basics, and Browser Use setup, the next gains come from gates, bundles, measurements, and boundaries for unattended work.

These are ten tips past that week, so a November video can pick five. Each section says when to use the feature, the commands or config keys from the Superbash lessons and the official Hermes docs, a sequence you can run, and a caveat. The figures are paper-cutout illustrations of each gate. They are not screenshots from a live session. Run /version before you copy a slash command. Release notes still move.

The bar for this list

  • Not how to install Hermes.
  • Not the five-skill starter stack already covered in the starter stack and the broader toolkit.
  • Reversible gates, a measured result, and consent that still holds when nobody is at the keyboard.

1. Gate every skill write

Self-improving Hermes is useful until an overnight review quietly invents a “better” procedure that deletes your boundaries. The write-approval gate stages every skill_manage write (create, edit, patch, delete, write_file, and remove_file) so you approve the diff before it becomes global procedural memory.

When to use it

Use when a small model learns aggressively, you share a profile, or a background refine runs after sessions.

Skip when you are alone on a disposable profile and every skill is hand-authored under version control. The default write_approval: false is fine there.

Config and commands

From the official Skills guide, under gating agent skill writes:

# ~/.hermes/config.yaml
skills:
  write_approval: true   # false = write freely (default)
/skills approval on
/skills pending
/skills diff
/skills approve
/skills reject

Staged writes land under ~/.hermes/pending/skills/ and survive restarts. Pair this with the memory consent desk in L22: memory and skill approval (/memory approval on) so facts and procedures both require review.

Steps

  1. Set skills.write_approval: true (or /skills approval on) and start a fresh session.
  2. Ask Hermes to save a non-critical workflow as a skill, or trigger a refine that proposes a skill change.
  3. Run /skills pending and open /skills diff in the CLI or Desktop. Chat truncates large diffs.
  4. Approve only if the name, triggers, steps, and boundaries match what you want repeated.
  5. Reject anything that embeds secrets, temporary project status, or “always” permissions.
  6. Confirm with /skills inspect <name> in a new session.
Paper-cutout skill write-approval desk with a pending diff card and approve and reject stamps
Write approval is a diff desk. A staged skill stays pending until you approve it.

Caveat

skills.guard_agent_created is a content scanner, not this gate. They are independent. A clean scanner result is not an approval. Batch skill_manage operations stage as one pending record. Confirm that your build renders a diff per operation. September 2026 fixes landed for batch diff rendering, so check that on the build you are running.

2. One slash, five skills

Recurring work rarely needs one skill. PR review wants tests, a security checklist, and a PR workflow in the same turn. Hermes lets you stack up to five leading /skill tokens, or wrap the set in a YAML bundle under one short command.

When to use it

Use when the same three to five skills always travel together and each already works alone (L04, L15).

Skip when you are still debugging a single procedure. Stacking amplifies a bad skill.

Commands

Official stacking, from the skills guide:

/github-pr-workflow /test-driven-development fix issue #123 and open a PR

Parsing stops at the first token that is not an installed skill, so paths starting with / stay arguments.

Bundle creation:

hermes bundles create backend-dev \
  --skill github-code-review \
  --skill test-driven-development \
  --skill github-pr-workflow \
  -d "Backend feature work — review, test, PR workflow"

hermes bundles list
hermes bundles show backend-dev
/backend-dev refactor the auth middleware
/bundles

Bundles live in ~/.hermes/skill-bundles/<name>.yaml with skills: and an optional instruction:. A bundle slug wins over a same-named skill. Missing skills are skipped with a note. The bundle does not install them for you.

Steps

  1. Prove each skill alone with /<skill> … in a fresh session.
  2. Stack two skills once by hand and check the combined behavior.
  3. Create a bundle with hermes bundles create … --skill ….
  4. Invoke /<bundle> with a real task and confirm every listed skill loads.
  5. Add a short instruction: only for durable handoff rules, such as “write failing tests first.”
  6. Document the bundle in team dotfiles if more than one profile needs it.
Paper-cutout skill bundle labeled backend-dev holding three skill cards beside a slash-command strip
A bundle is one slash command in front of skills you already proved alone.

Caveat

Loading a group of instructions is not evidence that every step ran correctly. Inspect the sources and the final artifact the same way you would for a single skill (L04).

3. /learn into a knowledge base

/learn turns a file, URL, folder, pasted notes, or the current conversation into a skill without hand-writing SKILL.md. Large sources become a knowledge-base skill: a lean SKILL.md plus references/ loaded on demand. Query cost stays proportional to the answer, not the book.

When to use it

Use when you already know what good looks like and the workflow will repeat (L15: /learn workflows).

Skip when the source is untrusted marketing copy, or you only needed a one-off answer. Prefer a project file over a skill.

Commands

/learn ./meeting-notes-method.md
/learn ./meeting-notes-method.md https://example.com/team-decisions-guide
/learn
/learn ~/books/designing-data-intensive-applications.pdf
/skills list
/skills inspect weekly-competitor-brief
/weekly-competitor-brief Research these three companies for this week: …
/source-check /weekly-competitor-brief Compare Company A and Company B

The official skills docs say /learn saves through skill_manage, so write approval applies if the gate is on. Re-running /learn on the same topic should update the matching skill instead of spawning a …-v2-final copy.

Steps

  1. Run the task once manually and save the method that actually worked.
  2. Point /learn at that method file, a URL, or the chat itself.
  3. Read the proposed name, description, triggers, steps, and boundaries before approving.
  4. For a large corpus, open references/ and confirm the chapters are distilled, not pasted verbatim.
  5. In a fresh session, invoke /<skill-name> explicitly. Auto-routing can miss it. L15 covers that.
  6. If the command is missing, start a new session or run /reload-skills on a surface that supports it.
Paper-cutout learn desk turning a long document into a skill card with a references drawer
/learn writes a local skill. A large source also gets a references drawer. It does not train the model.

Caveat

A source is input, not proof. /learn does not train model weights. It creates local instructions. Factual errors in the PDF survive unless you review them. Keep secrets out of skill text. Use the credential vault or env setup path instead.

4. Pin before you curate

Curator stales and archives long-unused managed skills. That is healthy until it archives the skill your Friday cron still names. Pin first. Prune second.

When to use it

Use when the library is crowded with experiments and near-duplicates (L13: Curator).

Skip consolidation on day one. Deterministic prune-only is the default and costs no auxiliary-model tokens.

Commands and config

hermes curator status
hermes curator list-unmanaged
hermes curator pin deployment-checklist
hermes curator backup --reason "before-first-curator-run"
hermes curator run --dry-run
hermes curator run
hermes curator list-archived
hermes curator restore <test-skill>
hermes curator ledger --limit 20
/curator status
/curator run --dry-run
/curator pin deployment-checklist

The default lifecycle in the official Curator docs and in L13 is active, then stale after 30 unused days, then archive after 90. Restore returns it. A background pass wants 168 hours since the last run and 2 hours idle.

curator:
  enabled: true
  interval_hours: 168
  min_idle_hours: 2
  stale_after_days: 30
  archive_after_days: 90
  consolidate: false
  prune_builtins: true

Skills listed in a cron job’s skills: field get similar protection from automatic transitions. Still pin them if tool-driven deletion must also be blocked.

Steps

  1. Run hermes curator status and list-unmanaged. Note the managed and unmanaged counts.
  2. Pin every skill used by release, deploy, or paid automation.
  3. Take a named backup.
  4. Run run --dry-run and read ~/.hermes/logs/curator/<timestamp>/REPORT.md.
  5. Run prune-only with hermes curator run.
  6. Restore a disposable archived skill once so recovery is proven.
Paper-cutout Curator desk with pinned skill cards, a dry-run report, and an archive tray
Pin the skills a cron job still names, then read the dry-run report before anything is archived.

Caveat

Hand-written and foreground-created skills are usually unmanaged until you adopt them. Hub and external skills stay off-limits. purge is manual and confirmed. Automatic maintenance archives. It does not silently delete. LLM consolidation (--consolidate) can cost 50 to 100 API calls. Treat it as an explicit refactor.

5. A/B your skills first

NVIDIA’s catalog headline of +41 correctness points is not a promise for your SKILL.md. The useful method is Tier-1 validation, positive and negative cases, then a with-skill run against a without-skill run, read as Skill Lift (L14: NVIDIA SkillEvaluator).

When to use it

Use when you are about to publish, schedule, or give a skill credentials.

Skip full Tier-3 for a throwaway personal checklist. Still run Tier-1 locally.

Commands

uv tool install --python 3.13 \
  "skillevaluator @ git+https://github.com/NVIDIA/SkillEvaluator.git@v0.1.0"
uv tool install \
  "git+https://github.com/NVIDIA/SkillSpector.git@v2.9.5"

# Hub install shows advisory findings when the binary is on PATH
hermes skills install openai/skills/k8s

# Local mirror of Hermes' install-time subset
skillevaluator validate ~/.hermes/skills/my-skill \
  --checks pii,unicode,lint,license,security \
  --no-dedup

skillevaluator create-eval-dataset ~/.hermes/skills/my-skill --full
skillevaluator doctor --agents codex --env-mode docker
skillevaluator tier3 evaluate ~/.hermes/skills/my-skill \
  --agents codex \
  --env-mode docker \
  --n-attempts 3
skills:
  tier1_advisory: true   # default; silent no-op until binary is installed

Hermes’ built-in guard still makes the allow or block decision. SkillEvaluator is advisory. The install-time subset is pii, unicode, lint, license, and security.

Steps

  1. Install the scanners and confirm skillevaluator --help in the same shell that launches Hermes.
  2. Inspect, then install, or validate a local skill, and disposition every material finding.
  3. Author explicit, implicit, contextual, and negative cases with observable assertions.
  4. Run a small Docker Tier-3 on a supported harness (Codex, Claude Code, or OpenCode, per the NVIDIA docs).
  5. Compare correctness, discoverability, tokens, time, and the worst single regression.
  6. Re-run one bounded task inside Hermes before scheduling. A Codex lift is not a Hermes lift.
Paper-cutout SkillEvaluator bench comparing a with-skill result and a without-skill result
Skill Lift is a with-versus-without measurement on your skill. A catalog headline is not your result.

Caveat

A missing SkillSpector means the security check did not run. Never call that clean. Token use can rise even when correctness rises. Do not rewrite the evals after a bad score just to green the chart.

6. Real profile, cron-safe

Default local browsing is a clean, logged-out profile. Real-profile mode snapshots your active Chromium profile so Hermes can act with your cookies, including on scheduled ticks. That is past L12 Browser Use week-one setup.

When to use it

Use when a recurring job must hit a site you already use, such as a price monitor or an internal wiki, and you accept consent-gated “act as me.”

Do not use it for hostile pages, payment changes, or anything you would not click yourself while signed in.

Config and patterns

From the official Browser guide, under real profile browsing and scheduled runs:

# ~/.hermes/config.yaml
browser:
  use_real_profile: true
  # optional: pin a specific Chrome profile directory name
  # real_profile_pin: "Profile 2"
  # headed: true   # watch the window; servers stay headless
/browser status

Cron-shaped requirements from the official docs:

  1. browser.use_real_profile: true
  2. Give the job the browser toolset. enabled_toolsets including browser wins when the job sets its own list.
  3. Assume nobody can answer a prompt. Vault credentials, and authenticator material, ahead of expiry. A login wall becomes a reported failure, not a hang.
# verify after a config change
hermes # then inside the session:
/browser status

Auth files re-sync from your real profile when a fresh session launches. Turning the toggle off deletes ~/.hermes/browser-profile/ on the next browser use.

Steps

  1. Enable use_real_profile. In Desktop that is Capabilities, then Browser, then Use My Real Browser Profile.
  2. Confirm /browser status and run a read-only signed-in check with a clear success condition and “do not submit forms.”
  3. Pin real_profile_pin if the last-used profile is the wrong identity.
  4. Create a cron job with the browser enabled and a narrow prompt. Dry-run it once while watching.
  5. Vault any credential the site will need after the cookie expires.
  6. Keep payment, account, and destructive actions behind a person. Never put them in the cron prompt.
Paper-cutout browser stage with a real Chromium profile, a credential vault, and a headless cron tick
Real-profile mode acts with your cookies. Vault what a login wall will ask for before the cron tick runs alone.

Caveat

This is convenience, not isolation. On Windows, the first snapshot may need the browser fully quit. If the copy fails, Hermes opens a fresh signed-out browser and reports real_profile_unavailable. Do not assume you are logged in. Pair this with the deny list in the next tip before leaving YOLO on overnight.

7. YOLO with a deny list

/yolo, hermes --yolo, or HERMES_YOLO_MODE=1 bypasses dangerous-command prompts for the session. That is reasonable in a disposable sandbox. It is reckless on a laptop with git remotes and cloud CLIs. approvals.deny is the user-editable floor that still blocks patterns even under YOLO.

When to use it

Use when you want fast iteration locally and absolute “never” rules for force-push, curl-pipe-shell, or raw disk writes (official Security guide).

Do not set approvals.mode: off on a machine with production credentials. L07: Security essentials covers Tailscale and scoped keys. This tip is the command-policy layer on top.

Config and commands

# ~/.hermes/config.yaml
approvals:
  mode: smart          # smart | manual | off
  deny:
    - "git push --force*"
    - "*curl*|*sh*"
    - "dd if=* of=/dev/*"

Always quote the patterns. A bare leading * is a YAML alias error.

/yolo
hermes approvals suggest              # dry run: numbered proposals
hermes approvals suggest --apply 1,3  # merge picks into command_allowlist
hermes approvals suggest --json

hermes approvals suggest only proposes commands you previously approved. Destructive classes are never proposed. Nothing applies without --apply.

The hardline blocklist (rm -rf /, fork bombs, and the rest of that class) stays above YOLO. There is no override.

Steps

  1. Add deny globs for the three commands you never want on this machine.
  2. Toggle /yolo on in a throwaway session and confirm the YOLO banner.
  3. Attempt a command that matches a deny pattern. Expect BLOCKED, not a prompt.
  4. Run hermes approvals suggest and review the proposals. Apply only boring, frequent, non-destructive patterns.
  5. Keep cron_mode and unattended_mode at deny unless the job is truly disposable.
  6. Restart after shrinking command_allowlist so live sessions drop old always-approves.
Paper-cutout YOLO session with a deny-list card blocking a force-push command
YOLO skips the prompt. approvals.deny is the floor that still blocks the patterns you listed.

Caveat

Deny rules are shell-command policy, not an OS sandbox. Renamed binaries, scripts, and interpreters can bypass basename globs. For real containment, use Docker or SSH backends and narrow credentials. YOLO is per session and can persist across resume. /new on messaging resets approvals.

8. Goals that self-judge

“Keep going” is not a plan. /goal adds a judge after every turn: done, continue, or wait. You write a completion contract (outcome, verification, constraints, boundaries, and a stop condition) and Hermes continues until the contract is met, blocked, or the turn budget hits (L17: persistent goals).

When to use it

Use when research, troubleshooting, or coding needs multi-turn persistence with a measurable finish line.

Skip when a single answer is enough. A goal spends an extra judge call per turn.

Commands

/goal draft Compare five coworking day passes in Central or Sheung Wan.
Verify today's price and opening hours from official sources.
Produce a dated comparison table with links.
Do not make a booking.
Stop and ask me if official information conflicts or requires an account.

/subgoal Include at least one option open after 8pm.
/goal status
/goal show
/subgoal
/goal pause
/goal resume
/goal clear
/goal gate add npm test
/goal gate
/goal wait 12345 Waiting for the build to finish

The default continuation budget is 20 turns. /goal resume keeps the goal and resets the counter. Goals are single-session. They are not a Kanban board.

Steps

  1. Draft with /goal draft and rewrite fuzzy verbs into checkable deliverables.
  2. Add /subgoal criteria instead of restarting.
  3. For code, attach a deterministic /goal gate (tests or lint). That is stronger than “looks good.”
  4. Watch /goal status while it runs. Pause if the scope drifts.
  5. On a block, read the reason yourself before accepting “impossible.”
  6. Clear the goal when you are finished so the next chat does not inherit it.
Paper-cutout goal contract with verification fields, subgoals, and a turn-budget counter
A goal is a completion contract with a turn budget, not a request to keep going.

Caveat

A judge is still a model. False positives happen. Do not combine a beginner /goal loop with /yolo and broad tools. Prefer primary sources, links beside claims, and hard boundaries around purchases, messages, and credentials.

9. Steer live, background the rest

When Hermes is busy, a second request means three different things. Use the command that matches the intent (L16: background, queue, and steer).

MeaningCommandWhat happens
Do this separately now/background or /bgIsolated session. It cannot see the foreground chat
Do this after the current answer/queue or /qNext full user turn, FIFO
Change the job in progress/steerInjects at the next safe tool-result boundary
What is active?/agents or /tasksStatus view, not a canceller

When to use it

Use /steer for scope, format, budget, audience, or safety corrections mid-run.

Use /background for independent research that must not muddy the main thread.

Avoid piling speculative /queue prompts. Stable v0.20.5 lacked selective queue cancel. Check that on your build.

Demo sequence

Plan a three-day Hong Kong itinerary for a first-time visitor.

/background Compare five rainy-day activities in Hong Kong using current official prices and opening hours. Return a sourced table.

/queue When the itinerary is complete, turn it into a one-page packing and booking checklist.

/steer Keep every journey MTR-friendly and avoid days costing more than HK$500 per person.

/agents

Steps

  1. Start one foreground task with a clear deliverable.
  2. Background only work that carries all needed context in its own prompt.
  3. Queue the follow-up that depends on the foreground result.
  4. Steer with one short correction when the active run drifts.
  5. Check /agents. Do not expect cancel controls there.
  6. Bound background permissions the same way you bound the foreground. Isolation of context is not isolation of tools.
Paper-cutout session desk showing a steer note on the live job and a separate background task
Steer changes the job in progress. Background work runs apart from that chat and cannot see it.

Caveat

/steer does not abort a running shell command. It waits for a safe boundary. If the run finishes first, steer text may fall through as a queued turn. CLI steer is text-only. Attached images queue normally.

10. Compress with focus

Long sessions fill the working desk: system prompt, tools, skills, memory, and chat. /context shows what is consuming space, with no LLM call. /compress turns older turns into a handoff summary and keeps recent exchanges verbatim (L19: context compress).

When to use it

Use when you are about to start a demanding phase and headroom is low.

Skip it if you still need every citation word for word. Save those to a file first. Compression is lossy for the active context. It is not a privacy delete of the transcript.

Commands

/context
/context all
/compress here 4 --preview
/compress here 4
/compress focus preserve the agreed budget, source rules, rejected options, and remaining questions
/compress --preview
/compress --dry-run
/compress --keep 4

/compact is an alias. The default keep for here is 2. The accepted keep count is 1 to 100. /compress --aggressive was not supported in v0.20.5. Check that on your build.

If a local model reports a nonsense window, set model.context_length using the official FAQ.

Steps

  1. Run /context all before a long next phase.
  2. Save exact requirements, figures, and citations to a durable file.
  3. Run /compress here 4 --preview and inspect the boundary.
  4. Compress, then ask Hermes to restate the preserved requirements.
  5. Prefer /compress focus … when one decision must survive.
  6. Budget the summarizer call. You pay once for a shorter briefing.
Paper-cutout context gauge beside a compress preview that keeps the latest turns verbatim
/context shows what is filling the desk. /compress summarizes older turns and keeps the recent ones verbatim.

Caveat

Compression breaks the existing prompt-cache prefix and costs a summarizer call. Soft-archived pre-compression turns may remain searchable under the same session, depending on config. Export anything legal or compliance-sensitive yourself.

The five to film in November

If the November video can hold five, this is the cut we would make unless a demo changes the story:

  1. Gate every skill write. The approve/diff desk is visual, and self-improvement does not drift in silence.
  2. One slash, five skills. Stack or bundle. The payoff is a command you would actually type again.
  3. Real profile, cron-safe. This is past L12. It shows unattended signed-in work done with a boundary.
  4. Goals that self-judge. It replaces “keep going” with a completion contract you can read on camera.
  5. A/B your skills first. Measurement, with Skill Lift and without the catalog headline.

Strong swaps: pin before you curate, or YOLO with a deny list. Both demo cleanly.

Hold for a shorter cut: /learn knowledge bases, steer versus background, and compress with focus.

Where to go next

Sources

Commands and defaults in this piece come from the Superbash Hermes lessons and the official docs those lessons cite:

Check on your build: your exact /version, whether a batch /skills diff shows one diff per operation, whether you can cancel a single queued prompt, and whether /compress --aggressive exists.

Put this to work

Treat each tip as a reversible experiment: enable the gate, run one bounded demo, then decide whether it earns a permanent place.

Try

Pick three tips this week. Capture a before/after for one skill write, one multi-skill command, and one /goal with a verification gate.

Prove it worked

Keep a tip only if it cuts review time, reduces accidental skill drift, or improves a measured with/without result without widening credentials.

Keep in view

  • Self-improving agents need an approve/diff desk before skill writes go global.
  • Stack up to five /skill tokens or ship a YAML bundle as one slash command.
  • Real-profile browser plus cron is useful only with vaulted credentials and a deny list under YOLO.
Learn the workflow: Hermes skills and skill bundles