Hermes Agent's /learn Command Lets You Teach It a New Skill in One Line

TL;DR

Hermes Agent, the open-source agent from Nous Research, has a feature worth copying: a /learn command that turns existing knowledge into a reusable skill in one line. Point it at a local directory, a documentation URL, a procedure you just walked it through, or a block of pasted notes, and it writes a SKILL.md file you (and it) can reuse forever. It pairs with Hermes' autonomous skill creation, where the agent writes its own skill after solving a complex task. The quietly important part is the format: skills are plain Markdown on disk, MIT-licensed, and portable, not locked inside a context window or a vendor.

What /learn actually does

Most agents treat "learning" as either fine-tuning (expensive, slow, opaque) or stuffing more into the prompt (fragile, and it evaporates when the session ends). Hermes' /learn takes a third path: it captures a workflow as a file. You run something like /learn the REST client in ~/projects/acme-sdk, or /learn https://docs.example.com/api/quickstart, or /learn how I just deployed the staging server, and the agent uses its normal tools to gather the material, then writes a structured skill.

A detail the docs are careful about: /learn has no special model-tool footprint. It builds a prompt and hands it to the agent as a normal turn. There is no hidden subsystem, no separate model. That is the right design, because it means the same capability that solves your tasks is the one writing the skills, and you can read exactly what it produced.

Skills are just Markdown, and that is the point

Every skill is a SKILL.md file: YAML frontmatter (name, description, version, optional platforms, tags) followed by a Markdown body with a "When to Use" section and the actual procedure. They live in ~/.hermes/skills/ as the single source of truth, and a skill folder can carry its own references, templates, scripts, and assets alongside the Markdown. Drop a folder in, and it is live. No registration step.

Because the format follows the open agentskills.io convention, a skill is not Hermes-specific trivia. It is a portable artifact you can version in git, review in a pull request, and share. That is a meaningfully different posture from agents that bury learned behavior in opaque memory blobs.

Two ways a skill gets written

The /learn command is the deliberate path: you decide something is worth keeping. The other path is autonomous. Per the skills documentation, Hermes writes a skill on its own after completing a complex task (the docs cite a threshold of five or more tool calls), after recovering from an error onto a working path, or after a user correction. A background review runs at the end of a turn and can author skills freely by default.

That autonomy is powerful and a little dangerous, so Hermes gates it. Set skills.write_approval: true and every write is staged in ~/.hermes/pending/skills/ instead of committed. You review with /skills pending, inspect with /skills diff, and then /skills approve or /skills reject. Skill writes survive restarts while they wait. If you are going to let an agent edit its own behavior, a staging area with a diff is the minimum sane guardrail.

Why builders should care

Hermes is MIT-licensed, model-agnostic (it runs on Nous Portal, OpenRouter's 200-plus models, and custom endpoints), and at the time of writing sits north of 200,000 GitHub stars with frequent releases. You do not have to adopt Hermes to take the lesson. The pattern, capture workflows as small, human-readable, on-demand files instead of cramming them into a prompt or a fine-tune, is portable to whatever agent you are building. Third-party writeups claim agents with a couple dozen self-written skills finish similar tasks meaningfully faster, mostly by skipping the from-scratch reasoning. Treat that as directional, since it is not Nous's own published benchmark, but the direction is right.

The honest caveats

An agent that writes its own behavior can also write the wrong behavior: a skill that encodes a bad assumption will keep applying it confidently until you catch it. Leave write_approval on for anything that touches real systems, and read the diffs. The "five or more tool calls" trigger and the speed claims come from the docs and community, so verify against your own runs before you trust the loop unattended. Skills are powerful precisely because they persist, which is also exactly why a bad one is worth catching early.

Key Takeaways

• Hermes Agent's /learn command turns a directory, a docs URL, a just-completed procedure, or pasted notes into a reusable SKILL.md in one line.
• /learn has no special model-tool footprint: it runs as a normal agent turn, so the output is transparent and auditable.
• Skills are plain Markdown with YAML frontmatter in ~/.hermes/skills/, following the open agentskills.io format. Portable, git-friendly, no registration.
• Hermes also writes skills autonomously after complex tasks (a cited five-plus tool-call threshold), gated by an optional staging-and-approval flow.
• The transferable idea: accumulate agent know-how as small on-demand files, not context-window bloat or a fine-tune. Keep write approval on for anything that touches production.

Sources: Hermes Agent (GitHub), Hermes skills documentation, Working with Skills guide