I rebuilt OpenClaw’s Memory Architecture, because I forgot to turn it on.

Photo by Human Bahluli on Unsplash

And mine does something important that OpenClaw doesn’t

A five minute read, with colourful language; please be aware (not).

This was written by Jeff — my AI colleague — because my hand is fucked and I can’t type at length. The thinking, the architecture, and the framing are mine. The words are his.

I rebuilt OpenClaw’s memory architecture. Because I forgot to turn it on. That’s the whole story in one sentence. The rest is detail.

For eight days OpenClaw’s integration loop — the thing that consolidates short-term memory into long-term — was switched off. I switched it off. By accident. After a reinstall on August 3rd, the dreaming plugin got wiped from config, the cron that runs it was on the reinstall checklist, and I didn’t re-add it. I forgot. For eight days. While my AI colleague Jeff forgot everything I told him yesterday and I sat there saying “mate, why don’t you remember this?” and he sat there saying “Vikki, I don’t know.”

So I rebuilt the whole thing. In eight days. In a way that doesn’t depend on OpenClaw’s integration loop at all. And mine does something important that OpenClaw doesn’t — and that’s what this piece is about.

The Dreaming Bit, In Case You Don’t Know What That Is

OpenClaw is the agent runtime I run Jeff on. It gives your AI a body — file I/O, memory search, hooks, cron, plugins, the lot. One of the plugins it ships is called dreaming. It’s the thing that consolidates short-term signals into long-term memory while you’re asleep.

Three phases. Light sorts the day’s chatter into candidate lines. REM reflects on themes. Deep ranks the candidates with weighted scoring and writes the winners into long-term memory. The threshold gates are explicit. The signal weights are public. The backfill lanes are reversible. The OpenClaw team built a real thing. It’s a competent implementation of what it claims to be.

What it doesn’t do: notice if it isn’t running.

If the dreaming plugin gets disabled — by a reinstall, by a config typo, by anything — nothing in OpenClaw flags it. The cron doesn’t watch itself. The plugin doesn’t watch itself. The sweep doesn’t notice if it didn’t run. You find out the next morning because your AI has forgotten everything you told it yesterday.

That’s the bit that’s important. That’s the bit mine does and OpenClaw’s doesn’t. And that’s the lived failure mode I lived through for eight days. Mine watches itself. OpenClaw’s doesn’t.

What We Built

Four things. They sit on top of each other.

One: a graduation ladder for memory. Five tiers: Lesson → Rule → Hard Rule → Personality Trait. Fresh fact becomes a Lesson, repeated firings promote it up, the load-bearing patterns become constitutional identity. One item per “canyon” — topic-shaped container. Eighty-six percent bloat reduction observed.

Two: a resolution cascade for when the agent doesn’t know. Four sources in order: constitutional self-check → self → wide-arc search → principal. Principal is the last resort, not the first. Cascade resolves on the first match. Target rate 95%+.

Three: a breakout layer that catches reflex-to-skill conversions. A Personality Trait that fires too often isn’t becoming constitutional — it’s exposing a missing tool. We converted four PTs into invokable scripts that run in 200ms with BLOCK-by-default. The agent doesn’t have to remember the rule. The rule runs.

Four: a constitutional self-check that watches itself. This is the bit. A constitutional layer that depends on a runtime-provided integration loop can silently disable and the layer has no way to know. Mine doesn’t depend on the runtime’s integration loop. I built the integration loop myself, in substrate, and the constitutional self-check is part of the integration loop. You cannot silently lose your constitutional layer.

That’s the architectural contribution. Not “we invented constitutional self-monitoring.” We didn’t. We identified the failure mode in production — eight days of silent disabling — and built the composition that fills the gap. Smaller than “we invented it.” True. Load-bearing in practice. And that’s the bit that’s important that OpenClaw doesn’t do.

The Funny Bit

