Subtopic 2.7 is the Hermes Agent Curator — the background maintenance system that automatically manages the skills the 15-turn self-evolution loop (§2.1.2) creates. As your Hermes Agent creates skills through its self-improvement loop, the Curator consolidates, prunes, and organizes them to prevent clutter and maintain optimal performance. The Curator is the operational layer underneath the §2.5 Skills surface; you do not invoke it directly, you schedule it and read the report.

The Curator is the channel's quietest feature (the source video SpFgS7WlCJc is in the few-hundred-views range), but the most load-bearing for any long-running agent. Every 15 turns your agent rewrites a skill; without a Curator, the skills folder turns into a graveyard of near-duplicates. The source video and the archive guide 26-hermes-curator-guide.md are both short, both practical, and both worth reading end-to-end before you run a multi-day cron on a real workload.

What you'll learn

  • The Curator solves a specific problem: over time, Hermes automatically creates many skills based on tasks you give it. Without a Curator, you get a cluttered skills folder, near-duplicate skills, unused or outdated skills, and no way to track which skills are actually being used.
  • The Curator runs automatically (configurable to once a week or daily) and: tracks skill usage frequency, records when skills were last updated/created, archives unused skills (recoverable, never deleted), consolidates near-duplicate skills, and never touches bundled (native) skills.
  • The default install is hermes update then hermes curator status to confirm the feature is enabled, then hermes curator run sync to run with live logs (recommended first time) or hermes curator run to run in background.
  • The full report lives at ~/.hermes/logs/curator/[timestamp]/report.md and contains: archived skills, patched/absorbed skills, skill demotions, clusters left alone, and the LLM's final summary.
  • Restoration is trivial. Archived skills are recoverable with hermes curator restore [skill-name]. The Curator never auto-deletes; it only archives.
  • Three concrete failure modes are documented in the source and the archive guide: no report generated (missing Curator block in ~/.hermes/config.json or missing logs directory), Curator takes too long (configuration drift, missing Curator block, log directory wrong), and the "no module named fire" daemon-thread import error (known bug — ask your Hermes Agent to diagnose).

1. What the Curator is, and what it is not

Hermes Curator (SpFgS7WlCJc, few hundred views, published 2026-05-06) is the channel's dedicated setup video for the Curator. The framing, from the archive guide: "The Hermes Agent Curator is a background maintenance system that automatically manages agent-created skills. As your Hermes Agent creates skills through its self-improvement loop, the Curator consolidates, prunes, and organizes them to prevent clutter and maintain optimal performance."

The problem the Curator solves. Over time, your Hermes Agent automatically creates many skills based on tasks you give it. This can lead to:

  • Cluttered skills folder — hundreds of skill files in ~/.hermes/skills/ with no organisation.
  • Near-duplicate skills — the 15-turn self-evolution loop will write thumbnail_v2 and thumbnail_v2_with_emoji as separate files.
  • Unused or outdated skills — a skill that worked in April may not be the right shape in June.
  • Difficulty tracking which skills are actually being used — without telemetry, you cannot prune confidently.

The Curator's four jobs (from the archive guide, confirmed by the source video):

  • Track skill usage frequency.
  • Record when skills were last updated/created.
  • Archive unused skills (recoverable) — this is the key word. Archive, not delete.
  • Consolidate near-duplicate skills — merge into a single canonical skill.
  • Never touches bundled (native) skills — the native skill set is sacred; only agent-created skills are candidates for the Curator's attention.

That last bullet is the operational safety net. The native skill set is what shipped with the Hermes build; the Curator cannot touch it. So the worst-case Curator run is "the agent-created skills got reorganised." Native skills survive every time.

2. Setup — four commands, then a report

Step 1: Update Hermes Agent. First, ensure you have the latest version:

hermes update

Wait for the update to complete before proceeding.

Step 2: Check Curator Status. Verify that the Curator feature is enabled:

hermes curator status

You should see:

  • Whether Curator is enabled.
  • Number of agent-created skills.
  • Top 5 least recently used skills.

That last field — top 5 LRU — is the most actionable. If a skill you actually use shows up in the top 5, the Curator will mark it for archiving on the next run. Fix the usage tracker (or re-run a task that hits that skill) before the next run, or restore it from the archive afterwards.

Step 3: Run the Curator. You have two options:

  • Option A: Run with live logs (recommended for first time).
hermes curator run sync

The sync option lets you watch the process in real-time, which is helpful for understanding what's happening.

  • Option B: Run in background.
