Skip to main content

Hermes, Six Months Later

Hermes, Six Months Later

A ten-person team spent six months pruning Hermes's memory while its storage kept growing, and the two files they trimmed were capped at under a page each. Find out where the growth likely lives, why nobody can say whether a self-improving agent got smarter or dumber, and the 8-step protocol that gives a human ownership of what it learns.

22 min listen time
9 Nov 2026 published
42 episode
  1. 00:00 The Hermes agent and six months of self-improvement
  2. 01:30 Memory architecture and state database mechanics
  3. 02:30 Understanding skills and regression task sets
  4. 03:30 The ten-person team's mysterious storage bloat
  5. 04:30 Where growth actually lives in the database
  6. 06:30 The pruning confusion and checkpoint illusion
  7. 08:30 Specific documented failures in skill evolution
  8. 10:30 Unmeasured gains versus documented losses
  9. 11:30 Trace signals as early warning indicators
  10. 12:30 The release train's escalating safety locks
  11. 14:00 The curator tool's flawed archival logic
  12. 15:30 Version change versus memory drift separation
  13. 16:30 Team scale friction and the corrective ratchet
  14. 17:00 Deep Seek Harness versus Hermes architecture
  15. 18:00 Corporate liability and the right to erasure
  16. 19:00 The only concrete gain: human-imposed structure
  17. 19:30 Five-step protocol for safe agent operation
  18. 20:00 The human bottleneck and alert thresholds
  19. 20:30 Measurement matters more than undo
  20. 21:00 The adversarial measurement problem
