Jonathon's AI Wiki

Hermes Skill Bundles — Slash-Command Skill Composition

15 min read

Source: Hermes Agent NEW Skill Bundles Setup Guide (YouTube _A02brv2Csg), Ron, 2026-05-21. Hermes Agent feature shipped by Nous Research.

A new Hermes feature that lets you save a named set of skills behind one slash command, so a multi-step workflow loads its full skill kit deterministically instead of relying on the agent to pick the right skills on the fly. Bundles are tiny YAML files under ~/.hermes/skill-bundles/. Solves the probabilistic-skill-invocation problem: AI agents may skip skills you intended them to use; bundles make the skill set explicit per workflow. Composable with the self-improvement loop — consult Hermes itself about which skills to bundle for a workflow, let it draft the YAML, review, ship. The newest skill-creation path is learn`, which turns any source (URL, PDF, video, repo, or a procedure you just performed) directly into a skill.md to drop into a bundle. Adjacent surface to the Browse.sh runtime skill hub announced 2026-05-21 (see user stories refresh) — both reduce the “did Claude actually use the right skill?” failure mode.

Key Takeaways

  • The problem skill bundles solve. A workflow often requires N skills in sequence (e.g., research-workflow: 4-phase pipeline across discovery / extraction / organization / analysis / output). Manually invoking each skill takes time + burns context. Stuffing the prompt with natural language risks the agent skipping skills probabilistically. Bundles make the skill set explicit per slash command.
  • YAML format under ~/.hermes/skill-bundles/. Each bundle is a small YAML file with: name (becomes the slash command), skills (array), optional description, optional instruction (“mini agents.md” — house rules / conventions / habits).
  • Slash command invocation. After bundling, /<name> loads the entire skill set for one turn. The agent runtime emits a system message: “User has invoked the X skill bundle — treat every skill below as active guidance for this turn.”
  • CLI surface. hermes bundles create <name> (interactive — pick skills), hermes bundles list (see all configured bundles), hermes bundles reload (re-read after manual edits).
  • Two ways to compose. (1) Hermes dashboard — Skills page, manually combine. (2) Conversational — ask Hermes to suggest skills for a workflow; review its plan; have it create the bundle following the official docs. Ron’s preferred path: hand Hermes the official documentation and ask it to do the right thing, instead of assuming it knows.
  • First-creation triggers folder creation. The ~/.hermes/skill-bundles/ directory is created the first time you create a bundle — it doesn’t exist after a fresh Hermes update.
  • Adaptive ordering not documented yet. Ron asks live: are skills running sequentially regardless of context, or can the agent reorder them based on the task? The documentation as of the video doesn’t explicitly say. Ron’s interim guidance: consult Hermes about the workflow first, let it design the bundle, manually review the ordering.
  • Team sharing pattern. Commit bundles to dotfiles or a shared repo. Bundles become deterministic, version-controlled workflow definitions.
  • Composable with self-improvement loop. Consult Hermes about which skills to bundle → Hermes drafts the YAML following docs → you review → ship. Ron’s research-workflow example: Hermes suggested splitting into a “general research” and a “quick research lightweight” bundle, demonstrating it inferred a useful structural decision from the brief.
  • Bundle composition is intentional, not max-fan-out. Only include skills the workflow actually needs. Use the instruction field for habits + conventions so Hermes does the right thing by default per bundle.

YAML structure

# ~/.hermes/skill-bundles/research.yaml
name: research
 
skills:
  - web-search
  - article-extraction
  - markdown-formatter
  - research-synthesizer
  - citation-checker
 
description: |
  Full research pipeline: discover sources, extract content,
  organize into structured notes, synthesize into a final brief
  with citations.
 
instruction: |
  House rules for this bundle:
  - Always cite sources inline.
  - Prefer primary sources over aggregators.
  - End every report with an "Open Questions" section.
  - Default depth = 10 sources unless asked otherwise.

Invoke with /research <task>. Hermes loads all five skills + the instruction set for the turn.

CLI

CommandPurpose
hermes bundles create <name>Interactive creation — pick skills, write description/instruction
hermes bundles listShow all configured bundles
hermes bundles reloadRe-read after manual YAML edits

Try It

  1. Identify your three most-repeated workflows. Each one that requires 3+ skills in sequence is a bundle candidate. Examples Ron walks through: research, release-prep, incident-response, backend-dev.
  2. Use the conversational on-ramp. Ask Hermes: “Suggest which skills we should bundle for [workflow].” Hand it the official Skill Bundles docs. Let it draft the YAML following the docs. Review the proposed bundle for completeness + ordering.
  3. Test against a real task. Invoke the bundle on a representative task (Ron’s example: /research find out why Hyperliquid token is pumping hard). Read the system message that lists the loaded skills. Check the output quality vs your previous one-skill-at-a-time approach.
  4. Iterate the instruction field. Treat it as a mini agents.md — accumulate your conventions over time. Reload after each edit.
  5. Commit bundles to your dotfiles or team repo. Version-controlled bundles = reproducible workflows across team members + machines.
  6. Pair bundles with Browse.sh skills for browser-heavy workflows (login flows, scraping recipes). See Hermes user stories — Browse.sh integration announced same week.

Open Questions

  • Adaptive ordering — sequential or context-aware? Ron raises this on-air. The transcript implies Hermes treats bundled skills as a single active context for the turn (system message says “treat every skill below as active guidance for this turn”), suggesting the agent picks invocation order per task. Documentation should be clearer.
  • Bundle-of-bundles? Can a bundle reference another bundle, or are bundles strictly leaf compositions of individual skills?
  • Versioning. If a skill changes upstream, do existing bundles auto-pick-up or pin to a version? hermes bundles reload re-reads YAML, but skill content is referenced by name — drift behavior is unclear.
  • Drag-and-drop bundle creation. Ron notes this is missing from the current Hermes dashboard and expects it in the next update.
  • Bundles vs Claude Code’s plugins. Claude Code skill bundles in plugins are the closest analog. Skill Bundles in Hermes are leaner (no command/agent/MCP slots, just skills + instructions). Worth a connection article on the trend.
  • Does self-generated skill creation underperform human-curated skills, per SkillsBench (arXiv:2602.12670)? (Added 2026-07-16 — see the dated signal section below for full context.) The paper’s abstract, independently fetched by this pipeline, confirms fewer/focused skills beat large bundles, but does not itself confirm the stronger “self-generated skills underperform” claim reported secondhand on r/hermesagent. A secondary web-search lead points at a self-generated-skills condition inside the full paper, but that lead came back flagged as possibly unreliable (failed source fetch) — genuinely open until someone reads the full paper directly, not just the abstract.
  • OpenSenseNova SenseNova-Skills — repo, license, and contents unverified. (Added 2026-07-17.) The MIT license, repository (github.com/OpenSenseNova/SenseNova-Skills), skill list, and SenseNova U1 infographic model all come from a single r/hermesagent Showcase post (raw/reddit-1uyp0fi.md); none were independently fetched or confirmed by this pipeline. Verify the repo exists, the license is genuinely MIT, and the skills load under a current Hermes version before recommending or bundling them.

Reddit signal — applied bundle pattern: “Teach Hermes to Drive Any Website” workshop (2026-05-25)

[Reddit signal — r/hermesagent 2026-05-25] Source: raw/reddit-1tmpq0n.md (47 score, 14 comments, OP Jonathan_Rivera, Workshop flair). Concrete applied bundle pattern: survey a website once, save what worked as a Hermes skill, invoke forever. OP’s framing: “You survey a website once, then Hermes automates it forever. Walmart checkout. DMV appointments. Facebook pages. Flight check-in. Insurance claims. Any consumer website with finite steps and clear success criteria.”

The pattern motivates skill bundles specifically by closing the agent-exploration-tax failure mode the original article doesn’t name explicitly:

“Every time I send Hermes to a site it has to explore, fail, explore some more, use this tool, whoops can’t, try this etc. and thought why don’t we just save what worked.”

That’s the recurring browser-automation pain — Hermes (or any browser-driving agent) re-discovering the same site’s affordances on every visit, burning context + retry cycles on already-solved navigation. The workshop pattern:

  1. One-shot prompt to Hermes — paste a single bundle-creation prompt. Hermes creates a builder profile, tests which browser engine actually works for the site (Browserbase / Browse.sh / Playwright / Hermes-native — site-dependent), then walks through every interaction surface — buttons, fields, dropdowns, failure modes, recovery paths.
  2. Subagent verifies the harness before the bundle ships. Truncation cuts the exact verification contract, but the shape is “second agent checks the bundle exec a representative session before storing.”
  3. The resulting skill is reusable forever — invoke the bundle on the same site for the corresponding task without re-explore.

Pair with the Browse.sh runtime skill hub referenced in the user-stories adjacency. The OP’s pattern creates the kind of artifact Browse.sh hosts — operator-authored site-specific automation skills. The skill-bundle YAML format above is the local-store version; Browse.sh is the runtime hub for sharing across operators.

Why this matters for the article. The original article framing is “skill bundles solve probabilistic-skill-invocation.” This signal adds a more specific failure mode bundles close: stateless re-exploration of consumer websites by browser-driving agents. Site automation is the load-bearing use case bundles solve — not generic multi-skill workflows.

Caveat. Single-author workshop post; OP Jonathan_Rivera is the same author behind the Qwen3.6-35B-A3B / 27B megathreads in the same subreddit (megathread-style maintenance posts, see raw/reddit-1tmp2qy.md and raw/reddit-1tn4lye.md skip-stubs). Pattern reads load-bearing; the bundle YAML / verification contract specifics need a fetch of the full body or the linked installable artifact (truncated in capture) before reproduction.

Workshop signal — Hermes Tool Router (May 2026)

[Reddit signal — r/hermesagent 2026-05-28] Source: raw/reddit-1tpvvm9.md (33 score / 24 comments, OP Jonathan_Rivera, Workshop flair, “Workshop - Hermes Tool Router: Reduce AI Agent Token Bloat”). Workshop post on router-first tool loading + memory tiering as a complement to the skill-bundle approach. The problem the post starts with: every first-turn prompt carried the full tool-schema payload — every toolset, every definition — regardless of what the operator actually asked. With dozens of skills × MCP tools × bundle definitions, that’s an arbitrarily large fixed-cost-per-turn before any real work happens. The Tool Router answer: instead of loading every toolset into the prompt on every turn, disable the heavy ones by default and replace them with a short delegation instruction in SOUL.md (~50 tokens), so a sub-agent with the full toolset still handles the actual work — the orchestrator just doesn’t carry the schema weight by default. Pairs naturally with skill bundles: bundles make the active capability set explicit per-workflow, tool-routing makes the active schema cost explicit per-turn. The post links a public reference repo (URL not extracted in this stub — see the Reddit post for the canonical link). Future article candidate if the tool router becomes an official Hermes feature.

Skill ecosystem update — creative catalog + community plugins (2026-06-07)

[X signal — @NousResearch 2026-06-06 (raw/x-account-nousresearch-2063093177582502390.md); community plugins via raw/x-bookmarks-recent-digest-2026-06-07.md] Two ecosystem developments around what you can bundle:

  • Creative skills sub-catalog. Alongside the v0.16 release, Nous spotlighted a creative skills catalog (art / media generation) with the framing “the skills are the tutorial.” Two canonical references: optional (installable) creative skills at hermes-agent.nousresearch.com/docs/reference/optional-skills-catalog#creative and bundled (ships-by-default) ones at …/skills-catalog#creative. First-party, bundle-able building blocks the article didn’t previously name.
  • Community plugin ecosystem (v0.16.0-compatible). A growing set of third-party plugins extends the core (Skills / MCP / Memory / Curator) without replacing it — notably Hermes Agent Self-Evolution (official Nous companion that auto-improves skills + prompts via DSPy + GEPA), plus hermes-plugins (goal management, inter-agent comms, cost tracking), web-search-plus, super-hermes (“Prisms” analytical frameworks), and Advanced Memory Providers (@IBuzovskyi). Self-Evolution is the direct automation of this article’s “composable with the self-improvement loop” theme — the loop you’d otherwise run by hand.

Community patches signal — Skills Index Mode + Telegram UX (2026-07-02)

[Reddit signal — r/hermesagent 2026-07-02] Source: raw/reddit-1ul4pdo.md (13 score, 5 comments, OP u/Erwan0714). A thread asking what custom patches operators reapply after every Hermes update surfaced three concrete ones. The headline is a quantified token-savings fix that targets the same fixed-prompt-tax problem as the Tool Router workshop signal above, but aimed at the <available_skills> block specifically rather than tool schemas.

  • Skills Index Mode (headline finding). The default <available_skills> system-prompt block was ~3,500 tokens of mostly-irrelevant skill descriptions loaded on every turn. The patch replaces it with a curated intent→skill keyword index at ~1,650 tokens — a reported ~1,850-token-per-session saving — with an automatic fallback to the original full block if the index misses a match. Same failure mode as the Tool Router signal above (fixed-cost prompt bloat from loading everything regardless of task), but patched at the skill-description layer instead of the tool-schema layer — complementary cost levers, not overlapping ones.
  • Approval Request UX rework (Telegram), shorter mention. The stock shell-command approval prompt is a wall of text; the patch swaps it for a one-line summary + collapsible code block + a button row (Once / Session / View Code (Hide Code) / Always / Deny). Reported as less jarring mid-task and less likely to fat-finger “Always” — a UX layer over the same approval flow that the security model’s manual/smart/off modes gate.
  • Gateway Online Ping (Telegram), shorter mention. A systemd drop-in pings Telegram with “Gateway online” when the gateway restarts, with a 1-minute cooldown so a restart loop doesn’t spam the channel. Lives entirely in ~/.hermes/ as a script + service drop-in, so it survives hermes update.

All three ship with check/apply/rollback scripts plus an auto reapply.sh triggered after hermes update — the same dotfiles-style, version-controlled operational discipline this article already recommends for bundles themselves (see “Team sharing pattern” above). ^[single-operator patch set; low reply count (5 comments) — no independent reproduction of the ~1,850-token figure]

Reddit signal — SkillsBench paper questions self-generated skills (2026-07-16)

[Reddit signal — r/hermesagent 2026-07-16] Source: raw/reddit-1uxx6b8.md (38 score, 15 comments, OP u/Enashka_Fr, “Discussion” flair). A thread links a paper — arXiv:2602.12670, “SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks” — reportedly finding that self-generated agent skills underperform, and that fewer/focused skills beat larger skill libraries. OP’s question to the community: how does this square with Hermes, which relies on a large collection of self-creating skills?

Verification status: partially confirmed, partially unverified. This pipeline independently fetched the paper’s abstract directly from arxiv.org/abs/2602.12670 before citing it, per this vault’s rule against citing unverified arXiv claims as fact:

  • Confirmed by the fetched abstract. The paper is real (77 authors led by Xiangyi Li, including Dawn Song), evaluates 87 tasks across 8 domains under matched no-Skills/curated-Skills conditions across 18 model-harness configurations, and states that curated Skills raise the average pass rate from 33.9% to 50.5% (+16.6pp). Directly relevant to this article’s own guidance above (“Bundle composition is intentional, not max-fan-out” in Key Takeaways): the abstract states “Focused Skills with at most three modules outperform larger or exhaustive bundles,” and that smaller models paired with Skills can match larger models without them.
  • Not confirmed by the abstract alone. The Reddit headline’s more specific claim — that self-generated (agent-authored) skills underperform — is not stated in the abstract text as fetched. The abstract’s comparison is “curated Skills” vs. “no-Skills,” not an explicit self-generated-vs-human-curated arm. ^[ambiguous — a follow-up X search surfaced a secondary summary (attributed to a thread by @aparnadhinak) claiming the full paper does include a self-generated-skills condition that landed roughly 1.3pp below the no-skill baseline. That search result came back from the tool with an explicit warning that a required source-thread fetch had failed and the summary might be a reconstruction rather than a verbatim read, so it is not treated as confirmed here — flagged only as a lead for a future, directly-verified follow-up.]

Bottom line for Hermes-relevance. The part of the paper this pipeline could directly verify — fewer, focused skills beat large/exhaustive bundles — corroborates this article’s existing bundle-design guidance (scoped instruction fields, “only include skills the workflow actually needs”). The more provocative claim in the Reddit post’s title — that self-generated skill creation specifically underperforms, which would bear directly on Hermes’s self-creating-skills architecture — is plausible given the paper’s general framing but not independently confirmed by this pipeline from the abstract alone, and should not be treated as settled. See Open Questions.

Community skill pack signal — OpenSenseNova office skills (2026-07-17)

[Reddit signal — r/hermesagent 2026-07-17] Source: raw/reddit-1uyp0fi.md (30 score, 5 comments, OP u/SamuelT6, Showcase flair). A community post announces OpenSenseNova’s “SenseNova-Skills”, reported as an MIT-licensed office skill pack for Hermes (repo: github.com/OpenSenseNova/SenseNova-Skills).^[repo, license, and contents are community-reported from a single Showcase post — not independently verified by this pipeline; see Open Questions] The pack reportedly covers Excel / multi-file data analysis, deep research with citations plus intermediate evidence files, PowerPoint generation, infographic + image generation, and academic / developer / financial / social search. Its distinctive claim is skill chaining: one bundled example takes a raw memory-price CSV through raw data → analysis → sourced research → report → PPT (ending in a 16-slide deck) rather than one-shot “make a presentation” prompting — the same intentional-composition thesis this article argues for bundles (see “Bundle composition is intentional, not max-fan-out” above). The poster also references an open-source visual-generation model (SenseNova U1) for turning analyzed data into infographics, plus a free token plan. On-topic as a set of bundle-able building blocks, but treat as an unvetted community release — not a Nous-shipped or wiki-verified pack — until the repo and license are independently confirmed.

Graph View

Backlinks