A source-grounded review of Hermes Agent's AI Skills feature and what Right Agent should adopt, reject, or modify while preserving bot-first management, sandbox-first security, OpenClaw/ClawHub compatibility, upgrade-friendly deployment, and Right Agent MCP naming rules.
The most important point is autonomous skill creation. Hermes Agent treats skills as procedural memory: when it solves a non-trivial workflow, recovers from dead ends, receives a user correction, or completes a complex task, it can preserve the working method as a reusable SKILL.md package through skill_manage Hermes Agent-managed skills. That is the learning loop: the agent does work, extracts the reusable procedure, stores it as a skill, loads it only when relevant, and later patches or archives it as experience accumulates.
The file format and hub ecosystem matter, but they are secondary. Hermes' differentiator is that skills are not only user-installed packages; they are the agent's way to convert execution history into future capability. Hermes' docs describe skills as token-efficient documents compatible with the agentskills.io open standard and loaded through progressive disclosure rather than injected wholesale into every prompt Hermes Skills System. Its docs home and homepage explicitly market persistent memory plus auto-generated skills as the mechanism by which Hermes "grows" over time Hermes docs home Hermes homepage.
Right Agent already has part of this model: bundled Claude Code skills are embedded by right-codegen, installed into each agent's .claude/skills/, and its rightskills skill points at skills.sh while preserving a per-agent installed.json. However, Right Agent does not yet have the core loop: agent notices "I learned a reusable procedure" - proposes a skill - user approves - platform installs it safely - future sessions load it when relevant.
mcp__right__skill_propose draft path and a bot-facing approval flow. Do not port Hermes' unrestricted skill_manage mutation model unchanged.
Confirmed: Hermes skills are on-demand knowledge documents stored as directories containing a required SKILL.md and optional supporting files. The official Skills System page defines them as documents the agent loads when needed, using progressive disclosure to minimize token usage and staying compatible with the agentskills.io standard Skills System.
A skill is closer to a reusable operating procedure than to a native tool. Hermes' Creating Skills guide says skills are appropriate when a capability can be expressed as instructions, shell commands, and existing tools; it recommends native tools when precise API integration, auth flows, streaming, or binary handling must be built into the agent Creating Skills.
Confirmed: Hermes can create and revise these skills itself. The Skills System page says the agent can create, patch, edit, delete, and add supporting files through skill_manage, turning successful workflows into future procedural memory Agent-managed skills. The prompt builder reinforces that behavior by telling the model to save non-trivial workflows as skills and patch stale skills during use prompt_builder.py.
Once Hermes discovers a workflow, it can encode the procedure as a skill instead of forcing the user to teach the same process again. Hermes' docs frame skills as procedural knowledge, distinct from factual memory Working with Skills.
Hermes can offer to save the approach after complex multi-step work, so the agent's capability library grows from its own successful traces instead of only from preinstalled packages Working with Skills.
The agent starts with a compact index and loads full instructions or references only when needed. Hermes documents a three-level pattern: list metadata, view one skill, then view a specific supporting file Progressive Disclosure.
Skill packages can be shared through bundled skills, official optional skills, skills.sh, GitHub taps, well-known endpoints, direct URLs, ClawHub, Claude marketplace-style repos, and LobeHub conversions Skills Hub.
Installed skills become slash commands in CLI and messaging surfaces, and can also be loaded by natural conversation via skill_view Working with Skills.
~/.hermes/skills/ plus configured read-only external directories. Local skills take precedence when names collide, and external skills appear in the prompt index, skills_list, skill_view, and slash commands External Skill Directories.skills_list() for metadata. Hermes' prompt builder has a build_skills_system_prompt path with in-process and disk snapshot caching for skill metadata prompt_builder.py.SKILL.md using skill_view(name), then optionally loads a supporting file with skill_view(name, path) Skills System.skill_manage to create, patch, edit, delete, or add/remove supporting files. Hermes explicitly prefers patching for updates because it is more token-efficient than full rewrites Agent-managed skills.
Hermes' tool is named skill_manage (singular). It is the agent-facing write API for procedural memory, not the learning algorithm by itself. The tool executes validated filesystem mutations; the decision to call it comes from Hermes' system prompt, the tool schema guidance, explicit user requests, and background review flows skill_manager_tool.py prompt_builder.py.
| Question | Hermes Behavior | Source-Backed Detail |
|---|---|---|
| How does it write skills? | skill_manage dispatches actions: create, patch, edit, delete, write_file, and remove_file. |
create writes a full SKILL.md under ~/.hermes/skills/, optionally inside a category. patch applies targeted fuzzy find-and-replace. edit replaces the whole SKILL.md. Supporting files are restricted to references/, templates/, scripts/, and assets/ tool source. |
| How does it learn new skills? | The model distills a successful or corrected execution trace into a reusable SKILL.md and calls skill_manage(action="create"). |
Hermes prompt guidance tells the model to save procedures when it discovers a reusable way to do something, and separately says procedures belong in skills rather than memory prompt_builder.py. The tool schema says good skills include trigger conditions, exact numbered steps, pitfalls, and verification steps tool source. |
| What triggers creation? | Creation is triggered by model judgment, not by a hard-coded classifier in skill_manage. |
The documented triggers are complex successful tasks, especially 5+ tool calls; recovered errors or dead ends; user-corrected approaches that worked; discovered non-trivial workflows; and explicit user requests to remember a procedure. The schema also says to offer to save after difficult or iterative tasks, skip simple one-offs, and confirm with the user before creating Skills System tool source. |
| When does it adjust a skill? | It patches immediately when active use proves the skill is stale, incomplete, OS-specific, or wrong. | The prompt builder instructs the model to patch an outdated, incomplete, or wrong skill during use instead of waiting. The schema lists update triggers: stale or wrong instructions, OS-specific failures, and missing steps or pitfalls. patch is preferred over edit because it sends only the changed text and preserves structure when possible prompt_builder.py Agent-managed skills. |
| When does it delete? | Deletion is for pruning or consolidation, and should be user-confirmed. | delete removes the skill directory. The absorbed_into parameter records whether the deleted skill was merged into an umbrella skill or was truly pruned with no forwarding target. If absorbed_into names a target, that target must already exist. The schema says to confirm before deleting tool source. |
| What does the curator decide? | The curator handles library hygiene rather than immediate learning. | It runs after enough time and idle time have passed, marks unused skills stale after 30 days, archives after 90 days, and runs an auxiliary-model review that may keep, patch through skill_manage, consolidate, or archive. Hermes describes archive as recoverable and says the curator does not auto-delete Curator docs. |
An umbrella skill is not a special Hermes object type. It is a normal, broader skill that absorbs the useful parts of one or more narrower skills before those narrower skills are removed. Example: separate skills for "debug GitHub Actions cache misses", "debug GitHub Actions matrix failures", and "debug GitHub Actions permissions" might be consolidated into a broader github-actions-debugging umbrella skill with sections for each failure class.
In skill_manage, the concept appears through the absorbed_into parameter on delete. The agent or curator should first patch or create the umbrella skill so the useful procedure is preserved, then delete the narrower skill with absorbed_into="umbrella-skill-name". The tool validates that the named umbrella skill already exists, which prevents a false claim that content was merged somewhere nonexistent skill_manager_tool.py.
SKILL.md or patch the existing skill that was stale, wrong, or incomplete.
skill_manage(action="delete", name="narrow-skill", absorbed_into="umbrella-skill").
absorbed_into="" after confirmation so downstream tooling knows this was not a merge.
skill_manage, consolidate into an umbrella, or archive.
The current implementation also validates names, YAML frontmatter, content size, and path traversal; writes atomically; clears the skill prompt cache on successful mutation; and can optionally run a security scan when skills.guard_agent_created is enabled. That guard is off by default in Hermes because the docs/code consider it too noisy for normal agent workflows Configuration skill_manager_tool.py.
skill_manager_tool.py currently guards deletion and allows patches/edits on pinned skills. Right Agent should not inherit that ambiguity; pinned or approved skills should have explicit, bot-enforced mutation policy.
Hermes uses YAML frontmatter with name, description, optional version, author, license, platforms, and Hermes metadata such as tags, category, related skills, required or fallback toolsets, and config keys SKILL.md Format. Hermes AGENTS.md adds reviewer rules: short descriptions, modern section order, scripts under scripts/, references under references/, templates under templates/, and tests for new skills Hermes AGENTS.md.
Confirmed: Hermes exposes skills through skills_list, skill_view, and slash commands. The loading model is progressive: metadata first, full skill content second, individual support file third Working with Skills. Code corroborates this split in tools/skills_tool.py and the prompt index builder in agent/prompt_builder.py.
Inference from docs: a skill does not grant a new capability by itself. It instructs the model how to use existing toolsets, shell commands, scripts, references, or APIs. If a required toolset is not enabled, the skill can be hidden with requires_toolsets; if a primary tool is present, a fallback skill can be hidden with fallback_for_toolsets or fallback_for_tools Conditional Activation.
Confirmed: Hermes' docs describe skill_manage as the mechanism for the agent to create, update, and delete its own skills, and list the events that should trigger creation: complex success, errors that led to a working path, user correction, or discovery of a non-trivial workflow Agent-managed skills. The practical loop is: observe a successful trace, distill it into SKILL.md, include supporting files when the procedure needs references or scripts, make the skill available by name in future sessions, and patch it when later runs expose drift.
This is stronger than a marketplace feature. A marketplace imports someone else's procedures; auto-creation turns the agent's own local experience into procedures tailored to the user's environment. That is why Right Agent should implement draft skill creation early, even if broad hub support comes later.
Hermes' local single source of truth is ~/.hermes/skills/. The docs show local category directories, .hub/lock.json, .hub/quarantine/, .hub/audit.log, and .bundled_manifest under that tree Skill Directory Structure. Taps are stored separately at ~/.hermes/.hub/taps.json, and bundled skill syncs use .bundled_manifest hashes to avoid overwriting user-modified copies Bundled skill updates.
Users manage skills via CLI commands such as hermes skills list, browse, search, inspect, install, check, update, audit, uninstall, reset, publish, and tap add. The same command family is available as /skills slash commands inside chat sessions Skills Hub commands. Per-platform enablement can also be managed with the interactive hermes skills TUI Per-platform skill management.
Hermes has several safety layers around skills, but they are not equivalent to a per-skill sandbox capability model. Toolsets decide which native tools are available for a session or platform, and conditional skill metadata controls whether a skill appears when required tools are present or absent Toolsets Reference Conditional Activation.
| Area | Hermes Behavior | Security Implication |
|---|---|---|
| Secrets | Skills can declare required environment variables. Hermes asks for missing values only when the skill loads in the local CLI; messaging surfaces tell users to configure locally instead of sending secrets in chat Secure Setup on Load. | Good pattern for Right Agent: credential entry must stay outside the sandbox and outside chat transcripts. |
| Hub installs | Hub-installed skills are scanned for exfiltration, prompt injection, destructive commands, supply-chain signals, and related threats. --force can override non-dangerous findings but not dangerous verdicts Security scanning and force. |
Good scanner/provenance idea, but Right Agent should require explicit bot-side confirmation for overrides. |
| External dirs | External skill directories are read-only for discovery. Agent-created and edited skills write to the local skills tree External Skill Directories. | Matches Right Agent's need to preserve compatibility without letting shared registries become mutable by the agent. |
| Curator | The curator archives instead of deleting, creates backups, respects pins, and excludes bundled/hub-installed skills from telemetry writes Curator. | Useful but should be report-only or opt-in in Right Agent until provenance is strong. |
| Dimension | Hermes | Right Agent Current State | Implication |
|---|---|---|---|
| Runtime model | Hermes is a Python agent with native toolsets and multiple terminal backends; its docs describe local, Docker, SSH, Singularity, Modal, Daytona, and similar execution backends Hermes docs home. | Right Agent is Rust 2024, orchestrates Claude Code through process-compose, and defaults to OpenShell sandboxes with host-held credentials AGENTS.md ARCHITECTURE.md. | Right Agent cannot copy Hermes' local filesystem mutation model directly; host/sandbox ownership matters. |
| Prompt integration | Hermes builds a compact skill index and loads individual skills with skill_view prompt_builder.py. |
Right Agent assembles one composite system prompt via --system-prompt-file; it uses compiled-in templates, agent-owned files, and platform-managed generated files PROMPT_SYSTEM.md. |
A native Right skill index should preserve prompt caching and avoid per-message filesystem scanning. |
| Skill storage | ~/.hermes/skills/ is the local source of truth, with hub metadata and bundled manifests under that tree Skill Directory Structure. |
Right Agent installs bundled skills into per-agent .claude/skills/. skills.rs embeds rightskills, rightcron, rightmcp, rightmemory, and rightreflect; right-platform-store deploys a platform-managed subset into OpenShell sandboxes. |
Right should retain per-agent isolation and add provenance metadata rather than a global mutable shared tree. |
| Management UX | Users have CLI and slash-command /skills management, plus agent-side skill_manage mutation Skills Hub commands. |
Right Agent has Telegram-first management for operational concerns such as MCP, model, and debug. Project rules explicitly say MCP config must go through the bot and that agents cannot register external MCP servers AGENTS.md ARCHITECTURE.md. | Skill install/remove/update should be bot-owned, not performed by arbitrary agent shell commands inside the sandbox. |
| Self-improvement loop | Hermes lets the agent create or patch procedural memory through skill_manage after complex successes, corrections, and recovered failures Agent-managed skills. |
Right Agent has memory and bundled skills, but no platform-owned path for an agent to propose a new reusable skill after a successful task. rightmemory explicitly says reusable procedures should become skills, but there is no safe proposal/approval flow yet. | This is the biggest Hermes idea to adapt: preserve the learning loop, but put approval and installation under the bot. |
| MCP and tool naming | Hermes uses native tool names such as skills_list, skill_view, and skill_manage Toolsets Reference. |
Right Agent uses Claude Code MCP naming with mcp__right__<tool> in agent-facing text; docs require that full prefix in skills, templates, prompts, and codegen AGENTS.md. |
Any Right Agent skill-management MCP tools must be documented as mcp__right__skill_list, mcp__right__skill_view, etc., not Hermes-style bare names. |
| Security default | Hermes supports sandbox backends and scans hub installs, but agent-managed skills can write to the local skills tree Agent-managed skills. | Right Agent's security model is OpenShell-first, credentials stay on the host, the agent runs Claude Code with --dangerously-skip-permissions, and OpenShell policy is the security layer Security Model. |
Right Agent should treat skill packages as policy-relevant content, especially when scripts or network requirements are declared. |
rightmemory and rightreflect, and local docs reference them, but the current platform-store manifest enumerates only rightskills, rightcron, and rightmcp for sandbox deployment. Before adding a broader skill lifecycle, align the installer, manifest, and prompt docs.
SKILL.md or supporting files only when needed. This maps cleanly to Right Agent's prompt-cache sensitivity documented in PROMPT_SYSTEM.md.SKILL.md packages. Right Agent already promises drop-in OpenClaw/ClawHub file compatibility AGENTS.md.skill_manage delete/edit power over installed skills. That conflicts with Right Agent's bot-first management and sandbox-first posture.--force equivalent for dangerous scanner results. Community skill overrides should be explicit, audited, and user-confirmed./skills in Telegram, backed by host-side internal APIs, rather than relying on the agent to run npx skills inside its sandbox.mcp__right__skill_propose that stores a draft and asks the user to approve through Telegram before installation. This preserves the Hermes learning loop without silently mutating the runtime./sandbox/.platform/ and symlink into /sandbox/.claude/skills/, matching Right Agent's existing upgrade model Upgrade & Migration Model.mcp__right__skill_propose first. Let the agent submit a draft SKILL.md plus optional supporting files after a complex task, recovered failure, user correction, or discovered repeatable workflow. Store the draft outside the active skill tree..mcp.json./skills commands. Start with /skills list, drafts, show, approve, reject, and disable. Marketplace commands such as search, install, update, and audit can follow after the auto-creation loop works.mcp__right__skill_list and mcp__right__skill_view, and update with_instructions(), templates, skills, and PROMPT_SYSTEM.md with full mcp__right__ names./skills doctor or /skills curator report. Only after reliable backups and pins exist should Right Agent archive stale agent-created skills..claude/skills activation entirely, or add its own MCP-backed skill_view layer for more deterministic progressive disclosure?.claude/skills/installed.json, or both for compatibility?agent.yaml fields./skills drafts?