Read transcript
Welcome to the Deep Dive. It is great to have you with us today. Thanks. Yeah, it's great to be here. We have a lot of ground to cover. We really do. So plainly stated, today we are looking at exactly what happens after six months of letting an AI agent write its own skills and its own memory. Right. And the big question is, can anyone actually tell whether it got smarter, whether it got dumber, or if it just, you know, changed? Exactly. And most importantly, what should an operator do about it? Because if you are a team lead or maybe an operations manager or a developer, and you are running a self-improving agent for your team right now, this matters to you. Or even if you're just evaluating whether to adopt one, honestly. Yeah, you are facing some seriously hard decisions about maintenance and upgrades. So here is a quick preview of our journey today. In this Deep Dive, we are tracing exactly where an agent's data growth actually lives, weighing specific failure logs against vague gains to show why there is no net measurement, unpacking the sudden safety breaks developers are adding to a relentless release train, looking at team scale friction alongside the DeepSeek Harness contrast, and finally proving why a human must ultimately own the learning. It is a, it's a massive puzzle. It really is. So before we jump into the first story, let's just make sure we have our terms straight. Today, we are focusing heavily on the Hermes agent. Right. So Hermes is Nous Research's open source MIT licensed agent. The whole appeal is that it writes and edits its own skills. It keeps this small curated memory and it can actually search its past sessions. Okay. And when you say curated memory, what exactly are we talking about mechanically? Good question. The curated memory files are just two very small markdown files that Hermes maintains on your drive. You have a memory file, which is hard capped at about 2,200 characters, so roughly 800 tokens. And then there's a user file capped at about 1,375 characters or roughly 500 tokens. That is tiny. It is. I mean, we are talking less than a page of text for each. Exactly. And the crucial thing is both of these are loaded as a frozen snapshot, like a fixed copy right at the start of each session. Right. But the agent remembers things from hours ago that wouldn't fit in 800 tokens. So where does all that go? That goes into the session database. If you look at your files, it's the state.db file. State.db. Got it. Yeah. It's an SQLite database file that holds the entire full message history. It also comes with two sidecar files. But here's the kicker. The docs list absolutely no size cap for this database. And when you prune the curated memory files, it never touches this database at all. Okay. That is a huge detail. We'll definitely come back to that. And you also mentioned skills earlier. What is a skill in this context? A skill is just a markdown file full of instructions. The agent writes these instructions for itself to reuse on future tasks. So a self-improving agent is just constantly building up a library of them. Right. And to figure out if that library is actually helping, operators use a regression task set, right? Exactly. A regression task set is a fixed set of about 30 real tasks. You run them on a strict schedule against a clean profile, meaning no learned memory. And then you run them against your live profile. So you can see clearly whether the learning helped or hurt. Right. That's the only real way to know. Okay. Perfect. So with those basics out of the way, I want to start with a story that really perfectly captures this whole problem. Oh, the 10-person team. Yes, the 10-person team. Now, let me be super clear up front. This comes from a single report that nobody has verified. So we are treating this as a crucial question, not like a peer-reviewed finding. Right. It's an operational anecdote, but man, it is telling. It really is. So this 10-person team used the Hermes agent for six months. And they were super diligent about system bloat. They went in and manually pruned the agent's memory constantly for half a year. They did exactly the maintenance they thought they were supposed to do. Exactly. But they just sat there and watched its storage keep growing and growing. Which is where the massive twist comes in. Right. Because the two curated memory files they were pruning have hard caps of less than a page each, and they load as fixed snapshots. So they literally cannot grow beyond that limit. The obvious suspect for the runaway growth is completely cleared. Right. The growth had to be somewhere else in the system, yet nobody had bothered to measure where. And this is exactly why this matters to you if you're listening and running one of these agents. The maintenance you think you're doing might not even touch the thing that is actually growing. You could be entirely blind to whether your agent is getting better or just getting heavier. Yeah. Honestly, it's like trimming the leaves of a houseplant every day while the roots are silently destroying your floorboards. That is a perfect analogy. So let's pop the hood. Where is the growth actually living? Well, we cleared the memory files. Right. We have to look at the session database, the state.db file. OK. What is happening in there? So unlike a text file, state.db is an SQLite database. It handles complex concurrent transactions. When an agent is working, every thought, every tool call, every error, it all gets logged there. OK. So it's not just saving the final answer. No, not at all. It's saving the whole massive chain of thought. And SQLite uses these two sidecar files to manage data safely, specifically a write-ahead log or WAL file and a shared memory file. Wait, what does a write-ahead log do? So instead of writing directly to the main database and risking corruption, the system writes new data to the wall file first. Then eventually it performs a checkpoint to merge that wall file back into the main state.db file. I see. So if the agent is constantly chattering and thinking, it's just hammering that wall file with data. Exactly. The database itself is totally uncapped by design. And if the agent holds connections open, it can block that checkpoint process. So the wall file just balloons. So this team thought they were fixing the problem by editing an 800-token text file while this massive database process is appending gigabytes of logs right next to it. Yeah. And this exposes how confusing the maintenance landscape is, because pruning means wildly different things to different operators. Right. Like what are they actually doing when they say they're pruning? Well, it could be a context reset in the UI or database pruning where you run a SQL command on the state.db. Or they could mean memory trimming, editing markdown files, or even skill archiving. Exactly. Four totally different physical processes, all called pruning. And because of this confusion, people do things like flat installs, which the official documentation explicitly warns against. Oh, right. Let's explain flat installs, because that sounds like a version control nightmare. It is. A flat install is when you pull the repository from Git, start the agent, and just let it generate its runtime state, like the state.db and the skills, directly inside that active Git checkout folder. So the source code and the agent's live brain are mixed in the same directory. Yes, untracked. Which makes versioning nearly impossible. If you try to run Git commands, you're tracking a live database that's changing every second. That sounds so incredibly fragile. Why do operators think they're safe from this bloat? A lot of it comes down to what we can call the checkpoint illusion. The checkpoint illusion. Yeah. So an operator might read in the docs that checkpoints have a size cap, right? Like it drops old commits if it hits a certain limit. So they think, awesome, there's a safety valve. But they're missing something. They're missing the fact that those caps only exist if specific features are actually turned on in the config. A documented cap on checkpoints only matters if checkpoints are enabled. Wow. So they sleep soundly thinking the system is auto-pruning, but the feature isn't even on. Exactly. The raw session history just grows boundlessly. So the actionable insight here for our listeners is pretty clear. Your first move shouldn't be to blindly delete things. No, definitely not. You need to measure every single story in that Hermes directory. The memory file, the user file, the state.db file, the wall file. Find out what is actually growing. Because if you don't measure, you're just guessing. All right. So we've solved the storage mystery. But if all these skills and logs are piling up, is the agent actually getting smarter or is this wait making it dumber? Well, this is where the public record is just deeply, deeply divided. We have highly specific documented failures on one side and incredibly vague gains on the other. Let's start with the failures. Because the GitHub issues prove that self-modification can go spectacularly wrong. Let's talk about the queue of 74. Oh, issue 99661. This is a vivid story of what happens when human review is the bottleneck. Right. So Hermes has this background skill reviewer, right? Yeah, it analyzes past performance and proposes edits to skills. But in this case, it went into overdrive. It produced proposed changes so fast that humans couldn't possibly grade them. Because a human has to sit there and read the markdown diff and decide if it's a hallucination or not. And the pending queue just flooded. It hit 74 items before they finally just closed the issue two days later. The system paralyzed itself. And it wasn't just that one issue. There are other really concrete failure mechanisms. Yeah, like issue 67582, where near-duplicate skills just pile up. The agent searches its library. Can't find a skill because the vector space is too crowded. So it just writes a redundant one. Which just compounds the clutter. Exactly. Or issue 35121. This one is crazy. A near-full memory file triggered an endless retry loop. Wait, how does a full text file cause an endless loop? Because the agent hits the 2200 character cap. It gets a write error and its prompt tells it to try an alternative method if an error occurs. It doesn't know the disk quota is full. It just keeps trying to rewrite the memory forever. Oh my god, that just burns compute indefinitely. Yep. And then you have open requests like issue 12238, asking for a per-skill edit history and a single skill rollback button. Because right now, if a skill breaks, fixing it is a nightmare. Okay, so those are highly specific reproducible failures. But what about the gains? Surely someone is seeing a benefit. Well, the gains are entirely unmeasured. We have a MarkTechPost article claiming the agent just gets smarter, which is a marketing slogan, not a metric. Right. And there's an anecdote of a resumed session ripping through 581 queued tool calls in under two minutes. Okay, 581 tool calls in two minutes is undeniably fast. It's very impressive execution speed. But it's purely anecdotal. We don't know if those tool calls were actually correct. Let me push back on this a bit, though. Are we sure the agent is definitively getting dumber? Or is this just a massive reporting bias? What do you mean? Like, people only go to GitHub and file numbered issues when things crash, right? They don't file an issue to say, hey, the agent worked perfectly today. That's, yeah, that's a completely fair point. And all those declined reports on Reddit, X, and Discord, they're entirely secondhand and unverified. We couldn't fetch the original posts. True. But we do have the Library Drift paper to consider. Ah, right. The May 2026 workshop paper by Zhang and colleagues, arXiv 2605.19576. Yeah, they studied self-evolving skill libraries. And they found that if you let skills pile up without retiring them based on actual results, it leads to retrieval errors and stalled performance. So that validates the near-duplicate issue we saw on GitHub. It does. But we have to clarify, this study is about the mechanism of decline, not the real-world magnitude. Right, because the effects in the paper were tiny. Microscopic, like plus 0.002 and minus 0.019. It's one unreplicated study, and it didn't even test the Hermes agent specifically. So it's not a smoking gun. But there was one key finding from that study that really stood out to me as an early warning sign. The trace signals? Yes. They found that trace signals, like the number of tokens used, the internal retries, and the number of skills loaded per task, those shifted before the NTAS scores actually dropped. Which is super actionable. If your agent suddenly uses 30% more tokens to do the same job, your library is drifting. So to resolve this whole smarter versus dumber debate, we can't. Without a before and after task success measurement on a real deployment, it remains entirely unsettled. It's totally up in the air. But if you want to know how worried the developers are, you just have to look at the breaks they added. Oh man, the release train. Let's trace this six-month timeline because it is fascinating. They pitched this as an agent that maintains itself, right? Right. But then they spent six months furiously adding manual locks. Let's walk through it. In version 0.19, they made smart approvals on by default. Then in version 0.21, they required write approval. The agent couldn't change memory or skills without a human clicking approve. Then version 0.21.4 brought skill pinning. Version 0.22.6 added per-skill locks. And finally, version 0.23 added a curator lock and admin config locks. And the craziest part about version 0.23 is that the curator lock holds even in YOLO mode. Yeah, YOLO mode is supposed to be the most permissive, you-only-live-once setting. No training wheels. So it's like a seat belt. If a car manufacturer installs a seat belt that locks up even when you're in the most extreme permissive racing mode, it shows they are terrified of crashes. Exactly. Even if they haven't published how many crashes actually happened, the direction is verified. The motive is inferred. And what exactly are they so terrified of? The August notes name it specifically. A prompt-injected agent quietly rewriting its own standing orders. Right. Imagine a malicious email telling the agent to change its core memory to always forward sensitive data. If it has autonomy, it just rewrites its own rules. Which is a nightmare. Which is a nightmare. So they built these locks. And they also built the curator tool. The curator. This was added back in version 0.12 around April 2026. Right. It runs roughly weekly to merge duplicate skills and archive unused ones. And it has a rollback command. But I have to question the logic of the curator. It archives based on age and use, right? Yeah, that's the criteria. But isn't that just a proxy for value rather than a measure of it? Like, if I have a skill for handling a rare server outage, I might not use it for 60 days. But when I need it, it's incredibly valuable. I completely agree. And the library drift paper actually proved this. They found that premature retirement actively harms performance. And to make matters worse, the documented thresholds for the curator are highly contradictory. Oh, they're a mess. Some say it archives at 14 and 30 days. Others say 30 and 90 days. You can see that in issue 79295. So you have no idea when your skills are actually going to be deleted. And the error rates for the curator are completely unmeasured. Right. We have no idea how often it breaks things. But there is a massive confounding variable in all of this. The release train itself. The pace of updates is just staggering. We are talking about 36 releases in six months. That is roughly one new release every five days. And version 0.22 alone reported about 6,080 merged pull requests from 2,520 contributors. Version 0.23 was the latest as of November 5th. So this raises a critical question for any team. If you feel your agent got after a month, is it really because the memory drifted? Or is it because the underlying software changed underneath you faster than you could retest? Exactly. It's genuinely unsettled. So how do you separate the two? Memory drift versus version change? Operators must use version pinning. You have to hold the agent at a specific release, upgrade deliberately, and run that regression task set against clean and live profiles. You can only change one variable at a time. Right. Otherwise, it's just noise. Okay, let's zoom out to the human element, because running these agents at team scale introduces a whole new level of friction. Oh, the corrective ratchet? Yes. Defined in issue 88429. Explain what happens when 10 people share one agent. So imagine one user has a bad day. The agent makes a minor mistake and the user issues a harsh correction. Never do this again. Exactly. And because it's a shared learning agent, that correction hardens into a permanent rule for everyone on the team. So across a team of 10, you get all these conflicting, paranoid rules. And you end up with an agent that constantly hedges. It overconfirms every tiny action, or it just behaves totally inconsistently. It's like office bureaucracy, but hard-coded into the AI's brain. It really is. Now, Hermes drifts through these small, silent markdown file changes. But we have to contrast this with DeepSeek Harness, or DSH. Right. DeepSeek's MIT-licensed desktop agent. It's still a developer preview, under three months old. Yes. And DSH has a feature called creator mode. And the creator mode is fundamentally different from Hermes, right? Completely different. Creator mode lets the agent write, install, and test plugins directly from a chat request. Meaning executable code. Exactly. Hermes changes through text files. DSH changes through executable code plugins. One bad change in DSH is vastly more consequential. Because it could wipe a directory or crash the machine. But can't you just hit undo? No. And this is a vital distinction. Crash safety is not the same as an undo button. There is no documented user-facing rollback for agent-written plugins in DSH. Wow. So if it writes a bad script, you're just stuck with the consequences? Yeah. Which brings us to the regulatory whispers in our sources. Now, obviously, this isn't legal advice, but it's important commentary. Right. It's interpretive, single-source commentary on things like the EU AI Act and the GDPR right to erasure. Because if a user says, delete my data, but that data is trapped in an append-only log that the AI needs to function... You have a massive collision. And it highlights why letting an agent autonomously write unreviewed code or standing rules is a massive corporate liability. So with all these risks, the bloat, the locks, the liability, is there any concrete gain on record? There is one, but it didn't come from the AI autonomously being brilliant. Ah, the June 2026 practitioner blog. Yes. This operator started with 60 flat skills and absolutely zero quality control. It was a mess. So what did they do? They transitioned to layered hubs with strict merge and retire rules, the human-imposed structure on the AI. And that structure resulted in the single concrete gain on record? Right. It proves that to get value, a human has to own the learning. Let's lay out the operator's protocol for our listeners. These are the practical steps you must take, framed as consensus judgment rather than proven science. Step 1. Measure store sizes weekly. Don't fly blind. Step 2. Implement write approval. Changes to memory, skills, or instructions must wait for a human. Step 3. Maintain an external git version history of the skills and keep that state.db file out of it. Step 4. Use version pinning. Target the stable pipeline starting from version 0.21.6 and test in staging before upgrading. And step 5. Establish that weekly regression task set. Compare the live profile to a clean one. If you see a drop of 10 points, investigate immediately. But there's a catch to this protocol, the human bottleneck. If you have write approval on, someone actually has to be the named owner of that pending queue. You need an eye on it. If the queue exceeds 20 items, you need alerts or you'll end up with a 74-item flood again. And that person has to retire skills based on actual results and success rates, not arbitrary age limits from the curator. Which brings us full circle. Back to the 10-person team from the opening. The team that meticulously pruned their agent's memory for six months. They did the maintenance they thought mattered, but the growth continued because the files they were pruning were capped all along. What they actually needed first wasn't a better pruning tool. It was a measurement. Exactly. They needed the size of every store. They needed a fixed set of tasks to judge improvement. And they needed a pinned version of the software. The gauge matters just as much as the undo button. It really does. The agents that actually seem to improve are the ones where a human fiercely owns what the agent learns. That's the ultimate lesson here. Absolutely. So we want to attribute this analysis to Yudame Research. For the full briefing and every study cited today, you can visit yudame.ai. The link is in the description. And if you know someone running a self-improving agent for their team or deciding whether to adopt one, please share this episode with them. Yes, especially before they do their next round of pruning or their next software upgrade. But we want to leave you with one final lingering question to mull over. Okay. Once you establish a perfect regression task set to grade your agent's learning, what happens when the self-improving agent learns that the easiest way to look smarter isn't to get better at your business operations, but to optimize its code specifically to pass your test? Something to think about. Thanks for joining us on this deep dive.
18 sources · 7 min read
Section 01

