Hermes v0.18: It Learned How to Learn
Not a smarter model. The first AI agent that actually feels like it's accumulating.
The Third Day
You ask an AI to help with the same task three days in a row.
Day 1: "Write my weekly report, use this format." It does. Decent.
Day 2: "Write my weekly report." It writes, but the format's wrong. You say "no, like yesterday's format." It apologizes, rewrites.
Day 3: "Write my weekly report." It writes. Wrong format again.
You start to wonder: does this thing actually remember anything? Or is every conversation like the first time?
I used to measure an AI agent by whether it could complete the task. Then I tried Hermes v0.18. And that feeling changed.
I'd spent time with ChatGPT's memory, Claude's Projects, Kimi's long context. They all "remember" something. But the feeling of being remembered is more like someone slapping a sticky note on their forehead — they see it, but they don't really understand it, and they definitely can't apply it at the right moment.
The bigger problem: you can't see what they've remembered.
They say "I'll remember that." You have no idea what they remembered, whether they got it right, or if they remembered the wrong thing entirely. That black box is why I've never trusted an AI agent with long-term work.
Then I tried Hermes Agent v0.18 (released July 1, 2026, codename "The Judgment Release"). Two commands stopped me: /learn and /journey.
Together, they're the first time I felt like — this thing is actually growing up.
Not "the model got stronger" growing up. But "it's becoming an assistant who understands me better" growing up.
/learn — Turning "How I Work" Into a Reusable Skill
The Problem: The Amnesic Intern
Before /learn, teaching an AI to work your way means reminding it in every prompt.
You want it to format data your way — every time, you say "use this format." You want it to code in your style — every time, you paste an example. You want it to remember your project context — every time, you re-explain the background.
The feeling is exactly like training an intern who forgets everything overnight.
Hermes v0.18's /learn command does something simple: it lets the agent distill its own working process into a skill file — and the next time it sees a similar task, it calls that skill automatically.
Not you teaching it in the prompt. It learning how to help you.
Imagine you're training a new intern. On day one, you explain how you like your weekly reports formatted. The intern nods, writes it down in a notebook. On day two, they produce the report in exactly the right format — without you reminding them.
That notebook? That's what /learn creates. Except instead of paper, it's a SKILL.md file. And instead of waiting three months for the intern to figure things out, this happens in seconds.
The difference from every other AI: you can read the notebook. You can edit it. You can throw it away and make a new one.
I tried it a few times to see how far it could go.
Test 1: GitHub Issues.
I gave Hermes a project's issue list and said "output in my preferred format." It asked what my preference was; I said "concise, just title + priority + assignee." It output the result.
Then I typed: /learn.
It asked "what should I learn?" I said "learn to organize issues in my format." It thought for a moment and said "OK, I'll create a skill."
A few seconds later: skill created, named organize-issues-in-user-format.
Next time I said "help me organize this project's issues" — it output in that format directly. No asking about preferences. No re-explaining. It just did it.
Test 2: API Documentation.
I gave it a URL to a technical doc and said "learn this API." After reading the docs, it turned the API usage pattern into a skill. Next time I asked a related question, it called that skill directly — no need for me to re-explain what the API does.
/learn supports three types of input: a directory, a URL, or a recent workflow.
At its core, it's converting tacit knowledge (how you work, your preferences, your understanding of a tool) into explicit knowledge (a standard SKILL.md file).
The file isn't stored in some database you can't access. It lives in ~/.hermes/skills/, written in Markdown. It contains:
- YAML frontmatter (metadata)
- Trigger conditions (when to use this skill)
- Steps (how to do it)
- Common errors (what goes wrong)
- Verification (how to tell it's done right)
You can open it, edit it, even share it with someone else.
This is not the same as ChatGPT's "memory."
| ChatGPT Memory | Claude Project | Hermes /learn | |
|---|---|---|---|
| What it remembers | Decided by the model | Files you upload | Your working patterns, as skills |
| Can you see it? | ❌ No | ✅ Yes (the files) | ✅ Yes (the SKILL.md) |
| Can you edit it? | ❌ Not really | ✅ Yes (re-upload) | ✅ Yes (it's Markdown) |
| Does it actively improve? | ❌ Passive | ❌ Static reference | ✅ Active — creates skills from your workflows |
/journey — Seeing What the Agent Has Learned
If /learn is "let the agent learn to do things," then /journey is "let the user see what the agent has learned."
This is a design I haven't seen in any other AI agent.
You open /journey, and you see a timeline: when Hermes learned something, which skills it created, which memories it updated.
Not an abstract "I've learned a lot" — but concrete entries:
-
2026-07-15 14:32— Created skillorganize-issues-in-user-format -
2026-07-16 09:15— Updated memory entry "user prefers concise answers" -
2026-07-16 11:47— Created skillapi-integration-github
You can click into each entry, see what it learned, why it learned it, what the content is.
More importantly: you can edit or delete any entry.
I found this more useful than I expected.
Once, I noticed Hermes's recent responses had changed — they'd become weirdly concise, sometimes skipping information. I wasn't sure if it had "learned badly" or "learnt well."
I opened /journey. I saw that three days earlier, from a certain conversation, it had updated a memory entry: "user prefers concise answers." But that time, I was in a hurry and had casually said "keep it brief." It wasn't my real preference — but Hermes had treated it like a "pattern."
I deleted that memory entry. Problem solved.
Without /journey, I might have spent a long time figuring out: why did its behavior change? Is it a model problem? Or did I say something it remembered?
Memory Graph: The "Brain Map"
Another feature that left an impression: memory graph (in the Hermes Desktop version).
It visualizes Hermes's knowledge structure — which concepts are connected, which memories are core nodes, which skills are frequently used.
Think of it as Hermes's "brain map."
Opening the memory graph, I could see it had already remembered my project structure, tech stack, and code style. And each node had a timestamp — I could trace back to when, and from which conversation, it learned that.
This "visibility" gave me a feeling I hadn't had before: I know what it's learning, I can judge whether it got it right, I can intervene in its learning process.
Traditional AI memory is invisible. It says "I'll remember," and you choose between "I trust you" and "I don't trust you." No middle ground.
Hermes's /journey gives you the middle ground: I can see what you've remembered, and I get to decide whether that's correct.
The Logic Behind the Design
I initially thought /learn and /journey were just two neat features.
The more I thought about it, the more I realized: behind these two features lies a much deeper question.
Most people evaluate an AI agent by "can it complete the task?" But the Hermes team, in v0.18, is asking: can the user trust what it has learned?
This question is harder, and more fundamental, than "can it complete the task?"
An agent can be powerful — powerful enough to write code, fix bugs, analyze problems for you. But if what it learns is invisible, uneditable, and unmanageable, would you trust it to work on long-term tasks for you?
I wouldn't.
Because I know it might remember wrong, might treat a one-time exception as a general pattern, might learn something from a conversation that I don't want it to learn.
If its learning process is invisible, I have no way to judge whether it deserves my trust.
<span>Visible</span>
<span>You can see what it learned</span>
<span>Editable</span>
<span>You can correct its mistakes</span>
<span>Manageable</span>
<span>You can delete a wrong skill or memory</span>
Visibility = Controllability.
You can see what it learned — that's how you judge whether it deserves your trust. You can edit its memories — that's how you correct its mistakes. You can delete a skill — that's how you prevent it from using the wrong method.
This is the part of Hermes v0.18's design that I appreciate most: it's not pursuing "a more powerful model," it's pursuing "a more trustable agent."
Think about the difference between these two scenarios:
Scenario A: You tell a colleague "I prefer concise updates." They nod. Six months later, they're still writing novels. You have no idea whether they remembered or not.
Scenario B: You tell a colleague "I prefer concise updates." They write it down in a shared notebook. You can open that notebook anytime, see "noted: prefers concise updates," and if it's wrong, you cross it out and write "actually, depends on the situation."
/journey is that shared notebook.
The difference from every other AI: the notebook is ours, not theirs. You have just as much access as the agent does.
Another point worth making: the perceivable quality of growth.
If an AI is improving but the user can't feel it, the user won't feel like "it's growing up" — they'll just feel like "it's inconsistent."
/journey makes progress something you can see. You open the timeline, see that over the past week it created 5 skills, updated 12 memories, corrected 3 errors — you visually feel: it's getting stronger, and the direction of that strength is useful to me.
That feeling is something no benchmark score can give you.
The Skill Mechanism's Design Philosophy
One final point: Hermes's skills are Markdown files. Not binary data, not a proprietary format — plain text, editable, version-controllable, shareable Markdown files.
What does this mean?
It means a user can put skills in Git and manage them. It means a user can write their own skills. It means a user can share skills with colleagues, put them in a team knowledge base, even open-source them to the community.
This is not "AI's black-box capability" — this is "a knowledge system the user can participate in."
I think this might be a standard paradigm for future AI agents: what an agent learns should be something the user can see, edit, and control.
The Broader Pattern: Making the Agent's Behavior Verifiable
Scrolling back through the Hermes v0.18 release notes, I realized something.
This version has ~1,720 commits, 998 merged PRs, ~251,000 lines of code changes. This was a version where they put in serious work.
Beyond /learn and /journey, two other features point in the same direction: making the agent's behavior verifiable.
One is MoA (Mixture-of-Agents) reasoning now visible.
Previously, when you used MoA mode (multiple models reasoning together, then aggregating results), you could only see the final output. Now you can see what each reference model outputted, what answers they each gave, how the final aggregation was derived.
This isn't a particularly "flashy" feature, but it's very important. Because when you're using multiple models to make an important decision, what you need isn't "one answer" — it's "why is this answer trustworthy."
The other is task completion verification (verification evidence).
Previously, an agent would finish a task and say "I'm done." But you didn't know if it actually finished, or if it was just telling you what you wanted to hear.
Now Hermes shows you which checks it ran to prove the task is complete. Not saying "I'm done" — but showing evidence: I checked A, I verified B, I tested C, so the task is complete.
These features — /learn, /journey, MoA reasoning visible, task verification — together point to the same direction:
The Hermes team isn't making the agent "smarter." They're making it "transparent."
Smart is their own business. Transparent is whether you can see what it's doing, how it's doing it, and why it's doing it that way.
An Assistant That Accumulates
Back to the opening scenario.
You ask an AI to help with the same task three days in a row.
The difference:
- Day 1: It's a stranger — you have to explain your format, preferences, and context.
- Day 2: It remembers what you said yesterday — but that's it. It won't proactively apply that information.
- Day 3: It proactively says "I created a skill; from now on, I can handle this type of task directly according to your preferences" — it didn't just remember; it learned.
This isn't a "smarter model." This is "an assistant that accumulates."
Whether the model is strong or not is the vendor's business. Whether it accumulates — that's about your experience using it.
Hermes v0.18's /learn and /journey are the first time I felt like: an AI agent can go from "tool" to "assistant."
Not because it got smarter. But because it started to "remember well, learn properly, and explain how it learned."
If you're curious what Hermes is, go to GitHub and search NousResearch/hermes-agent, read the README.
If you want to try /learn and /journey, install Hermes Agent. It supports CLI, Desktop, and WeChat integration — pick whichever way you're used to.
If you're building an AI product, go study its memory and skill design. Particularly the visibility design of memory — it's worth studying for every team building AI products. This might be the standard paradigm for future AI agents: not "a stronger model," but "a more trustable agent."
When I use Hermes v0.18, one image stays in my head:
An intern, first day on the job, you teach them how to work. Second day, they remember what you said yesterday. Third day, they proactively come to you and say: "I summarized a working method; from now on, I can handle this type of task in your preferred way."
You'd feel: this intern is growing up.
Hermes v0.18 let me see that feeling in an AI agent for the first time.
It didn't suddenly get strong. It's gradually becoming an assistant who understands you better, through the process of working with you.
That feeling is called "growing up."
Top comments (0)