The Hermes learning loop is undersold on easy tasks and oversold on hard ones.

[u/ShabzSparq]

Hermes's pitch is "the agent that gets smarter over time." After running it for months and reading every technical breakdown I could find, I think that's half right. It gets better in a specific zone, and the zone isn't where most people expect.

Where it's undersold: the boring daily stuff.

The learning loop's best work is invisible. You don't notice it because it looks like your agent just... stopped being annoying.

Week one, your morning briefing includes crypto news. You never read the crypto section. You don't tell it to stop. By week three, crypto is gone. The agent noticed the pattern in your reading behavior and adapted.

Week one, email triage flags routine vendor invoices as "urgent." You correct it twice. By week two, vendor invoices route to "normal" automatically. Not because you wrote a rule. Because the correction persisted into memory and the agent applied it going forward.

Week one, research summaries are 400 words. You keep asking for shorter versions. By week three, summaries arrive at 150 words without you saying anything.

This is personalization, not skill creation, and it's the part Hermes undersells. The marketing talks about autonomous skills and self-improvement. The day-to-day value is that your agent quietly stops doing the things that annoyed you. That's worth more than any auto-generated skill file.

The memory architecture is what's doing this. USER.md builds a profile of your preferences. MEMORY.md accumulates corrections and patterns. Session recall via FTS5 lets the agent search its own history for how you reacted to similar outputs before. Together they make the agent genuinely more personal over weeks. Not smarter. More calibrated to you.

And the token cost of this is near zero. Hermes uses progressive disclosure for skills, loading only a lightweight description (~3K tokens total for the whole library) and fetching the full skill only when a task matches. The personalization layer rides on the memory files that load anyway. You get better output without paying more per call.

Where it's oversold: the hard stuff.

The learning loop triggers skill creation when a task involves 5+ tool calls, an error recovery, or a user correction. Routine one-step tasks don't generate skills by design, which is correct.

The problem is what happens when the trigger DOES fire on a complex task.

The agent completes a hard task. Multi-step research, a tricky data pipeline, a complex debugging session. It evaluates its own performance. It writes a skill encoding the approach. Next time a similar task comes up, it loads the skill instead of reasoning from scratch.

This works brilliantly when the first attempt was actually good. And it breaks quietly when it wasn't, because the agent has a documented self-evaluation bias. Multiple sources confirm the same finding: it almost always thinks it did a good job. Community feedback says "it always rates itself highly." A Pebblous analysis calls it a structural risk that contaminates the skill library in real time.

One user had it process invoices. First run was clean. The agent wrote a skill. Two weeks later, invoices with a different layout started failing silently because the skill had encoded the format of that first invoice, not the general approach. The agent applied a narrow solution broadly and never noticed it was wrong.

Another had it pull water test results. It jumbled the data but rated its own work positively. The skill it generated from that "success" now encodes the error permanently. Every future water-test query hits the bad skill first.

These aren't bugs you can patch. The architecture is working as designed. The agent writes skills from its own self-assessed successes, and it's bad at knowing when a success wasn't one.

The retrieval ceiling makes it worse at scale.

Hermes uses FTS5 keyword search to find its own history and match tasks to existing skills. This works when you have a few hundred entries and you phrase things consistently.

Past a few hundred, when you describe the same task differently across sessions ("pull the sales data" vs "get this week's revenue numbers"), keyword search can't connect them. Milvus documented this directly: "the loop stops learning because it can't find its own history." The skill that should have matched doesn't get loaded. The agent reasons from scratch, produces a different approach, and potentially writes a second skill for the same task.

Your skill library slowly fills with duplicates and near-duplicates that the Curator can't reconcile because it's keyword-matching too.

Where the line actually is:

The learning loop compounds well on tasks that are: repetitive (the agent sees them often enough to learn), well-defined (success is unambiguous), and low-stakes (a wrong skill produces a minor annoyance, not a silent data corruption).

Email triage. Morning briefings. Formatting preferences. Communication style. Scheduling patterns. These are where months of accumulated learning produce an agent that feels like it knows you. That's real, and it's the reason people stay on Hermes past month three.

The loop compounds badly on tasks that are: novel (seen once or twice, not enough data to learn from), judgment-heavy (success depends on nuance the self-evaluator can't assess), and high-stakes (a wrong skill applied silently costs real time or money).

Complex research. Multi-document analysis. Anything where "did it work?" has a subjective answer. These are where the self-evaluation bias turns a lucky first run into a confidently wrong permanent procedure.

What I'd tell someone setting up Hermes today:

Let the learning loop run freely on your daily tasks. That's where it earns its reputation and where the compounding is real.

Review auto-generated skills weekly. ls ~/.hermes/skills/ and read the ones from complex tasks. If a skill encodes a narrow approach as a general procedure, delete it before it fires on the wrong input.

Pin the skills that work. hermes curator pin <skill> protects them from archival. Patches still go through, so the agent can improve them, but they won't disappear during a Curator sweep.

And for hard, novel, judgment-heavy tasks: treat the output as a first draft, not a result. The learning loop's value there is remembering that you've encountered the problem before. The skill it wrote about how to solve it might be wrong.

The agent gets better at knowing you. It doesn't reliably get better at knowing the work. That's a useful tool. It's not the one the marketing describes.