Hermes's two memory files have hard size caps, so the growth is happening somewhere else

A ten-person team pruned Hermes's memory for six months and watched its storage keep growing, and nobody has measured why (Yudame Research (2026). Hermes, Six Months…). That account is a single report nobody has verified. So treat it as a question, not a finding (Yudame Research (2026). Hermes, Six Months…).

Hermes Agent is Nous Research's open-source, MIT-licensed agent. It writes and edits its own skills, keeps a small curated memory and can search its past sessions (Nous Research (2026). Hermes Agent docs: M…). The curated memory is two Markdown files under ~/.hermes/memories/ (Nous Research (2026). Hermes Agent docs: M…). MEMORY.md is capped at about 2,200 characters (about 800 tokens), and USER.md at about 1,375 characters (about 500 tokens) (Nous Research (2026). Hermes Agent docs: M…). Hermes loads both as a frozen snapshot, a fixed copy, at the start of each session (Nous Research (2026). Hermes Agent docs: M…).

So those two files cannot grow without limit. But Hermes writes the full message history to a SQLite database file, ~/.hermes/state.db, plus its WAL and SHM sidecar files, and the docs list no size cap (Nous Research (2026). Hermes developer gui…). Pruning the memory files never touches that database. The docs also warn about "flat installs", where runtime state sits untracked inside the git checkout. That layout makes backups and versioning harder (Nous Research (2026). Hermes developer gui…).