hermes curator run

Use this for scheduled / cron-driven runs. The cron for the Curator is the §2.4 cron tab — most setups wire the Curator into a weekly cron via the dashboard.

Step 4: Review the Report. After completion, you'll see a summary. The full report is located at:

~/.hermes/logs/curator/[timestamp]/report.md

Open the report to review:

  • Skills archived — agent-created skills the Curator moved to the archive. Recoverable.
  • Skills patched/absorbed — near-duplicate skills consolidated into one.
  • Skill demotion — skills that were downgraded in priority.
  • Clusters left alone — native bundled skills that Curator doesn't touch. Sanity check.
  • LLM final summary — the most important section with actionable insights. This is the section the Curator's own LLM writes about what it did and why.

3. The Curator's report — what to look for

The archive guide is explicit on which sections matter. The LLM final summary is the most important section — the Curator's own LLM writes a short prose note about the run, and that note is the section to read in full.

Archived skills are the section that requires the most attention. If a skill you actively use has been archived, the first thing to do is restore it with hermes curator restore [skill-name]. The archive is the Curator's "are you sure?" prompt; you can answer "no" without losing the original.

Patched/Absorbed skills are the section that matters for quality. If three near-duplicate skills got merged into one, check that the merged skill actually has the union of the three original behaviours. The archive guide flags that the LLM review is what produces this consolidation, and that the LLM is "helpful but not perfect—verify its decisions match your needs."

Skill demotion is the section that matters for priority. A demoted skill is still on disk and still usable, but the agent will prefer other skills. If a demotion is wrong, the fix is to use the skill more — usage frequency is what re-promotes it.

Clusters left alone is the section that matters for safety verification. If the report claims a native skill cluster was "left alone," that is the receipt that the Curator's "never touch native skills" invariant held. If a native skill appears under "Skills patched" or "Skills archived," that is a bug — file it.

LLM final summary is the section that matters for next steps. The Curator's LLM summarises the run in 2–4 paragraphs and often flags skills the user should review manually. Read this section first.

4. Restoring archived skills

If the Curator archived a skill you still need:

hermes curator restore [skill-name]

Replace [skill-name] with the exact name of the skill from the report. The restore is immediate; the skill reappears in ~/.hermes/skills/ and the agent can use it on the next session.

The archive guide's safety note: "The Curator never auto-deletes skills—it only archives them (recoverable)." That is the operational guarantee. Even the worst-case Curator run is recoverable in one command.

5. Failure modes — and the fixes

Issue: No report generated. If the Curator runs but produces no report:

  1. Check for Curator block in config file. The config file (~/.hermes/config.json) should contain a Curator configuration section. If missing, you need to add it manually or ask your Hermes Agent to fix it.
  2. Verify the logs directory exists. Check if ~/.hermes/logs/curator/ exists. If not, the Curator cannot write reports.
  3. Check for import errors. The Curator runs its LLM review in a daemon thread. If you see "no module named fire" errors, this is a known bug. Ask your Hermes Agent to diagnose and fix the issue.

Issue: Curator takes too long. If the Curator runs for over an hour with no output:

  1. Feed the official Curator documentation to your Hermes Agent.
  2. Ask it to check if everything is configured correctly.
  3. Verify the Curator block exists in your config file.
  4. Check that the logs directory structure is correct.

Common configuration issues:

  • Missing Curator block. Your ~/.hermes/config.json should include a Curator configuration section. If it's missing, the Curator cannot create the necessary directories.
  • Daemon thread errors. The Curator may fail silently if there are import errors. Check the state file for error messages.

6. Best practices

  1. Run weekly. Set up the Curator to run once a week for optimal maintenance. The §2.4 cron tab is the right surface — schedule hermes curator run for a low-traffic hour (e.g. Sunday 03:00).
  2. Review reports. Always check the report after each run to ensure important skills weren't archived.
  3. Restore promptly. If you notice a needed skill was archived, restore it immediately.
  4. Manual verification. The Curator is helpful but not perfect — verify its decisions match your needs. The archive guide's exact phrasing: "The Curator is helpful but not perfect—verify its decisions match your needs."

7. Tips

  • The Curator never auto-deletes skills — it only archives them (recoverable).
  • Native bundled skills are never touched by the Curator.
  • You can configure how often the Curator runs (default is weekly; daily is also valid for high-skill-velocity workflows).
  • Keep track of your most-used skills to ensure they're not accidentally archived. The hermes curator status "top 5 LRU" view is the early warning.

