Nous Research's Hermes Agent Now Teaches Itself Your Entire Codebase

Hermes Agent, the open-source self-improving agent from Nous Research, just shipped a new /learn command that lets the agent ingest entire directories of source material and distill them into a reusable, verifiable skill. Feed it a folder of API docs, a codebase, a pile of PDFs, or internal config files, and it produces a structured SKILL.md document the agent can call on demand in any future session. No fine-tuning. No prompt stuffing. Just a clean, inspectable file on disk.

The problem it's actually solving

Every team that runs an AI agent on internal tooling hits the same wall: the agent doesn't know your stack. It doesn't know your internal API conventions, your deployment runbooks, or the quirks in your third-party vendor's SDK. The usual workarounds are either dumping everything into the system prompt (expensive, fragile) or re-explaining context every session (tedious, lossy).

Hermes's core differentiator has always been a closed learning loop: while solving problems with tools, it writes reusable skill documents and curates a persistent memory file so the agent quite literally gets more capable the longer it runs. The /learn command extends that loop to external knowledge , you bring the source material, the agent distills it.

How skills actually work

Skills are on-demand knowledge documents the agent can load when needed. They follow a progressive disclosure pattern to minimize token usage and are compatible with the agentskills.io open standard. That last part matters: Hermes follows the agentskills.io open standard , the same SKILL.md format Claude Code, Codex CLI, OpenClaw, OpenCode, and friends use.

The progressive disclosure model is worth understanding. Instead of loading every skill into every prompt, the agent uses a three-level hierarchy:

• Level 0 , a lightweight index of all skill names and descriptions (~3k tokens total)
• Level 1 , the full SKILL.md content for a specific skill, loaded only when relevant
• Level 2 , individual reference files within a skill (scripts, templates, docs), loaded only if needed

This means skills don't cost tokens until they're actually used. A library of 50 skills doesn't bloat your context on every turn.

What /learn produces

The output of /learn is a structured SKILL.md file with YAML frontmatter and a standardized body. A well-formed skill includes:

• A name and description used by the agent to decide when to load it
• A When to Use section with explicit trigger conditions
• A Procedure section with step-by-step instructions
• A Pitfalls section for known failure modes
• A Verification section so the agent can confirm it worked

The skill also supports references/, templates/, and scripts/ subdirectories for supporting files. Once created, it's immediately available as a slash command , if the skill is named my-api, you can invoke it with /my-api from the CLI or any connected messaging platform.

The self-improvement loop around it

Hermes is the only agent with a built-in learning loop , it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions. The /learn command plugs into that same loop. Skills created this way can be patched by the agent when it hits edge cases mid-run, and a background Curator process handles long-term maintenance.

The Curator runs automatically when the agent has been idle for at least two hours. It tracks usage per skill and moves stale ones through an active → stale → archived lifecycle , so your skill library doesn't accumulate dead weight. Skills can even edit themselves when they hit a snag mid-run, and a recent release added an autonomous Curator that grades, consolidates, and prunes the skill library so it doesn't rot.

You can also gate skill writes if you want human review before anything lands:

skills:
  write_approval: true  # stage all writes for review
# Then review staged writes:
/skills pending          # list staged writes
/skills diff <id>       # inspect the diff
/skills approve <id>   # apply it

Practical use cases for /learn

The most obvious targets are things the base model doesn't know well:

• Internal APIs , point it at your OpenAPI spec or SDK source and get a skill that knows your auth patterns, error codes, and pagination conventions
• Vendor documentation , distill a third-party SDK's docs into a skill so the agent stops hallucinating method signatures
• Deployment runbooks , convert a directory of Markdown ops docs into a callable /deploy-runbook skill
• Config-heavy systems , feed it Kubernetes configs, Terraform modules, or CI pipeline files to build a skill that understands your infra layout
• PDF manuals , hardware datasheets, compliance docs, or internal policy PDFs become queryable skills

A skill that tries to cover "all of DevOps" will be too long and too vague. A skill that covers "deploy a Python app to Fly.io" is specific enough to be genuinely useful. The same principle applies when using /learn: scoped source directories produce better skills than dumping an entire monorepo.

The ecosystem it plugs into

Hermes Agent has crossed 175,000 GitHub stars and attracted nearly a thousand contributors. In May it overtook OpenClaw, the previous open-source darling, to become the most-used open-source agent on OpenRouter's daily inference rankings, processing over 220 billion tokens in a single day. The Skills Hub at agentskills.io already indexes over 88,000 skills across registries from OpenAI, Anthropic, HuggingFace, NVIDIA, and the community.

Hermes skills use the SKILL.md format that Anthropic published as an open specification, a standard that Microsoft, OpenAI, Google, and dozens of other tools adopted within months. Your skills are portable files, shareable through a community hub, not assets trapped in one vendor's silo. Skills you distill with /learn can be published to a tap (a GitHub-hosted skill registry) and shared with your team or the community with no additional infrastructure.

Availability and cost

Hermes Agent is self-hosted, open source, and free forever. One command to install, one command to start. It works with Nous Portal, OpenRouter (200+ models), NovitaAI, NVIDIA NIM, OpenAI, or your own endpoint. The /learn command is available now in the current release. The only cost is whatever model inference you use to run the distillation pass , there's no Nous-side fee.

The real question for teams is whether they want to invest in curating good source directories. Skills that are too broad become noise; skills scoped to a specific tool or workflow become genuinely load-bearing infrastructure. Update skills when they go stale. If you use a skill and hit issues not covered by it, tell Hermes to update the skill with what you learned. Skills that aren't maintained become liabilities. The /learn command lowers the creation cost dramatically , the maintenance discipline is still on you.