Nous Research Adds / learns in the skills system of Hermes Agent, Capture Workflow as Slash Commands Without SKILL-Writing Hand-Writing.md

Nous Research has extended the Skills System within Hermes Agent, its open source self-development agent. The new addition is /learncommand that writes a reusable skill for you. Point to a documentation page, local SDK, past discussion, or sticky notes. The living agent collects the material, then the authors a SKILL.md instead of you.

The Hermes Agent can now / read from anything: feed references to any source material (code, API documents, manuals, PDFs, configs) and parse the executable pic.twitter.com/oRznwCRF3E

—Nous Research (@NousResearch) June 23, 2026

Hermes Skills System

Capabilities are documents of information that an agent needs when needed. Each is a folder containing ua SKILL.md file with instructions. They follow a continuous disclosure the pattern of keeping token usage low. The format is compliant with the agentkills.io open standard.

All abilities reside in it ~/.hermes/skills/the one source of truth. On a new installation, the compiled capabilities are copied to the repo. Hub-enabled and agent-created capabilities live there as well. Every entered skill becomes a slash command by default. Running /plan or /axolotl it loads the instructions for that skill on the turn.

Think of the skill as a reference book that the agent reads only when it’s relevant. Memory, by contrast, has little solid facts that must remain in context.

How it works / learning

/learn eliminates the manual writing step. You specify the source, and the agent does the detection with the tools it already has. It reads local references with read_file again search_files. Downloads online documents with web_extract. It can also capture the workflow you just went through.

# A local SDK or doc directory
/learn the REST client in ~/projects/acme-sdk, focus on auth + pagination

# An online doc page
/learn 

# The workflow you just completed in this conversation
/learn how I just deployed the staging server

# Pasted notes or a described procedure
/learn filing an expense: open the portal, New > Expense, attach receipt, submit

The agent then writes the property following the house approval standards. That means a description in less than 60 characters, a standard class arrangement, and an outline of the Hermes tool. It does not create commands that do not exist.

There is no separate import engine. /learn It creates level-driven information and provides it to the agent as a regular turn. So it works the same for CLI, messaging gateway, TUI, and dashboard. It also works on any terminal backend, whether local, Docker, or remote. The dashboard adds a Learn the skill a button with a directory field, a URL field, and a text box.

The agent stores the result with skill_manage a tool. If you have enabled the write authorization gate, that authorization step is still active.

Why Skills Are Always Cheap

Skills load in three levels, so an agent only pays for what they use.

Level	Make a phone call	It’s coming back	Almost. costs
0	`skills_list()`	Words, definitions, categories	~3k tokens
1	`skill_view(name)`	Full content and metadata	It varies
2	`skill_view(name, path)`	A specific reference file	It varies

The agent sees the collective index at all times. It only loads the content of the full skill when the task requires it. This prevents the main library from filling the context window.

Four Ways to Create Ability

/learn it is one way among many. The right choice depends on who is writing the skill and where the source lives.

The way	Who are the authors	Source input	Review the gate	It’s very good
Write by hand `SKILL.md`	You	Your personal information	Nothing	Full control over words
`/learn`	A living agent	Dir, URL, chat, notes	`skill_manage` The gate	Transform existing assets into capabilities quickly
`skill_manage` (default)	The agent itself	Newly resolved workflow	`write_approval` The gate	Taking process memory after difficult tasks
Installation of skills hub	Third person	Registry or GitHub repo	Security scanner	Reusing community or vendor skills

Agent-created capabilities are the agent’s process memory. An agent may save a method after a complex task of five or more tool calls. It also saves when it gets to the end and finds a way to work. By mistake, write_approval is false, so the agent writes freely. Set it to true for each section to review below ~/.hermes/pending/skills/.

Use Cases with examples

To install an internal API: Run /learn to the URL of your private documents. The agent generates the ability to cover auth, naming, and standard calls. New teammates then request it as a slash command.
Captures the output runbook: Go agent with single stage implementation. Then run /learn how I just deployed the staging server. The process becomes repetitive across CLI and forums.
Collecting work in progress: Use a bunch of skills to load several skills at once. A single slash command then pulls in review, testing, and PR skills together.

# ~/.hermes/skill-bundles/backend-dev.yaml
name: backend-dev
description: Backend feature work — review, test, PR workflow.
skills:
  - github-code-review
  - test-driven-development
  - github-pr-workflow
instruction: |
  Always start by writing failing tests, then implement.

Viewing the SKILL.md Format

A capability is usually a markup file with a YAML frontmatter. The body follows a fixed phase command. /learn target this situation exactly so that the output remains the same.

---
name: my-skill
description: Brief description of what this skill does
version: 1.0.0
platforms: [macos, linux]     # Optional — restrict to specific OS
metadata:
  hermes:
    tags: [python, automation]
    category: devops
---

# Skill Title

## When to Use
Trigger conditions for this skill.

## Procedure
1. Step one
2. Step two

## Pitfalls
- Known failure modes and fixes

## Verification
How to confirm it worked.

I platforms field can hide the ability on incompatible operating systems. Conditional fields can also display the ability only if certain tools are present or absent.

Interactive Descriptor