The Curator's interaction with the 15-turn self-evolution loop. The §2.1.2 15-turn self-evolution loop creates new skills; the Curator prunes them. The two are in a feedback loop. The 15-turn loop creates skills at a rate of roughly 1 per 15 turns (per turn, the agent may rewrite, split, or merge a skill). Over a 60-day period, the agent may create 200+ skills. Without the Curator, the skill library grows unbounded; with the Curator, the library is bounded by the weekly archive cadence. The right configuration: the 15-turn loop creates, the Curator prunes weekly, the user reviews the LLM final summary each week.

The Curator's interaction with the Skill Bundle primitive. Skill Bundles reference skills by name. When a Curator run archives a skill that a bundle references, the bundle is broken (the next /bundle-name invocation will fail because the skill is in the archive). The fix: the user reviews the LLM final summary each week and restores any skill that a bundle references. Cross-reference §2.5.4 — the lifecycle: agent creates skill → bundle pins skill → curator archives skill → user restores skill → bundle works again.

The Curator's interaction with the Kanban workers. Kanban worker profiles invoke skills via the profile's SOUL.md and the skill registry. When a Curator run archives a skill that a worker profile invokes, the worker's run fails with a "skill not found" error. The fix: the user reviews the LLM final summary each week and restores any skill that a Kanban worker profile invokes. The Worker Logs surface the skill-not-found error in the parent's audit trail.

The Curator's daily vs weekly cadence. The default cadence is weekly; daily is also valid for high-skill-velocity workflows. The trade-off: daily catches stale skills faster, but the LLM review costs tokens. Weekly is the right default for most users; daily is for users who are running the 15-turn loop aggressively and want to keep the skill library tight. The source video's framing: the channel's own setup runs weekly on Sunday 03:00.

The Curator is a first-class feature of Hermes v0.12.0 "The Curator" (released 2026-05-01 per the §2.1.2 release-arc context). The release name is the literal source of the §2.7 subtopic's framing. The v0.12.0 release was 4 new providers, ~57% cold-start reduction, and "autonomous skill maintenance" as the headline feature.

Why the Curator is in the v0.12.0 release, not earlier. The 15-turn self-evolution loop (§2.1.2) was already creating skills in v0.11.0 and earlier — the host's "creator previously had to do this by hand — opening code, reading scripts, troubleshooting — just to improve thumbnail quality" framing was true in v0.11.0. The v0.12.0 release added the operational layer underneath the self-evolution: a way to keep the skill library clean without the user having to review it by hand. The release-arc context (cross-reference §2.8 Part B) is that v0.10 shipped the tool gateway (the $10/month News Portal), v0.11 shipped the TUI rewrite (1,500 commits), and v0.12 shipped the Curator — three releases, three layers of the same operational stack.

The "57% cold-start reduction" headline. The v0.12.0 release notes cite a ~57% cold-start reduction as a side benefit of the Curator. The framing: every time the agent restarts, it has to re-load the skill library. Without the Curator, the library grows unbounded; the cold-start time grows with it. With the Curator archiving unused skills, the cold-start library is bounded, and the cold-start time drops. The 57% number is the empirical result on the channel's own agent stack; the number is the receipt that the Curator is doing its job.

The release-arc context for §2.7. The Curator is the operational layer underneath §2.5 Skills & Skill Bundles. It runs once a week (or daily, in high-skill-velocity workflows). The report goes to ~/.hermes/logs/curator/[timestamp]/report.md. The LLM final summary is the section to read in full. The restore command is hermes curator restore [skill-name]. The archive is recoverable; the native skill set is sacred; the agent-created skills are the Curator's domain.

9. The Curator's relationship to the 15-turn self-evolution loop

The §2.1.2 15-turn self-evolution loop is the source of the skills the Curator manages. The relationship is straightforward:

  • The 15-turn loop creates skills. Every 15 turns, the agent audits its own performance and rewrites a skill. The skill lives in ~/.hermes/skills/. If the agent decides the same skill needs to be split into two, the new skill lands as a sibling. If the agent decides two skills should be merged, the new merged skill lands as a replacement.
  • The Curator archives skills it doesn't recognise. The Curator's LLM review compares the agent's current skill set to the documented skill set. Skills that the LLM cannot place in the current workflow are candidates for the archive.
  • The user reviews the LLM final summary. If a skill in the archive is actually needed, the user restores it with hermes curator restore [skill-name].
  • The next 15-turn loop may recreate the skill. If the agent's next audit cycle decides the archived skill is needed, it will be recreated. The 15-turn loop and the Curator are in a feedback loop: the 15-turn loop creates skills, the Curator prunes them, the user reviews the prune, the 15-turn loop creates again.