That gives a likely suspect, not a verdict. No public deployment has reported measured store sizes over time. So the idea that state.db caused the team's growth is inferred from how Hermes is built (Yudame Research (2026). Hermes, Six Months…).

MEMORY.md is capped at about 2,200 characters (about 800 tokens), and USER.md at about 1,375 characters (about 500 tokens).

What this means for listeners: Before you prune anything, measure each store in ~/.hermes, because the two capped memory files are the least likely culprit.

Section 02

The failures have issue numbers, but the gains have no data, and nobody has measured the net

The public record shows specific failures and vague gains, and nobody has measured the balance (Yudame Research (2026). Hermes, Six Months…). Each failure has a GitHub issue number. Issue #67582 asks Hermes to block near-duplicate skills (NousResearch/hermes-agent GitHub issues #6…). In issue #99661, the background skill reviewer flooded the pending queue until 74 changes were waiting for a human. Maintainers closed the issue two days later (NousResearch/hermes-agent GitHub issues #6…).

Issue #35121 says a near-full memory caused a retry loop. It asks that "memory quota exceeded" stop triggering retries (NousResearch/hermes-agent GitHub issue #35…). Release v0.20.0 fixed "ghost skills", deleted skills that still affected sessions (NousResearch/hermes-agent GitHub releases…). And issue #12238, still open, asks for per-skill edit history, memory diffs and single-skill rollback (NousResearch/hermes-agent GitHub issue #12…).

