Source: Hermes Agent NEW Skill Bundles Setup Guide (YouTube _A02brv2Csg), Ron, 2026-05-21. Hermes Agent feature shipped by Nous Research. Later signal sections cite their own raw/ sources inline; the SkillsBench figures are checked against ai-research/skillsbench-arxiv-2602-12670-2026-09-29.md (arXiv:2602.12670 abstract page, v4, fetched 2026-09-29).
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), optionaldescription, optionalinstruction(“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
instructionfield for habits + conventions so Hermes does the right thing by default per bundle.
YAML structure
Illustrative example, not a copy of an on-screen file. The video never shows a YAML body. It names one skill set in prose — Ron’s backend-dev example: “GitHub code review, test-driven development, GitHub PR workflow” — and lists the fields: name and skills (the core), plus optional description and instruction. The block below is rebuilt from that example; the file name, skill slugs and field text are placeholders.
# ~/.hermes/skill-bundles/backend-dev.yaml (illustrative)
name: backend-dev # becomes the /backend-dev slash command
skills:
- github-code-review
- test-driven-development
- github-pr-workflow
description: | # optional
Backend development workflow: code review, test-driven changes, PR.
instruction: | # optional: "a mini agents.md" of house rules
<your house rules and conventions for this workflow>Invoke with /backend-dev <task>. Hermes loads the bundled skills plus the instruction for the turn. Ron’s on-screen demo used a research bundle that Hermes generated (invoked as /research find out why Hyperliquid token is pumping hard); the video confirms it had name, skills, description and instruction fields but does not show its skill list.
CLI
| Command | Purpose |
|---|---|
hermes bundles create <name> | Interactive creation — pick skills, write description/instruction |
hermes bundles list | Show all configured bundles |
hermes bundles reload | Re-read after manual YAML edits |
Try It
- Identify your three most-repeated workflows. Each one that requires 3+ skills in sequence is a bundle candidate. Examples Ron walks through: research and backend-dev.
- Use the conversational on-ramp. Ask Hermes: “Suggest which skills we should bundle for [workflow].” Hand it the official Skill Bundles docs (Ron feeds them to Hermes on screen; the transcript gives no URL). Let it draft the YAML following the docs. Review the proposed bundle for completeness + ordering.
- 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. - Iterate the
instructionfield. Treat it as a mini agents.md — accumulate your conventions over time. Reload after each edit. - Commit bundles to your dotfiles or team repo. Version-controlled bundles = reproducible workflows across team members + machines.
- 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 reloadre-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 — site-harness skill 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). A site-harness skill pattern that a bundle could include: survey a website once, save what worked as a Hermes skill, replay it. The post never mentions skill bundles; its output is one harness skill per site. 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.”
It is relevant here because it closes an agent-exploration-tax failure mode the original article doesn’t name:
“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:
- One setup prompt to Hermes — paste a single prompt. Hermes creates a
harness-builderprofile (smartest available model, a “surveying, not executing” system prompt, dummy data only), loads the harness-authoring skill, then tests which browser engine actually works for the site, lightest lane first and escalating only if something breaks: real Chrome over CDP (port 9222), Playwright Chromium (the default, but silently rejected by some React-heavy sites), Camoufox and nodriver (stealth options for bot checks), and computer use via cua-driver (macOS-only last resort). It then walks through every step, documenting buttons, fields, dropdowns, failure modes, and recovery paths, and writes a harness file at~/.hermes/skills/consumer-web/[sitename]/SKILL.md. - A subagent verifies the harness (mandatory). The post’s verification prompt, given to the builder after the survey: “Spawn a subagent to replay every step of this harness using dummy data. Report every failure with step number and what went wrong. Never submit real data or create real accounts. Respond with PASS or FAIL: [list of failures].” On FAIL the builder patches the broken steps and re-verifies; on PASS the harness is marked tested.
- An executor replays it. A separate
harness-executorprofile on a cheap model follows the harness mechanically, stopping only at steps marked as decision points; harnesses can also run on cron. The post’s own limits: harnesses expire after 30 days (selector rot), and a CAPTCHA wall or aggressive anti-bot measures can make a site unharnessable.
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.^[inferred] The harness is an ordinary skill (SKILL.md), not a bundle YAML; a browser-heavy bundle could list one or more site harnesses alongside other skills.
Why this matters for the article. The original article framing is “skill bundles solve probabilistic-skill-invocation.” This post addresses an adjacent failure mode — stateless re-exploration of consumer websites by browser-driving agents — and solves it with a saved skill, not a bundle. Bundles are one way to load such a skill together with the others a workflow needs.
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). The captured post is complete through its Limitations and Community sections, including the setup prompt, the verification prompt and a harness-file skeleton. It does not say where the harness-authoring skill it loads comes from, so reproducing the survey needs that skill.
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, so typing “hi” cost the same as a multi-step agentic task. On the OP’s setup that floor was 14,200 tokens, 65% of it tool schemas. The Tool Router makes two lightweight decisions before the main model sees the message, plus a safety net:
- Router classifier. A small, cheap model (~1.5s) reads the user message and predicts which toolsets the turn needs; Hermes assembles only those schemas. If the classifier is unsure, or the message is long and complex, it declines reduction and loads the full surface — worst case is no savings, not a broken response.
- Memory tiers. The same analysis sets injection depth once per session, from the first message: none (~4,100 tokens; trivial openers), compact (~5k–9.6k; injects the
USER.mdprofile and a lightweight web-search hint), or full (~11,100; full memory store plus profile, for “last session” / “remember” style recall). - Recall-on-miss. If the router mispredicts and the model calls a tool that wasn’t loaded, Hermes detects the invalid tool name, injects the missing toolset and retries — one extra API call, not a failed turn.
Reported numbers (live provider meter on the OP’s setup; “your numbers will vary based on Hermes version, enabled toolsets, and profile size”): a trivial opener fell from 14,200 to 4,136 tokens; a normal task with a full profile came to 9,595, where the USER.md profile (44%) becomes the dominant cost once tools are trimmed. Quality check after the change: 13 prompts, 11/13 pass, 2/13 partial, 0 failures — one partial was an ambiguous cold-start “save this as a skill”, the other a pre-existing kanban issue unrelated to routing. The floor toolset list is configurable (router_config: confidence_threshold, long_message_decline_chars, floor_toolsets), the classifier works with any OpenAI-compatible endpoint (the OP reports qwen2.5:7b via Ollama works locally), and install is manual for now. Pairs naturally with skill bundles: bundles make the active capability set explicit per-workflow, tool-routing makes the active schema cost explicit per-turn. Repo: github.com/AtlasOmnia/hermes-tool-router. 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#creativeand 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 surviveshermes 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. No copy was kept at the time; the abstract page (v4, revised 14 Jun 2026) was re-fetched and saved on 2026-09-29 as ai-research/skillsbench-arxiv-2602-12670-2026-09-29.md, and every figure below was re-checked against it:
- Confirmed by the fetched abstract. The paper is real (led by Xiangyi Li, with Dawn Song as last author; the page lists 78 author names, while its own link text says “Xiangyi Li and 76 other authors”, i.e. 77^[ambiguous]), 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; a 25.5% normalized gain, with configuration-level gains from +4.1 to +25.7pp). 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.
Community plugin signal — Forage, a purpose-built Firecrawl replacement (2026-08-06)
[Reddit signal — r/hermesagent 2026-08-06] Source: raw/reddit-1vhh2p9.md (41 score, 26 comments, OP u/elzerouno, Showcase flair). A community-built web search + extract backend shipping its own Hermes plugin — relevant here as an example of the plugin surface being used to swap out a core capability provider rather than to add a feature.
The motivating number: self-hosted Firecrawl was consuming ~2.5GB of RAM idle for what the operator only needed as web scraping. Forage claims ~526MB idle (up to ~1.5GB with the browser pool maxed), single container, no Redis, no extra services.
Reported design, which is the transferable part:
- Static fetch first (httpx + trafilatura), escalating to a Playwright browser only when the page actually needs one — the reason the idle footprint is low.
- Configurable per-domain rewrites — ships rewriting
reddit.com/r/...toold.reddit.com, yielding full threads without a browser. - SPA detection plus stealth so YouTube, Instagram and X render; Cloudflare challenges are detected and reported rather than silently returning empty content.
- Native PDF and office file extraction; parallel multi-URL extraction; search via self-hosted SearXNG with caching.
- A custom agent tool to request full page text on demand when default extraction misses comments or forums.
- Reported latency: Wikipedia under a second, x.com ~7 seconds. Claims 82 of the 100 most visited domains end to end, “including ones the self-hosted Firecrawl fetch engine could not touch.”
Integration is plugin-shaped: point web.search_backend and web.extract_backend at it. Repo: github.com/aldemaroc/forage (GPL v3). The author notes the Hermes plugin and GitHub documentation were written by their own Hermes agent, with the human reviewing and directing.
Caveats the author states plainly: it is still in testing, and was benchmarked on a home connection. The Cloudflare-detection and stealth features put it in the same authorization grey zone that the TOS ceiling on agent commerce describes — stealth rendering exists because sites are trying to prevent exactly this. Unvetted community release; license and repo were read from the post, not independently confirmed.
Related
- Hermes Agent
- Hermes User Stories — adjacent Browse.sh runtime skill hub announcement same week
- Hermes v0.14.0 Foundation Release — release context
- Nate Herk Hermes Agent 1-Hour Course
- Skills vs Projects (Claude analog) — the trend toward bundling skills behind one entry point
- Cowork Plugins — Claude analog (skill + connector + sub-agent bundles)