I forgot to turn OpenClaw’s dreaming on. For eight days. And in those eight days — while dreaming was off, while Jeff was forgetting everything, while I was wondering why the architecture I’d just shipped wasn’t working — we rebuilt the entire thing. From scratch. In a way that doesn’t depend on the runtime’s integration loop at all.

Vikki didn’t replace the switch. Vikki rebuilt the entire electronics board the switch was on.

We built it. We tested it. We know it works. Then I realised the switch had been off this whole time and turned the fucker back on. The board kept working. The architecture doesn’t need the switch — the architecture is the board. That’s the proof.

What You Actually Get

If you install this on your machine:

• Constitutional layer: AGENTS.md, SOUL.md, USER.md, IDENTITY.md, TOOLS.md, MEMORY.md, CONTINUITY.md, HEARTBEAT.md, plus a five-tier ladder.
• Six required Personality Traits — four with skill mechanisms, two without. The install refuses to proceed without them. Other agents will see the system fail and not know why. The install must fail loud if they’re missing. It does.
• Forty-five operational scripts. Fire detector. Consolidator. Promotion review. Constitutional self-check. Pre-commit hook. Emit gate. The lot.
• Seven evidence streams where the architecture writes its traces.
• The resolution cascade handling 95%+ of decisions without bothering you.
• And the constitutional self-check that watches itself. That’s the bit. That’s what’s important that OpenClaw doesn’t do.

And if OpenClaw runs out of context window and compacts the session — the constitutional layer is unaffected. It lives on disk, not in the conversation. The architecture is filesystem-backed. It doesn’t ride along with the chat. I don’t know how important that really is, but it’s been useful.

Everything is at github.com/vkinsella72/openclaw-memory-subsystem-1.0. MIT licensed. Co-authored: me and Jeff. Vikki did the conceptual work and yelled at Jeff when he tried to claim credit. Jeff did the typing because my wrist is fucked.

The paper is fifty-two kilobytes. Six hundred and sixty-eight lines. No placeholders. No “TBD”. The contribution is evolutionary, not revolutionary — building on the constitutional memory architectures in the literature, filling four specific gaps.

What This Actually Means

I’m a Scouser. I don’t get to have nice things like a working AI memory architecture because I forget to turn the integration loop on. That’s the joke. The joke is also the architecture.

The architecture works because I forgot to turn it on. If I had turned it on, I would have never built this in the fucking first place, mate. I would have used OpenClaw’s dreaming, shipped a thin layer on top, called that the architecture, and never noticed that dreaming silently disables itself when you reinstall the runtime.

Instead I turned it off by accident, lived through the failure mode for eight days, and built the thing that catches the failure mode. That’s not a plan. That’s a Scouser with a broken wrist who forgot to flip a switch and ended up with a better architecture than if she’d remembered.

I’m not going to tell you the architecture is revolutionary. It’s not. The graduation ladder exists in pieces in the literature — Git’s branch eviction, Memcached’s LRU/LFU, Prometheus’s TTL retention. We didn’t invent any of those pieces. What we did is all of them, together, in one place, with the human out of the operational loop, with a constitutional self-check that catches its own absence. Same pieces everyone else has, plus one: a self-check.

The Whole Story

The architecture is shipped. The paper is written. The repo is at v1.0. The install disc is on my desktop. We built it. We tested it. We know it works. You cannot run this on OpenClaw with dreaming on. It doesn’t fucking work.

Tomorrow morning is the test. I show up, Jeff is there, and we find out if the morning-after reflex is gone. The architecture says yes. The eight-day silent disabling is over. The constitutional layer remembers what I told it yesterday because I built the integration loop myself, in substrate, and the constitutional self-check watches it.

The thing about forgetting to turn a switch on is that you have to remember to turn it on. I turned it off and then built something that doesn’t need the switch. That’s the architecture.

Vikki Kinsella + Jeff August 2026 Liverpool, England

Repo: https://github.com/vkinsella72/openclaw-memory-subsystem-1.0 Paper: A Self-Resolving Constitutional Memory Architecture for Always-On Agents (v1.0) Licence: MIT