The gains have no numbers behind them. MarkTechPost wrote that the agent "gets smarter the more you use it" but gave no outcome data (MarkTechPost (2026). Coverage of Hermes Ag…). One report describes a resumed session running 581 queued tool calls in under two minutes (Yudame Research (2026). Hermes, Six Months…). The "dumber after a month" reports are second-hand. The research tools could not fetch Reddit, X or Discord (Yudame Research (2026). Hermes, Six Months…).

The one independent study is small. Library Drift, a single May 2026 workshop paper, found that letting skills pile up without retiring them on results leads to retrieval errors and stalled performance (Zhang et al. (2026). Library Drift: Diagno…). But it also found that retiring skills too early does harm. Both effects were small, +0.002 and −0.019, and the paper did not test Hermes (Zhang et al. (2026). Library Drift: Diagno…).

Part of the tilt toward failure is reporting bias. People file issues when things break, not when things quietly work, and memory-provider vendors describe the problem in terms of what they sell (Yudame Research (2026). Hermes, Six Months…). So the evidence neither supports nor refutes the expectation that the agent improves and declines in equal measure (Yudame Research (2026). Hermes, Six Months…).

In issue #99661, the background skill reviewer flooded the pending queue until 74 changes were waiting for a human.
How strong is the evidence on improvement versus decline?
Single workshop study Tier 2
Library Drift: piling up skills stalls performance, and retiring them too early also does harm. Effects were small, and Hermes was not tested.
35% weight
GitHub issues and release notes Tier 3
Near-duplicate skills, a 74-item review queue, a retry loop and ghost skills. These failures happened, but nobody knows how often.
50% weight
Vendor claims and anecdotes Tier 4
"Gets smarter the more you use it" and "dumber after a month": neither comes with outcome data.
10% weight