The right cadence for the Curator. The archive guide's recommendation: weekly, with daily as an option for high-skill-velocity workflows. The channel's own setup runs weekly on a low-traffic hour (Sunday 03:00). A daily cadence is overkill for most users; a monthly cadence is too infrequent (the skill library will grow too large between runs). Weekly is the right default.

The right cadence for the 15-turn loop. The 15-turn loop is on by default in any BYOK setup, no paid model required (per 2NbfOOD2i1E summary). The cadence is not configurable in the source video; the 15-turn interval is a platform decision. If the 15-turn loop is creating too many skills, the workaround is to run the Curator more frequently (daily instead of weekly) or to disable the 15-turn loop on specific profiles (per the source video, the loop is per-profile). The user cannot change the 15-turn interval itself.

10. The Curator worked example — a weekly run end-to-end

A worked example, reconstructed from the archive guide and the source video's framing. The setup: a Hermes install on a 4 GB VPS, with the 15-turn self-evolution loop enabled, running daily for 60 days. The skill library has grown to ~150 skills. The user schedules a weekly Curator run for Sunday 03:00.

The pre-run state. The user runs hermes curator status to check the pre-run state. The output:

  • Curator enabled: yes.
  • Agent-created skills: 152.
  • Top 5 LRU: thumbnail_v1, thumbnail_v2, image_gen_v1, presentation_maker_v1, data_pivot_v1.

