# Hermes AI Skills Research for Right Agent

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.

Prepared: 2026-05-14 Focus: Hermes Agent AI Skills Deliverable: self-contained HTML

## Executive Summary

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.

Recommendation: prioritize a safe auto-creation loop before broad marketplace support. Add an agent-facing `mcp__right__skill_propose` draft path and a bot-facing approval flow. Do not port Hermes' unrestricted `skill_manage` mutation model unchanged.

## Source Notes

- Primary Hermes sources: the current public Hermes docs, NousResearch GitHub repository files, and Hermes' own AGENTS.md. The docs were crawled within the last week by the search index and the official docs footer identifies the project as MIT licensed in 2026 Hermes docs home.
- Authoritative support: the Hermes homepage states the product includes persistent memory and auto-generated skills, and the docs home describes a closed learning loop with autonomous skill creation and self-improvement Hermes homepage Hermes docs home.
- Code-level checks: Hermes' tools/skills_tool.py, tools/skill_manager_tool.py, and agent/prompt_builder.py were used to verify that the docs map to real modules.
- Right Agent sources: recommendations below are grounded in AGENTS.md, AGENTS.rust.md, ARCHITECTURE.md, PROMPT_SYSTEM.md, the docs under docs/architecture/, bundled skills under crates/right-codegen/skills/, templates under templates/right/, and Right Agent code under crates/.
- Gaps: Hermes documents the behavior and the relevant code modules exist, but this research did not run Hermes locally or trace every slash-command dispatch path. Where runtime behavior is inferred from docs plus file names, it is labeled as inference.
- Conflict note: Hermes docs say the curator only reviews agent-authored skills, while the same page's "What agent-created means" section defines the mutable bucket as anything not present in bundled or hub provenance manifests, including hand-written local skills and external skill directories Curator docs. That is not a direct contradiction, but it is a safety footgun: "agent-created" is provenance-by-exclusion, not proof of authorship.

## What Hermes AI Skills Are

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.

The point of auto-creation: memory remembers facts; skills remember methods. Auto-created skills are how Hermes turns a one-off success into a reusable operating procedure, including commands tried, pitfalls hit, verification steps, and when to use the workflow again.

## User Value

### Less Repeated Steering

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.

### Self-Improving Agent

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.

### Lower Token Cost

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.

### Portable Capability Packages

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.

### Natural UX

Installed skills become slash commands in CLI and messaging surfaces, and can also be loaded by natural conversation via `skill_view` Working with Skills.

## How It Works

1. Discovery: Hermes scans `~/.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.
2. Indexing: The agent receives a compact skill index and can use `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.
3. Loading: The agent loads one skill's full `SKILL.md` using `skill_view(name)`, then optionally loads a supporting file with `skill_view(name, path)` Skills System.
4. Execution: Confirmed docs describe skills as instructions plus supporting files, not as a separate executor. Inference: the actual action happens through the ordinary Hermes tools enabled for the session, such as terminal, file, browser, web, or MCP toolsets Toolsets Reference.
5. Auto-creation trigger: Hermes documents four creation moments: successful complex tasks, dead ends followed by a working path, user corrections, and discovered non-trivial workflows When the Agent Creates Skills.
6. Mutation: The agent can call `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.
7. Maintenance: The curator tracks use, view, and patch counts, transitions idle agent-created skills from active to stale to archived, and can run an auxiliary model review. It archives rather than deletes, supports pinning, and writes reports and backups Curator.

## skill_manage Deep Dive

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.

### What Is an Umbrella Skill?

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_manage Flow Diagrams

#### Foreground Learning: Create or Patch

Experience Complex success, recovered failure, user correction, non-trivial workflow, or user asks to remember.
then
Model Judgment Is this repeatable and valuable enough to preserve?
if yes
skill_manage Create a new `SKILL.md` or patch the existing skill that was stale, wrong, or incomplete.
then
Reusable Skill Future sessions see the skill in the index and load full instructions only when relevant.

#### Delete and Umbrella Consolidation

Candidate Skill Skill is duplicate, too narrow, stale beyond repair, or better represented inside a broader workflow.
if useful content remains
Patch Umbrella First Add the useful procedure, pitfalls, or verification steps to an existing broader skill, or create that broader skill first.
then
Delete with Intent Call `skill_manage(action="delete", name="narrow-skill", absorbed_into="umbrella-skill")`.
or, if no useful content remains
Prune Explicitly Call delete with `absorbed_into=""` after confirmation so downstream tooling knows this was not a merge.

#### Curator Maintenance Loop

Idle Check Enough time passed and agent has been idle long enough.
then
Telemetry Pass View/use/patch counts and last activity determine stale or archive candidates.
then
LLM Review Keep, patch with `skill_manage`, consolidate into an umbrella, or archive.
then
Recoverable State Skills are patched or archived with reports/backups; Hermes says curator archival is recoverable.

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.

Porting warning: there is a pin-scope mismatch between Hermes documentation and current tool code. The curator docs describe pins as a broader fence, while `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.