Expenses, attach receipt, submit’, open:’open portal, New > Expenses, attach receipt, submit’,focv:”,tool:’attached text’,action:’Analyze attached notes’} }; function slug(s){ return (s||”).toLowerCase().replace(/[^a-z0-9]+/g,’-‘).replace(/^-+|-+$/g,”)||’my-skill’;} function esc(s){return (s||”).replace(/&/g,’&’).replace(//g,’>’);} function updateCt(){ var n=desscIn.value.length; ct.textContent=n+’ / 60′; ct.className=”ct”+(n>60?’ over’:”); } function updateCmd(){ var p=presets[src]; var arg=srcIn.value.trim(); var foc=focIn.value.trim(); var tail=foc?(‘, ‘+foc):”; if(src===” tail = ifoc?(‘ ‘+foc):”; var body; if(src===” body=arg+(foc?(‘, ‘+foc):”); else if(src===’url’) body=arg; another body=arg+(foc?(‘ — ‘+foc)=PressHTMLd.”);$ /read ‘+esc(body); } set functionTab(s){ src=s; tabs.forEach(function [srcIn,focIn].forEach(function(el){el.addEventListener(‘input’,updateCmd);}); descIn.addEventListener(‘input’,updateCt); function buildSkill(){ var name=slug(nameIn.value); var cat=slug(catIn.value)||’general’; var desc=descIn.value.trim().slice(0,60); var p=set[src]; var arg=srcIn.value.trim(); var foc=focIn.value.trim(); var tagBase=name.split(‘-‘).slice(0,2); var tags=”[“+tagBase.join(‘, ‘)+’]’; var whenLine, procLines, verifyLine, sourceNote; if(src===”{ whenLine=”Use when working with code in “+arg+’.’; sourceNote=”Written from local source: “+arg+(foc?(‘ (‘+foc+’).’):’.’); procLines=[‘1. Inspect the relevant module before calling it.’, ‘2. Apply the documented auth and request pattern.’, ‘3. Handle pagination and errors as the source specifies.’]; verifyLine=”Use a sample call and verify a valid response.”; } else if(src===’url’){ whenLine=”Use when compiling the API written in “+arg+’.’; sourceNote=”Written on the doc page: “+arg+’.’; procLines=[‘1. Read the quickstart steps in order.’, ‘2. Set credentials and the base URL.’, ‘3. Make the first request and inspect the payload.’]; verifyLine=”Verify the response matches the written schema.”; } else if(src===’conv’){ whenLine=”Use to repeat this process: “+arg+’.’; sourceNote=”Taken from a completed workflow in a chat.”; procLines=[‘1. Reproduce the steps in the order performed.’, ‘2. Substitute environment-specific values where noted.’, ‘3. Stop and report if any step fails.’]; verifyLine=”Verify that the final state is the same as the initial launch.”; } else { whenLine=”Use the following procedure: “+arg+’.’; sourceNote=”Written in the attached notes.”; procLines=[‘1. ‘+arg.split(‘,’)[0].decide()+’.’, ‘2. Proceed with each step listed in order.’, ‘3. Confirm completion before closing the job.’]; verifyLine=”Verify the last step was completed successfully.”; } var L=’n’; var s=””; s+=’—‘+L; s+=’name: ‘+esc(name)+L; s+=’description: ‘+esc(desc)+L; s+=’version: 1.0.0’+L; s+=’metadata:‘+L; s+=’ hermes:‘+L; s+=’ tags: ‘+esc(tags)+L; s+=’ category: ‘+esc(cat)+L; s+=’—‘+L+L; s+=’# ‘+esc(name.replace(/-/g,’ ‘).replace(/bw/g,function(c){replace c.toUpperCase();}))+’‘+L+L; s+=’## When to use‘+L+esc(whenLine)+L+L; s+=’## Process‘+L+procLines.map(esc).join(L)+L+L; s+=’## Traps‘+L+’- Don’t make calls the source doesn’t define.’+L+’- Check the source again if the behavior changes.’+L+L; s+=’## Validation‘+L+esc(verifyLine)+L+L; s+=’‘; return {html:s, name:name, cat:cat}; } function plainSkill(name, cat, html){ var tmp=html.replace(/<[^>]+>/g,”); var d=document.createElement(‘textarea’);d.innerHTML=tmp;return d.value; } function type Stage(rows, done){ stage.innerHTML=”; lines.forEach(function(t,i){ var d=document.createElement(‘div’); d.className=”ln”;d.style.animationDelay=(i*0.32)+’s’; d.innerHTML=t;stage.appendChild(d); }); setTimeout(done, lines.length*320+150); } function run(){ var p=presets[src]; runBtn.disabled=true;runBtn.textContent=”Active…”; out.classList.add(‘show’); var built=buildSkill(); var rows=[ ‘→ ‘+p.verb+’ via ‘+p.tool+’‘, ‘→ Building standards-guided prompt (≤60-char description, fixed section order)’, ‘→ Agent authoring SKILL.md as a normal turn’, ‘✓ skill_manage(create) → ~/.hermes/skills/’+built.cat+’/’+built.name+’/’, ‘✓ Slash command ready: /’+built.name ]; typeStage(lines,function(){ skillPre.innerHTML=built.html; runBtn.disabled=false;runBtn.textContent=”Run /learn ▸”; report(); }); report(); } copyBtn.addEventListener(‘click’,function(){ var txt=skillPre.innerText; if(navigator.clipboard){navigator.clipboard.writeText(txt);} copyBtn.textContent=”Copied ✓”; setTimeout(function(){copyBtn.textContent=”Copy”;},1400); runBtn.addEventListener(‘click’,start); // automatically resize WordPress iframe function embed(){ var h=document.parent.postMessage({hlLearnHeight},’*’); window.addEventListener(‘resize’, report).note(root,childList:true}); setTimeout(report,200); })();