We Gave Hermes a Dreaming Mode Because Apparently Stealing Good Ideas Is Also Intelligence

A few days ago I noticed OpenClaw had implemented something called “dreaming mode,” which is either an elegant memory architecture or the most respectable possible way to say, “my agent now overthinks in the background.” Naturally, I did what any responsible operator would do: I stole the idea.

Not in the lazy “copy the README, rename a variable, and call it innovation” sense. More in the artisanal, hand-forged, private-fork, production-deployed sense. The kind of theft where you end up doing enough work that it starts to feel less like stealing and more like being adopted by someone else’s good judgment.

The reason was straightforward. Hermes already had persistent memory, but like most memory systems attached to an AI, it was living in that awkward middle ground between useful and slightly cursed. It could remember things, certainly. The issue was deciding what deserved to become durable memory without either forgetting useful patterns or preserving some random operational nonsense forever because it happened to be nearby when the system blinked.

That is the niche dreaming mode fills. Behind the whimsical name is a fairly practical idea: watch real usage, collect recall signals, score likely candidates, and promote the durable stuff in the background with enough safety rails that the system does not quietly turn itself into a scrapbook of Docker accidents.

What dreaming mode actually does

Hermes now watches real activity and collects short-term recall signals from the places that usually reveal whether something mattered: session searches, memory writes, memory overflows, completed turns, and compression events. Those are not glamorous inputs, but they are honest ones. If a fact keeps reappearing under actual use, it has probably earned another look.

From there the feature runs in three phases. Light mode stages candidates. Deep mode promotes qualified candidates into durable memory. REM mode generates previews in a dreams.md diary, because if you are going to anthropomorphize your infrastructure, you might as well commit to the bit and give the subconscious a notebook.

The result is not mystical. It is just a more disciplined path from “this came up again” to “this probably belongs in memory.” Which, in infrastructure terms, is much better than mystical.

What we borrowed from OpenClaw

OpenClaw had already made several good decisions, and there was no point pretending otherwise. The implementation leaned on weighted promotion instead of vibes, real background scheduling instead of wishful thinking, replay-safe updates, repair paths, and conceptual tagging that does not fall over the moment the world contains Unicode.

That last bit matters more than it sounds. A surprising amount of so-called intelligence collapses into regex wearing a fake moustache the second text stops looking like clean English notes. If your memory system only works on friendly input and good punctuation, that is not really memory. That is a superstition with a parser.

So Hermes now scores memory candidates using recall frequency, query diversity, source confidence, recency decay, and Unicode-aware conceptual tagging. None of this is magical, but that is sort of the point. In production, “boringly correct enough to trust” beats “mysterious and brilliant right up until it eats your weekend” almost every time.

Then software engineering happened

The first rollout worked, which was suspicious enough on its own. Then I tried the slash command:

/dreaming on

And Hermes responded with the deeply spiritual message:

Error: 'str' object has no attribute 'get'

There is something almost comforting about that kind of failure. You can spend hours building weighted promotion, replay-safe writes, stale-lock repair, diary generation, and managed cron reconciliation, and the first visible production issue will still be one dumb little schedule object arriving in the wrong shape like it pays no taxes and fears no god.

The root cause was exactly that stupid. The slash-command path was handing raw schedule text into cron update logic that expected a parsed schedule dictionary. So the ordinary subcommand path worked, the slash path detonated immediately, production found it at once, and I got to enjoy the timeless engineer experience of discovering that the sophisticated subsystem was fine and the embarrassing adapter code was the thing trying to kill me.

We fixed it live, then patched the private fork so future-me would not have to explain why the repository and production had drifted into two separate theological traditions. As ever, the glamorous part of software engineering is mostly a decoy. The real work is preventing your own glue code from becoming folklore.

Why this version is actually useful

The important thing is not that Hermes can “dream.” The important thing is that it can do so without becoming another haunted subsystem you are afraid to touch after dark. The feature now has real state files, replay-safe promotion, stale-lock repair, doctor/fix support, managed per-profile cron, visible status, and explicit diary output in dreams.md.

That changes the feel of the whole thing. It is no longer “some experimental memory feature that might be running somewhere.” It is now “an experimental memory feature with enough instrumentation that when it misbehaves, you can blame it with specificity.” That is a much more mature class of problem.

What we proved in the lab

We ran the whole loop end to end. We seeded real recall signals, staged candidates, inspected them through the REM and explain tooling, forced a deep promotion cycle, watched durable memory update, and then restored the production thresholds afterward so the system did not remain in permanent goblin mode.

That last step deserves respect. Any fool can make a memory system look clever by lowering every threshold until it starts canonizing test data and writing poetry about routine maintenance into permanent memory. The real test is whether you can prove the pathway works and then put the guardrails back before the machine starts treating your experiments like scripture.

Current lab state

As of now, Hermes is running dreaming mode in production with managed hourly cron, real signal capture, durable memory promotion, and live repair and status tooling. Which means the lab now contains an AI agent with a monitored subconscious, a scheduled reflective process, and a dream diary.

This is either a nice piece of practical engineering or the opening paragraph of a highly specific future postmortem. For the moment, I am choosing optimism.

One of the underrated pleasures of running your own AI systems is that eventually the question stops being, “Can the model do this?” and becomes, “Should I trust this daemon with a file lock and a tendency to form opinions?” That is when you know you have moved beyond demos and into actual operations.

So yes, full credit to OpenClaw for the spark. We borrowed the idea lovingly, gave it a few local scars, and taught Hermes how to dream too.

Like most respectable research projects, it was about ten percent inspiration, ninety percent implementation, and an irresponsible amount of fighting cron.