## Architecture

### Skill Format

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.

### Discovery and Loading Flow

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.

### Execution Model

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.

### Autonomous Creation Loop

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.

### Storage and Registry Model

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.

### User-Facing Management UX

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.

## Security and Permission Model

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.

Security inference: Hermes' conditional activation hides irrelevant skills from the prompt, but it should not be treated as hard authorization. A skill that instructs shell use is bounded by whatever terminal/file/network sandbox the session already has.

## Comparison With Right Agent

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.

Local drift to audit: Right Agent's installer includes `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.

## Applicability to Right Agent

### Adopt

- Progressive disclosure: keep a compact installed-skill index and load full `SKILL.md` or supporting files only when needed. This maps cleanly to Right Agent's prompt-cache sensitivity documented in PROMPT_SYSTEM.md.
- Provenance and hashes: track source, install identifier, trust level, content hash, install time, and update hash for each non-bundled skill, following Hermes' lock/update model Update lifecycle.
- Multi-source compatibility: support OpenClaw/ClawHub and agentskills-compatible `SKILL.md` packages. Right Agent already promises drop-in OpenClaw/ClawHub file compatibility AGENTS.md.
- Read-only external dirs: allow configured shared directories to appear in discovery while keeping writes local and platform-managed, matching Hermes' external-dir precedence model External Skill Directories.
- Curator concepts: use usage telemetry, stale reports, pins, archives, and backups, but start as report-only until Right Agent has strong provenance and approval flows.
- Auto-created skill drafts: let agents draft reusable procedures when a task reveals a repeatable workflow. The draft should include trigger conditions, exact steps, pitfalls, verification, and any proposed supporting files, mirroring Hermes' skill-as-procedural-memory model Agent-managed skills.

### Reject

- Unapproved agent mutation: do not give the agent a direct equivalent of Hermes' full `skill_manage` delete/edit power over installed skills. That conflicts with Right Agent's bot-first management and sandbox-first posture.
- Chat secret capture: do not ask for API keys in Telegram chat. Hermes also avoids secret prompts on messaging surfaces Secure Setup on Load; Right should keep credential collection in bot-managed flows.
- Automatic policy widening: do not let a skill install expand OpenShell network or filesystem policy. Existing rightskills already says not to auto-expand sandbox config; a native implementation should enforce that in code.
- Dangerous override from chat: do not expose a casual `--force` equivalent for dangerous scanner results. Community skill overrides should be explicit, audited, and user-confirmed.

### Modify

