Type /refine and Hermes agent /refine runs the background memory-and-skill self-improvement review on the spot, instead of waiting for the automatic post-turn trigger. That is the entire job of the command: an on-demand nudge that tells Hermes to review what it has just learned right now, optionally steered by focus text you type after it. The review runs in a background fork against a snapshot of the conversation, so your live session and prompt cache are left untouched, and the results are reported back once it finishes. It works in both the CLI and the messaging gateway, and it is documented in the official slash-commands reference. I first spotted it on the unofficial Hermes Release Watch cheat sheet dated 5 September 2026, and I have leaned on it daily ever since.
📺 Watch: Hermes + Jarvis + Obsidian Memory is INSANE!
🔥 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
What the /refine command actually does
The reference describes /refine plainly: it runs the background memory and skill self-improvement review immediately, rather than waiting for the automatic post-turn trigger. Read that twice, because the second half quietly confirms something bigger than the command itself. Hermes already reviews its own memories and skills after turns, automatically, in the background — looking over what just happened, deciding what is worth keeping, what needs correcting, and what deserves to become a reusable skill. /refine simply moves that moment from whenever the trigger fires to right now.
That timing shift sounds small and is not. When I have just finished a messy piece of work — a deployment that finally went clean, a research sprint that surfaced something genuinely useful — the freshest review is the most accurate one. Running /refine on the spot means consolidation happens whilst everything worth capturing is still front and centre. Same machinery, better moment.
Hermes agent /refine syntax and focus text
The syntax barely qualifies as syntax. On its own, /refine triggers the standard review with no particular steer. Add focus text after the command and that text steers the review towards whatever you name. The documented example is worth quoting exactly: /refine save the deploy workflow as a skill. One line, and it tells you precisely what focus text is for — pointing the reviewer at a specific outcome you want from the pass.
In practice I treat the focus text like a briefing note. If the session just produced a workflow I want captured, I say so. If I want the pass to concentrate on what went wrong earlier, I describe that instead — plain English, typed straight after the command. The Hermes agent /refine pattern rewards specificity: a vague nudge gets the generic review you would have received anyway, while a pointed one gets the exact capture you were hoping for.
Want the exact refine-and-capture routines I run across my own agents every day? Grab my Hermes workflow playbooks inside AI Profit Lab — and if you would rather map it onto your business one-to-one, book a free SEO strategy session with me.
📺 Watch: Hermes3D Is INSANE: AI Agents Now Have a 3D Office
The background fork: why /refine never disturbs your session
The mechanics are my favourite part. /refine runs in a background fork against a snapshot of the conversation. Your live session carries on exactly as it was, your prompt cache stays untouched, and the results are reported back when the review is done. No pause, no context churn, no risk of the review polluting the very conversation it is reviewing.
The cache detail deserves emphasis. Long agent sessions live and die by cache economics — rebuilding a large prompt cache is where the real cost hides — and a background fork that leaves the cache alone is exactly the cache-friendly pattern I described in my Hermes memory budget breakdown. A review that trashed the cache on every run would be a tax on the sessions it was trying to improve. As designed, /refine is effectively free to invoke from the live session's point of view.
/refine vs /learn: steering a review vs teaching from a source
These two commands sound like siblings and behave like opposites. The /learn command teaches Hermes from a source: point it at material and it studies it, saving what it extracts as skill files — the same skill.md format I unpacked in my guide to Hermes skill files. Knowledge flows inward, from the outside world into the agent.
/refine works in the opposite direction. There is no external source; the raw material is the conversation you have already had, and the review decides what deserves to survive as memory or skill. The documented focus example — save the deploy workflow as a skill — is the same capture-a-skill idea, except harvested from your own session rather than taught from someone else's documentation. My rule of thumb: /learn when the expertise lives outside the session, /refine when you have just generated it yourself. And do not muddle /refine with /review either — that is a different command entirely, one I broke down in my Hermes /review command guide.
📺 Watch: Hermes AI Agents Just Went Portable
/refine and memory hygiene
Every serious agent operator ends up with the same three habits, and I laid mine out in my Hermes memory management guide: review what the agent has stored, correct what is wrong, dedupe what is repeated. Done by hand, that is a weekly chore. /refine is the built-in version of the same discipline — a review over memory and skills that the agent performs on itself, triggered whenever you decide the moment is right.
I still audit manually, because trust is earned. But the command has changed the ratio: hygiene is no longer something I impose purely from outside, because /refine lets me demand an internal pass that keeps the memory store honest between my own inspections.
Where /refine sits in the self-improvement loop
Zoom out and /refine is one lever on a much larger machine. The Hermes self-improvement loop is the cycle where the agent works, reviews its own performance, updates memory, promotes skills, and comes back sharper for the next task. The automatic post-turn review is that loop ticking over on its own schedule; /refine is the manual crank handle. Inside my Agent OS setup that distinction matters, because the sessions that compound fastest are the ones where the review lands at the most instructive moments — and only the operator knows when those are. The loop supplies the machinery. /refine hands you the timing.
Practical ways I use /refine
Three patterns cover almost all of my real /refine usage:
- The end-of-day refine. Last action before I close a working session: trigger the review while the day's context is intact. The automatic trigger would get there eventually, but I would rather the day's lessons were consolidated on my schedule, not the agent's.
- Capture a workflow you just nailed. The moment something goes from fumbling to fluent, I run the review with focus text describing what to save — exactly the spirit of the documented deploy-workflow example. Fresh wins make the best skills.
- The pre-handover tidy. Before pointing the agent at a new project, I trigger a review of the old one, so the useful residue gets consolidated rather than buried under fresh context.
Whether the review actually captures what I expect is something I measure rather than assume — my Goldie Bench notes are where I log how each command behaves across repeated runs.
Hermes agent /refine at a glance
| Aspect | Documented behaviour |
|---|---|
| What it triggers | The background memory and skill self-improvement review, run immediately |
| Default timing without it | The review fires on the automatic post-turn trigger |
| Syntax | /refine, with optional focus text steering the review |
| Documented example | /refine save the deploy workflow as a skill |
| Where it runs | A background fork against a conversation snapshot |
| Live session impact | None — session and prompt cache untouched; results reported when done |
| Availability | CLI and the messaging gateway |
Hermes agent /refine FAQ
Does Hermes agent /refine interrupt my live session?
No. The review runs in a background fork against a snapshot of the conversation, the live session and prompt cache are untouched, and the results are reported back when it finishes. You can keep working the whole time.
What is the difference between /refine and /learn?
/learn teaches Hermes from an external source and saves the output as skill files. /refine reviews what already happened in your own session and consolidates memory and skills from it. Outside-in versus inside-out.
Do I still need /refine if the review runs automatically?
The automatic post-turn trigger runs the review regardless. /refine earns its place on timing and steering: you choose the moment, and the optional focus text points the pass at the exact thing you want captured.
Does /refine work outside the CLI?
Yes. The documentation lists it as working in both the CLI and the messaging gateway, so a refine triggered from chat behaves the same as one typed into a terminal session.
My verdict on /refine
/refine is the smallest possible command wrapped around the most important idea in agent operations: a system that improves itself, on demand, without disturbing the work in progress. The automatic review means Hermes gets better whether you ask or not; the command means it gets better at the moments you choose, steered towards the things you actually care about keeping. Snapshot fork, untouched cache, results reported when done — the engineering respects your session, and the focus text respects your judgement. If you adopt one habit from this page, make it the end-of-day refine. Compounding needs a schedule, and now you own it.
If you want agents that genuinely compound — refine, learn, memory and all — join me inside AI Profit Lab and copy my full Hermes setup, or book a free SEO strategy session and I will walk you through it on a call.
