A Hermes /learn skill is what the learn command actually produces: a skill.md markdown file — a clean, reusable recipe your agent writes for itself and keeps forever. When Hermes learns something with /learn, it doesn't tuck the knowledge away in some opaque internal state. It saves a plain markdown file that stores the skill: the name, what the workflow does, when it applies, the exact procedure, and the mistakes to steer around. I'm Julian Goldie, and this page is my deep dive on that file — what a learned skill is made of, how the skill file loads, how to edit it when it's off, and how to share it when it's right.
📺 Watch: Learn Anything Engine for Hermes AgentOS
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
A quick map before we start. This is the anatomy lesson: for the big-picture case for teaching your agent, begin with my Hermes /learn overview, and for the step-by-step of actually running it, use my guide to the /learn command. I won't repeat either of those here.
Inside a Hermes /learn Skill: What the File Contains
The easiest way to explain the format is to show you a real one. I pointed /learn at my daily win log workflow — the routine I use to log the day's wins — and Hermes wrote the entire skill itself. I didn't touch a line of it. What came out was a tidy markdown file holding seven parts:
- The name — what you and the agent call the skill.
- The description — a one-glance summary of what it covers.
- The version — so a refined copy is distinguishable from an older one.
- What it does — the job itself, stated plainly.
- When to use it — the situations that should bring the skill into play.
- The procedure — the steps of the workflow, in order.
- The pitfalls to avoid — the traps this particular workflow is prone to.
That's the whole format. No exotic syntax, no sprawling configuration — a named, versioned, documented recipe in a single skill.md file. The procedure section described my own routine more cleanly than I'd ever written it down myself.
Why a Readable Skill Beats a Black Box
Here's the part I care about most. A learned skill is a verifiable, reusable recipe — not a black box. You can open the file, read it top to bottom, and see exactly what your agent believes the workflow is. If the procedure says to summarise the wins before logging them, that's what it will do — and if a step is wrong, you can see it's wrong before it costs you anything.
Compare that with the usual arrangement, where an assistant "sort of knows" your preferences and you discover what it actually absorbed by watching it make mistakes. With a skill file there's nothing to guess at. The knowledge sits in plain text, in a file you own, in a format you can audit in thirty seconds. That's a far better trust model, and it's why I'm happy handing real workflows to learned skills rather than hoping the agent remembers things the way I meant them.
Quick one before the detail: I share my own refined skill files — plus the prompts and workflows behind them — inside my community, so you can install what I've already taught my agent instead of starting from a blank file. Join us here.
How a Learned Skill Loads: On Demand, Not Always-On
Loading works two ways, and both are deliberately lightweight.
First, on demand: type /skill plus the name and the skill loads into the current session. Second, automatically: skills wake up when related terms come up in conversation. My Agent OS skill, for instance, loads whenever agent OS, mission control or memory galaxy are mentioned — I never have to summon it deliberately. The practical upshot is that a skill only takes up space when it's needed; it loads on demand rather than sitting in every session, so a growing library of skills never becomes a growing tax on every conversation.
Once saved, a skill also isn't tied to one doorway. The same skill file works across the dashboard chat, the terminal, voice via Hermes Jarvis, and messaging. Teach the workflow once and every surface you talk to Hermes through knows it.
📺 Watch: Hermes AI Just Learned to Read Books
Editing a Skill: It's Just Markdown
This is where the boring file format earns its keep. A learned skill is a markdown note — nothing more ceremonial than that. If a skill comes out slightly off, you have two easy fixes: open the file and correct the one line that's wrong, or run /learn again with a clearer source and let the agent rewrite the file properly.
You also get a checkpoint before anything is stored. With the approval gate on, you see the file before it saves, so a sloppy skill gets caught at the door rather than discovered a week later. Nothing is locked in, and a wrong skill can't break anything else — the worst case is a recipe you edit or replace. For a system you're trusting with your working methods, that's precisely the failure mode you want.
Getting a Better Skill Out of /learn
Three levers make the biggest difference to skill quality in my experience:
- Source clarity. A clear, specific source produces a better skill. Feed the command a rambling description and you'll get a vague recipe; feed it a precise walkthrough and the procedure section comes out sharp.
- Model choice. Route tricky jobs to a stronger model — a nuanced workflow deserves the best writer available.
- Don't overestimate the cost. In my testing on Goldie Bench, a free local model wrote a complete skill in about 25 seconds. Simple workflows genuinely don't need heavyweight firepower.
Sharing Skills and Installing Other People's
Skills are shareable, and this is where the format stops being a personal convenience and becomes an asset. You can publish a skill you've written, and you can install other people's with one command. I share mine with my community, and I'd point to the SEO skills I run as an example of how specialised these files can get.
A skill file you've refined — tested against your real workflow, with a pitfalls section earned the hard way — is genuinely transferable know-how. It isn't advice; it's the working recipe itself, installable in seconds.
Where Learned Skills Fit in the Wider System
A learned skill isn't a separate mechanism bolted onto the side of Hermes. It's the same skills system Hermes already has — /learn simply makes the agent author skills itself instead of you writing them by hand. That's the whole trick, and it's a significant one.
It's also what separates a learned skill from a downloaded skill or a plugged-in tool. Those give your agent generic capability. A learned skill captures your way of doing the job — your steps, your rules, your quality bar. Two people can teach the same type of workflow and end up with meaningfully different files, because the files encode how each of them actually works.
The pattern pairs naturally with the rest of the stack, too. There's the book-to-skill move I covered on my PDF reader page — feed the agent a book and it learns it as a queryable skill. And because skills live as files, they're part of what a Hermes export carries, which means the backup habits I recommend protect your skills along with everything else. The same file-first thinking runs through the memory system and its memory plugins, and it's why the whole setup stays inspectable end to end.
📺 Watch: New Hermes Agent Skill Bundles are INSANE!
The Compounding Point: Every Skill You Teach Sticks
Here's the strategic bit. Every skill you teach makes the agent more capable for good. Teach the win log workflow once and it's known permanently — not for a single session, but as a file that persists. Do that every week for a few months and you've built an agent whose usefulness compounds, because the recipes live in the agent, not in your head. That's the quiet difference between an assistant you re-brief forever and one that accumulates. The learned skill file is the unit that makes the compounding real: small, readable, fixable, and permanent until you say otherwise.
Skill File Anatomy at a Glance
| Skill part | What it's for |
|---|---|
| Name | What you and the agent call the skill |
| Description | A one-glance summary of what the skill covers |
| Version | Telling a refined copy from an older one |
| What it does | The job itself, stated in plain words |
| When to use it | The situations that should bring the skill into play |
| Procedure | The steps of the workflow, in order |
| Pitfalls to avoid | The known traps and mistakes to steer around |
Learned Skill FAQs
What is a learned skill, exactly?
It's the skill.md file that /learn produces when Hermes learns a workflow: a markdown recipe holding the name, description, version, what the skill does, when to use it, the procedure and the pitfalls to avoid. It's readable, reusable and entirely yours.
Can I edit a learned skill?
Yes — it's just markdown. If something's off, fix the one line that's wrong, or run /learn again with a clearer source and let the agent rewrite the file. With the approval gate on, you also see the skill before it ever saves.
Does a skill load in every session?
No, and that's the point. A skill loads on demand when you call /skill plus its name, and it auto-loads when related terms come up in conversation. Otherwise it takes up no room in your sessions.
Can I share a skill file?
Yes. Skills are publishable, and you can install other people's with one command. I share my own refined skill files inside my community, because a well-tested recipe is transferable in a way general advice never is.
What happens if a skill is wrong?
Nothing dramatic. A wrong skill can't break anything else — it's a text file, not wiring. Catch it at the approval stage, correct the offending line, or re-learn from a better source, and you're done.
My Verdict on the Skill File
The skill.md format is the least glamorous part of the whole learn feature and quietly the most important. Because a learned skill is a plain, versioned, readable recipe, everything else follows: you can verify what your agent believes, fix it in one line, load it only when it's relevant, run it across chat, terminal, voice and messaging, and hand it to someone else as working know-how. Boring formats are usually a feature; here it absolutely is.
My advice: teach one real workflow, open the skill file it produces, and read the procedure and pitfalls with a critical eye. Refine a handful of these and you'll own recipes that live in your agent rather than in your head — and if you'd like a head start, I share my working skill files inside the community. Join us here and install rather than reinvent.