- Bot-first management: implement `/skills` in Telegram, backed by host-side internal APIs, rather than relying on the agent to run `npx skills` inside its sandbox.
- Agent-created skills as the core loop: add an MCP tool such as `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.
- Content-addressed deployment: put approved skills into the host agent dir, then let platform-store deploy them into `/sandbox/.platform/` and symlink into `/sandbox/.claude/skills/`, matching Right Agent's existing upgrade model Upgrade & Migration Model.
- Permission metadata: use skill frontmatter for advisory requirements, but translate network/filesystem changes into explicit bot-side policy review. Filesystem-policy changes require sandbox migration in Right Agent and cannot be hidden inside skill install sandbox docs.

## Recommended Implementation Path

1. Audit current built-in skill deployment. Align right-codegen skill installation, platform-store manifest deployment, and PROMPT_SYSTEM.md so every documented bundled skill is actually present inside OpenShell sandboxes.
2. Build `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.
3. Add Telegram approval for drafts. The bot should show a compact diff, scanner result, requested domains/filesystem needs, and actions: approve, reject, edit later. Approval, not the agent, installs the skill.
4. Define a Right Agent skill registry. Store per-agent entries in SQLite or a platform-managed manifest, with fields for name, source, install identifier, category, trust, content hash, installed_at, updated_at, disabled, provenance, and draft/approved state. Avoid manually editing agent configs or `.mcp.json`.
5. Deploy approved skills through platform-store. Extend the manifest from a fixed built-in subset to a registry-driven list of approved skill directories. Preserve user-installed directories across restarts and use content hashes to avoid stale or partial sandbox state.
6. Add bot-owned `/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.
7. Implement scanner and policy gate. Parse frontmatter and supporting files. Block path traversal, unexpected symlinks, prompt-injection patterns, destructive shell snippets, secret-looking literals, unsupported required platforms, and declared network/filesystem requirements not covered by current OpenShell policy.
8. Add read-only agent discovery tools if Claude Code's native Skill surface is insufficient. If needed, expose `mcp__right__skill_list` and `mcp__right__skill_view`, and update `with_instructions()`, templates, skills, and PROMPT_SYSTEM.md with full `mcp__right__` names.
9. Add curator later, initially report-only. Track skill usage and produce `/skills doctor` or `/skills curator report`. Only after reliable backups and pins exist should Right Agent archive stale agent-created skills.

## Open Questions

- Should Right Agent keep using Claude Code's native `.claude/skills` activation entirely, or add its own MCP-backed `skill_view` layer for more deterministic progressive disclosure?
- Where should approved skill provenance live: per-agent SQLite, `.claude/skills/installed.json`, or both for compatibility?
- How should Right Agent expose non-secret skill config without violating the bot-managed-field exception? A bot-managed registry in SQLite is cleaner than adding more user-facing `agent.yaml` fields.
- Should external read-only skill directories be allowed at all in sandboxed agents, or only on the host side with platform-store copying selected approved skills?
- What scanner policy should Right use for OpenClaw/ClawHub compatibility when third-party skills include helper scripts or broad shell instructions?
- Should agent-created skills be disabled by default until user approval, or installed as inactive drafts visible only through `/skills drafts`?
- How should Right reconcile skill update checks with the upgrade-friendly rule that existing agents adopt new platform behavior without recreation?

## References

### Hermes Sources

1. Hermes Agent homepage
2. Hermes Agent docs home
3. Hermes Skills System
4. Working with Skills guide
5. Creating Skills guide
6. Toolsets Reference
7. Curator docs
8. Hermes Configuration
9. NousResearch/hermes-agent AGENTS.md
10. Hermes tools/skills_tool.py
11. Hermes tools/skill_manager_tool.py
12. Hermes tools/skills_hub.py
13. Hermes tools/skills_guard.py
14. Hermes agent/prompt_builder.py

### Right Agent Sources

1. AGENTS.md
2. AGENTS.rust.md
3. ARCHITECTURE.md
4. PROMPT_SYSTEM.md
5. docs/architecture/mcp.md
6. docs/architecture/sandbox.md
7. docs/architecture/lifecycle.md
8. docs/architecture/memory.md
9. docs/architecture/sessions.md
10. crates/right-codegen/src/skills.rs
11. crates/right-codegen/skills/rightskills/SKILL.md
12. crates/right-codegen/src/pipeline.rs
13. crates/right-platform-store/src/lib.rs
14. crates/right-codegen/src/agent_def.rs
15. crates/right-codegen/src/mcp_config.rs
16. crates/bot/src/telegram/handler.rs
17. crates/right/src/aggregator.rs
18. templates/right/agent/TOOLS.md
19. templates/right/agent/agent.yaml