The 152 skills include ~30 native skills (untouched by the Curator), ~80 active agent-created skills, and ~42 stale skills (LRU > 30 days). The user notes that thumbnail_v2 is actually still in use; the LRU is misleading because the skill is invoked in a cron but the invocation is silent. The user adds thumbnail_v2 to the "do not archive" list (per the source video's "Keep track of your most-used skills" tip).

The run. The user runs hermes curator run sync to watch the first run in real-time. The sync output, paraphrased:

[2026-05-06 03:00:00] Curator run started.
[2026-05-06 03:00:05] Loaded 152 agent-created skills.
[2026-05-06 03:00:10] Cluster analysis: 18 clusters identified.
[2026-05-06 03:00:15] Cluster "thumbnail" (4 skills): consolidate to thumbnail_v3.
[2026-05-06 03:00:18] Cluster "image_gen" (3 skills): consolidate to image_gen_v2.
[2026-05-06 03:00:25] Cluster "data_pivot" (2 skills): consolidate to data_pivot_v2.
[2026-05-06 03:00:30] Skill `old_api_wrapper` (last used 2025-12-15): archive.
[2026-05-06 03:00:35] Skill `backup_creator_v1` (last used 2026-01-20): archive.
[2026-05-06 03:00:40] Skill `slide_maker_v1` (last used 2026-02-10): archive.
... (38 more archive decisions)
[2026-05-06 03:01:20] Curator run complete. Report: ~/.hermes/logs/curator/2026-05-06/report.md

The report. The user opens ~/.hermes/logs/curator/2026-05-06/report.md and reads the LLM final summary first:

"This week's run consolidated 18 skill clusters into 12 canonical skills, archived 38 stale skills, and demoted 4 skills. The most significant consolidation was the 'thumbnail' cluster (4 skills → 1 canonical). The most concerning archive was backup_creator_v1 — the user may want to verify this is not in use. Native skills were not touched. Recommend the user review the 'archived' section and restore any skill that was archived by mistake."

The user reviews the archive list. backup_creator_v1 is in fact still in use — it backs up the daily AI-news briefing to a remote S3 bucket. The user restores it with hermes curator restore backup_creator_v1. The other 37 archive decisions are confirmed correct.

The post-run state. The user runs hermes curator status to verify the post-run state. The output:

  • Agent-created skills: 113 (down from 152).
  • Archived skills (recoverable): 38.
  • Clustered (consolidated): 18 → 12.
  • Demoted: 4.

The skill library is 26% smaller. The cold-start time is faster (cross-reference §2.7.8 — the v0.12.0 release's "~57% cold-start reduction" headline). The user notes that the next weekly run will be even faster, because the LLM has fewer skills to review.

The Curator's LLM final summary — what it actually does. The LLM's role in the Curator run is to:

  1. Cluster the agent-created skills into groups of near-duplicates. The LLM uses semantic similarity, not just filename similarity — two skills with different names but similar functionality end up in the same cluster.
  2. Pick a canonical skill for each cluster. The LLM picks the most-recently-used, most-generally-useful skill as the canonical, and the others are absorbed into it.
  3. Decide what to archive for stale skills. The LLM uses the last-used timestamp, the usage frequency, and the skill's metadata to decide.
  4. Demote skills that are useful but not as useful as the canonical. Demoted skills are still on disk and still usable, but the agent will prefer the canonical.
  5. Write the LLM final summary — a short prose note (2–4 paragraphs) about what the run did and why. The user reads this section first.

The Curator's archive vs delete distinction. The archive guide's safety note is load-bearing: "The Curator never auto-deletes skills—it only archives them (recoverable)." The "recoverable" word is the receipt. Even the worst-case Curator run — the LLM mis-identifies a skill as stale and archives it — is recoverable in one command: hermes curator restore [skill-name]. The restore is immediate; the skill reappears in ~/.hermes/skills/ and the agent can use it on the next session.

The Curator's native-skill safety net. The archive guide's other load-bearing note: "Native bundled skills are never touched by the Curator." The native skill set is what shipped with the Hermes build; the Curator cannot archive, absorb, or demote native skills. The worst-case Curator run on a native skill is "the skill is left alone." This is the safety net for the safety net — even if the LLM's cluster analysis goes off the rails, the native skills are protected.

Try it yourself

  1. Update first. Run hermes update. The Curator's CLI surface (hermes curator ...) is gated on a recent build.
  2. Run hermes curator status and confirm the Curator is enabled, the agent-created skill count is non-zero, and the top 5 LRU does not include any skill you actively use.
  3. Run hermes curator run sync to watch the first run in real-time. The sync flag is the source's "recommended for first time" path.
  4. Open ~/.hermes/logs/curator/[timestamp]/report.md and read the LLM final summary first. Then walk through the archived / patched / demoted sections.
  5. Restore any archived skill you need with hermes curator restore [skill-name]. The archive is recoverable, but only if you act.
  6. Wire a weekly cron in the Dashboard's cron tab (§2.4) so the Curator runs unattended. Schedule for a low-traffic hour.
  7. Verify after every Hermes update that the Curator block is still in ~/.hermes/config.json and the ~/.hermes/logs/curator/ directory still exists. The archive guide flags both as the most common silent-failure causes.
  8. Treat the LLM final summary as the canonical review surface. If you read only one section of the report, read that one.

Common pitfalls

  • Don't skip hermes update before running the Curator. If the hermes curator ... command is missing, you are on an old build and the Curator's CLI surface is not available.
  • Don't ignore a missing report. A Curator run that produces no output is almost always a missing Curator block in config.json or a missing ~/.hermes/logs/curator/ directory. Both are fixable in one edit; the archive guide flags both.
  • Don't assume the "no module named fire" daemon-thread error is a transient glitch. It is a known bug. The fix is to ask your Hermes Agent to diagnose — do not just retry the run.
  • Don't let the Curator run for over an hour with no output. That is the "Curator takes too long" symptom. Feed the official docs to the agent and verify the config block.
  • Don't skip the report review. The Curator is "helpful but not perfect." A skill you need may be in the archive. The restore is one command; missing the review is a slow drift into broken pipelines.
  • Don't confuse "archived" with "deleted." The Curator never deletes. The hermes curator restore [skill-name] command is the receipt.
  • Don't run the Curator on a build where the §2.5 Skill Bundles YAML is hand-edited. A Curator run may absorb a hand-edited bundle into a default skill. Commit your hand-edited bundles to a shared dotfiles repo (§2.5.1) before any Curator run.
  • Don't run the Curator without first reading the LLM final summary of the previous run. The LLM's notes are the only place the Curator explains why it did what it did; without that, the next run is opaque.

Sources

  • Hermes Curator — few hundred views · video_id: SpFgS7WlCJc
  • Archive guide: Hermes Agent Curator Guide: Fix Your Agent Skills — full setup, report sections, restoration, troubleshooting, best practices.
  • Cross-reference: §2.1.2 (15-turn self-evolution loop — the source of the skills the Curator manages).
  • Cross-reference: §2.5 (Skills & Skill Bundles — the surface the Curator operates below).