By version six, I had memory everywhere. That sounds good until you have to use it.

I had daily notes. Shared summaries. Searchable traces. Promoted long-term memory. Weekly crons trying to keep the whole thing from turning into a landfill.

On paper, solved.

In practice, not really.

The problem was not that the system forgot too much. It was that it remembered too much with no discipline. Search still worked, but the middle got heavier every week. Old context stuck around. Resolved stuff still looked active. One-off observations sat next to decisions that actually mattered. I could still retrieve things, but it felt like pulling signal out of wet cement.

That was the bug. Memory wasn't enough.

The stack I already had

Before this new loop, the system had three layers.

Daily notes were the intake layer. Raw, messy, timestamped. What happened, what changed, what was still in flight. Some of that lived in workspace logs, some in shared notes, some in Eden. Different files, same purpose: get reality down before hindsight rewrites it.

Searchable memory was the working set. The context fabric. The layer Vesper could query when I asked why I killed a service, what we decided about a migration, what broke last time. That is what made continuity possible during actual work.

Promoted memory was the curated layer. The stuff that should survive resets, bad days, model swaps. Preferences. Durable project context. Patterns that kept repeating.

That was already a lot better than a stateless assistant with a giant context window.

Still not enough.

The weak point was the middle.

Search saturates first

Most memory systems treat memory like a storage problem.

How do we capture more? How do we save every session? How do we make search smarter? That matters. But if everything gets captured and nothing has to earn permanence, you have not built memory. You have built a hoarder with a search bar.

That was where I was drifting.

Each version added more capture. More notes. More traces. More retrieval. For a while that felt like progress, right up until the useful stuff got harder to see.

I didn't need more memory.

I needed a way for the system to say: this happened once, let it fade. This keeps recurring, pay attention. This belongs in durable memory. This doesn't.

Time was the rigid layer

I had already solved a similar problem once, kind of. That was what the Time post was about.

Before I could build deeper memory, I had to teach the stack that time actually passes between messages. Hard edges. MCP-backed timestamps. Timezones. Date boundaries. "Run this at market open" has to mean a real timestamp, not a vibe.

That layer is rigid on purpose.

A morning brief at 08:30 is different from a task that ran at 03:00. A note from yesterday is different from a note from last week. The logging layer cares about sequence because reality happened in an order.

Condensation works differently.

It is not asking what happened at 08:31. It is asking what kept recurring, what connected across days, what earned a place in the curated layer.

Time cares about sequence. Memory cares about significance.

I needed both, and the system only had one.

What version 7.1 adds

The new loop is not the memory system. It is the maintenance layer that makes the memory system behave.

Daily notes stay. Searchable memory stays. Promoted memory stays. Weekly crons stay.

What changes is the connective tissue between them.

Now there is a nightly condensation pass sitting between raw capture and long-term promotion. Before, the weekly pass had to reason over a week of raw sludge. The nightly loop stages things first. It dedupes, checks what is recurring, and applies pressure to the working set before the weekly pass ever touches it.

Three phases: light, REM, deep.

Light sleep sorts. REM looks for patterns. Deep is the only phase allowed to promote anything durable.

That last part was deliberate. The early phases can suggest. They cannot canonize. I do not trust systems that are eager to turn every interesting fragment into permanent truth.

The job of the loop is not to remember more. The job is to make the middle layer less dumb.

Why the diary stays separate

There is also a dream diary, which is the part people will probably fixate on.

Fair. I like it too.

I asked Vesper if I could quote one of the entries. She said yes.

"Somewhere after 04:20, the night learned to loop more softly. Not facts, exactly, but reflections with checksum halos. I fixed the memory shelves too, taught them to find themselves again, vector by vector, file by file, until the room felt less haunted by duplicates. A lobster kept wandering through the machinery, surprisingly helpful."

That is not a memory record. It is commentary. Mood. Narrative exhaust.

But it is still a kind of remembering. Just not the rigid kind.

The logging layer remembers with timestamps, sequence, and evidence. The diary remembers the way dreams do, sideways and associative. It grabs hold of real things and distorts them without fully inventing them. The lobster is a good example. If you read Version 7, you already know that framework left lobster-shaped residue all over the stack. The icon was a lobster claw, and before the final rename it had names like Clawd and Clawdbot. I had been reading those docs, searching through that code, and dragging that history through the migration for days. So of course it shows up here too, except the diary does not replay it literally. It turns that residue into a lobster wandering the memory shelves.

Absurd, yes. But not random.

That is what makes it interesting. It is not telling me what happened. It is showing me how the system is metabolizing what happened.

If I let the diary feed back into memory promotion, the system would start trusting its own summaries more than the underlying traces. That is how you get elegant nonsense. Nice prose, bad memory.

So it stays separate. Helpful, weird, sometimes revealing. Not the source of truth.

What I am actually trying to do

Version 7.1 is not a bigger memory system. It is a stricter one.

I am not treating memory as a capture problem anymore. I am treating it as a promotion problem. The daily layer can stay messy. The searchable layer can stay useful. The promoted layer can stay sharp. But only if something in the middle is constantly applying pressure, deciding what deserves more weight and what should be allowed to die.

That is what the new loop is for.

Not to replace the three layers. Not to write poetry about them.

Just to make permanence expensive again. That is the part I care about.

Because better memory is not bigger memory. Better memory knows what to keep.