Hermes v0.18: It Learned How to Learn

A hands-on look at the two features that make this release different — and why “transparent” matters more than “smart.”

The Third Day

You ask an AI to help with the same task three days running.

Day one, it needs everything explained. Day two, it remembers what you said — but doesn’t proactively apply it. Day three, it says: “I created a skill for this. I can handle it directly now.”

That last moment — that’s what “growing up” feels like.

I’ve used ChatGPT’s memory, Claude’s Projects, Kimi’s long context. They all “remember” something. But the experience of being remembered always felt like the AI had slapped a sticky note on its forehead — it sees the note, but doesn’t really understand it, and definitely can’t apply it at the right moment.

The bigger problem: you can’t see what they’ve remembered.

“I’ll remember that,” they say. You have no idea what they actually retained, whether they got it right, or if they learned the wrong thing entirely. That black box is why I’ve never trusted an AI agent with genuinely long-term work.

Then I tried Hermes v0.18.

/learn: From Tacit Knowledge to Explicit Skill

The core idea is simple: after you work with Hermes on a task, you type /learn. Hermes distills what it just learned about how you work into a SKILL.md file — stored in ~/.hermes/skills/, editable, version-controllable, shareable.

Not the model remembering passively. You deciding what should be learned, and Hermes packaging that into a reusable skill.

What a skill file contains

• Trigger conditions — when this skill should be used
• Steps — the actual workflow
• Common errors — what tends to go wrong
• Verification — how to tell it’s done right

The key difference from every other AI: the skill is a Markdown file. You can open it, read it, edit it, delete it, share it. It’s not a black box — it’s a notebook you both contribute to.

The Trust Problem

Most people evaluate an AI agent by: “can it complete the task?”

Hermes team is asking a deeper question: can you trust what it’s learned?

An agent can be powerful. But if what it learns is invisible, uneditable, and unmanageable — would you trust it with long-term work?

I wouldn’t. Because I know it might remember wrong. It might treat a one-time exception as a general pattern. It might learn something from a conversation I didn’t want it to learn.

Visibility = Controllability.

You can see what it learned → you can judge whether it deserves your trust. You can edit its memories → you can correct its mistakes. You can delete a skill → you can prevent it from using the wrong method.

This is what Hermes v0.18 is really doing: not pursuing “a smarter model,” but pursuing “a more trustable agent.”

/journey: Seeing the Learning Timeline

If /learn is "let the agent learn," then /journey is "let the user see what was learned."

You type /journey. A timeline appears:

2026-07-15 14:32 — Created skill `organize-issues-in-user-format`
2026-07-16 09:15 — Updated memory: "user prefers concise answers"
2026-07-16 11:47 — Created skill `api-integration-github`

You can click into each entry. See what it learned, why, and what the content is.

More importantly: you can edit or delete any entry.

I found this more useful than expected.

Once, Hermes’s responses became weirdly concise — skipping information. I wasn’t sure if it had “learned badly” or “learned well.”

I opened /journey. 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." Not my real preference — but Hermes treated it as 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?

The Broader Pattern: Verifiability

This release has ~1,720 commits, 998 merged PRs, ~251,000 lines of code changes. It’s 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: MoA (Mixture-of-Agents) reasoning is now visible.

Previously: MoA mode → you only see the final output. Now: you see what each reference model outputted, what answers they gave, how the aggregation was derived.

Two: Task completion verification (verification evidence).

Previously: agent finishes → says “I’m done.” You don’t know if it actually finished. Now: it shows you which checks it ran. Evidence, not just a claim.

These features together point to the same direction:

The Hermes team isn’t making the agent “smarter.” They’re making it “transparent.”

Smart is the model’s business. Transparent is whether you can see what it’s doing, how it’s doing it, and why.

The Takeaway

Back to the three-day scenario.

The difference:

• Day 1: it’s a stranger — everything must be explained.
• Day 2: it remembers what you said — but doesn’t proactively apply it.
• Day 3: it proactively says “I created a skill; I can handle this type of task directly now.” — it didn’t just remember; it learned.

That feeling — “this thing is growing up” — isn’t from a smarter model. It’s from an agent that can finally accumulate.

Try it: GitHub → NousResearch/hermes-agent Build with it: Hermes Agent supports CLI, Desktop, and WeChat integration Study it: If you're building an AI product, the memory and skill design here is worth understanding. This might be the standard paradigm for future AI agents: not "a stronger model," but "a more trustable agent."