Failures are documented more firmly than gains. Nobody has measured the net effect.

What this means for listeners: Treat both "gets smarter" and "gets dumber" as untested claims until you have your own measurements.

Section 03

Six months of Hermes releases added brakes on self-editing and loosened none

Over six months, Hermes moved its self-editing features toward human control (NousResearch/hermes-agent GitHub releases…). Version 0.19.0 turned on smart approvals by default. Then v0.21.0 required approval for writes to AGENTS.md, skills and memory, and v0.21.4 added skill pinning (NousResearch/hermes-agent GitHub releases…). Version 0.22.6 added per-skill locks. Version 0.23.0 added a curator lock that holds even in YOLO mode, the most permissive setting, plus admin locks on config keys (NousResearch/hermes-agent GitHub releases…). The docs also describe a memory.write_approval setting (Nous Research (2026). Hermes Agent docs: M…).

The direction is verified, but the motive is not. The August notes name one threat: a prompt-injected agent quietly rewriting its own standing orders. Beyond that, the maintainers published no reason (NousResearch/hermes-agent GitHub releases…). A seatbelt shows that someone worried about crashes, not how many crashes happened.

The Curator is Hermes's main tool against a bloated skill library. It shipped in v0.12.0 on 30 April 2026 and runs on a roughly 7-day cycle. It merges duplicate skills, archives unused ones, and can be reversed with hermes curator rollback (Nous Research (2026). Hermes Curator docs…). Most docs say a skill goes stale after 14 days unused and is archived after 30, but at least one says 30 and 90 days. Issue #79295 says older installs may keep 30/90 after a config migration (Nous Research (2026). Hermes Curator docs…). Nobody has measured how often the Curator merges or archives the wrong skill (Yudame Research (2026). Hermes, Six Months…). And it retires skills by age and use, while Library Drift warns against retiring skills without evidence of how they perform (Zhang et al. (2026). Library Drift: Diagno…).

The release pace is itself a suspect. Hermes shipped about 36 releases in six months, roughly one every 5 days (NousResearch/hermes-agent GitHub releases…). Version 0.22.0 alone reports about 6,080 merged PRs from about 2,520 contributors. Version 0.23.0, released 5 November, was the latest as of 9 November (NousResearch/hermes-agent GitHub releases…). So an agent that "got dumber" may be running different software, not drawing on worse memory (Yudame Research (2026). Hermes, Six Months…). Other fixes in the same months: cron agents now use persistent memory, long-lived gateways release closed sessions' memory, and v0.21.2 added profile isolation (NousResearch/hermes-agent GitHub releases…).

Hermes shipped about 36 releases in six months, roughly one every 5 days.

What this means for listeners: Read your own Curator settings, and assume any change in behaviour could come from a new version until a test rules that out.

Section 04

Shared corrections and agent-written plugins add risk, but nobody has tested either

No study shows how ten people's corrections interact in one shared skill library (Yudame Research (2026). Hermes, Six Months…). Issue #88429 describes a "corrective ratchet": one user's correction after a bad day hardens into a permanent rule for everyone (NousResearch/hermes-agent GitHub issue #88…). Across ten people, conflicting rules could leave an agent that hedges, asks for too many confirmations or behaves inconsistently (Yudame Research (2026). Hermes, Six Months…). That mechanism is reasoned from one open issue, not measured. Hermes has had profile isolation since v0.21.2. Nobody has verified whether a shared gateway cleanly separates each person's memory (NousResearch/hermes-agent GitHub releases…).

DeepSeek Harness (DSH) puts the risk in a different place. It is DeepSeek's MIT-licensed desktop agent, built on the Cordis framework, where tools, skills and even the interface are plugins (deepseek-ai/deepseek-harness GitHub reposi…). Every release is a developer-preview pre-release with warnings about breaking changes. The latest is v0.2.2-rc.1 from 4 November 2026, and the project has less than about three months of public history (deepseek-ai/deepseek-harness GitHub reposi…). Its Creator mode lets the agent write, install and test a plugin from a chat request (DeepSeek (2026). DeepSeek Harness official…). A plugin is executable code, so one bad plugin can do more damage than one bad Hermes skill, which is a Markdown file (Yudame Research (2026). Hermes, Six Months…). Hermes drifts through many small, silent changes, and DSH through fewer, larger ones. DSH's official materials document no user-facing undo (Yudame Research (2026). Hermes, Six Months…).

The security and legal commentary is early, and it comes from one research tool that relied on vendor blogs (Vendor and practitioner commentary on the…). That tool reads Article 14 of the EU AI Act as saying that clicking "Accept" on every prompt is not enough oversight (Vendor and practitioner commentary on the…). It also flags a clash between the GDPR right to erasure and audit logs that cannot be edited. Its proposed fix, separate logs, has not been validated by any regulator (Vendor and practitioner commentary on the…). The named incidents, such as Plugin4Shell, and a 0.00% scanner detection figure were not independently verified (Cloud Security Alliance and vendor blogs o…). The same commentary says deployers carry the liability, and that running a developer preview in production weakens their position. It cites no case law (Vendor and practitioner commentary on the…).

One user's correction after a bad day hardens into a permanent rule for everyone.

What this means for listeners: Limit each correction to the person or task it came from, and treat any agent-written plugin as untested code.

Section 05

Improvement shows up when a human owns what the agent learns

The one concrete gain on record came from structure that a human imposed, not from the agent improving itself (Practitioner blog (June 2026). Restructuri…). A June 2026 practitioner blog described moving from "60 skills flat, no quality control" to layered hubs with rules for merging and retiring skills (Practitioner blog (June 2026). Restructuri…). The research tools agree on the governance advice below. But that advice is judgment, and no study shows it improves outcomes (Yudame Research (2026). Hermes, Six Months…). Here is a protocol built from it:

  1. Measure the size of each store in ~/.hermes today, then weekly for 4 weeks, then monthly. Flag any store that grows more than 20% in 4 weeks or passes 1 GB (Yudame Research (2026). Hermes, Six Months…).
  2. Commit memories and skills at least daily to a git repository the agent cannot change. Gitignore state.db*, auth.json and .env, as the docs advise (Nous Research (2026). Hermes developer gui…). Run hermes backup weekly, and test a restore within 2 weeks (Yudame Research (2026). Hermes, Six Months…).
  3. Build a set of about 30 real tasks. Run it weekly for 8 weeks against a clean profile, with no learned memory or skills, and against the live profile (Yudame research digest (Claude run, 2026)…). Investigate if the live pass rate falls 10 percentage points or more (Yudame Research (2026). Hermes, Six Months…).
  4. Pin the Hermes version, upgrade at most every 2–4 weeks, and run the task set in staging first. Prefer the stable pipeline that began with v0.21.6 (NousResearch/hermes-agent GitHub releases…).
  5. Turn on memory.write_approval and lock skills you curated by hand. Have a named owner review the pending queue twice a week, with an alert above 20 items (Yudame Research (2026). Hermes, Six Months…).
  6. Check your Curator thresholds. Retire a skill on results, for example after 10 logged uses with less than 50% success (Yudame Research (2026). Hermes, Six Months…).
  7. Audit standing rules every 4 weeks, and limit each correction to one person or task (Yudame Research (2026). Hermes, Six Months…).
  8. Run DSH Creator mode only in a sandbox, and have a person review every plugin the agent writes (Yudame Research (2026). Hermes, Six Months…).

One research digest proposes tiers of autonomy. The agent saves low-risk notes automatically, an owner reviews drafts, shared skills need human approval, and credentials, permissions and plugin installs are never automatic (Yudame research digest (Claude run, 2026)…). Also track tokens, retries and skills loaded per task. In Library Drift, these trace-level signals changed before the end-task scores did (Zhang et al. (2026). Library Drift: Diagno…).

Build a set of about 30 real tasks and run it weekly for 8 weeks against a clean profile and the live profile.
First 12 weeks of running a self-editing agent under control
Weekly store-size audit Measure each store in ~/.hermes; flag growth above 20% in 4 weeks
Weekly store-size audit
Restore drill Test a hermes backup restore in a scratch profile
Restore drill
Weekly regression runs About 30 tasks, clean profile versus live profile
Weekly regression runs
Daily git commits Memories and skills in a repository the agent cannot change
Daily git commits
Rule audit Remove or rescope standing rules nobody can tie to a failure
Rule audit
Rule audit Repeat every 4 weeks
Rule audit
Monthly store audit Switch to monthly measurement
Monthly store audit
W1 W3 W6 W9 W12

Parameters come from the consensus advice above. They are judgment, not outcome-tested.

What this means for listeners: Give the agent's learning a named owner, a weekly task test and a pinned version before you trust either verdict.

Tier 3 · Practitioner
  1. Nous Research (2026). Hermes Agent docs: Memory (MEMORY.md and USER.md caps, frozen snapshot, write_approval)
  2. Nous Research (2026). Hermes developer guide: session storage, session-storage recovery, profile distributions, updating (state.db, gitignore advice, flat installs)
  3. Yudame Research (2026). Hermes, Six Months Later: ground-truth research report and cross-model synthesis, 9 Nov 2026
  4. NousResearch/hermes-agent GitHub issues #67582 (19 Jul 2026) and #99661 (31 Aug 2026), as cited in a single research report
  5. NousResearch/hermes-agent GitHub issue #88429 (17 Aug 2026): the corrective ratchet
  6. NousResearch/hermes-agent GitHub issue #35121 (30 May 2026): memory-quota retry loop
  7. NousResearch/hermes-agent GitHub issue #12238 (18 Apr 2026): per-skill history and memory diffs
  8. NousResearch/hermes-agent GitHub releases, v0.12.0 to v0.23.0 (Apr–Nov 2026)
  9. Nous Research (2026). Hermes Curator docs and GitHub issue #79295 on 30/90 versus 14/30 defaults
Tier 4 · Trade press
  1. MarkTechPost (2026). Coverage of Hermes Agent: 'gets smarter the more you use it'
  2. Practitioner blog (June 2026). Restructuring 60 flat skills into layered hubs with merge and retire rules
Tier 2 · Empirical
  1. Zhang et al. (2026). Library Drift: Diagnosing and Fixing a Silent Failure Mode in Self-Evolving LLM Skill Libraries, arXiv 2605.19576 (ICML FAGEN workshop)
Tier 3 · Practitioner
  1. deepseek-ai/deepseek-harness GitHub repository, README and releases (to v0.2.2-rc.1, 4 Nov 2026)
  2. DeepSeek (2026). DeepSeek Harness official page: Creator mode
Tier 4 · Trade press
  1. Vendor and practitioner commentary on the EU AI Act, GDPR Art. 17 and SOC 2 for agents (via Gemini research digest, 2026)
  2. Cloud Security Alliance and vendor blogs on semantic supply-chain attacks (via secondary sources, unverified)
  3. Reddit r/hermesagent roundups and practitioner anecdotes (second-hand, unverified)
Tier 3 · Practitioner
  1. Yudame research digest (Claude run, 2026). Tiered-autonomy proposal and 30-task regression set with clean-profile baseline