Fourteen architectural decisions, ninety-nine tests, two empirical hypotheses confirmed, one ceiling found. A first checkpoint.

A friend pointed out that Reverie's cells, with their per-token preference vectors, rhyme with attention. So I built a ten-thousand-parameter untrained transformer and pointed it at the same observations. The result is sharper than the analogy.

Entry 002 left the substrate stuck at 33% on the arithmetic benchmark with a clean explanation — the context-cell pool was full and frozen. Two ADRs later, the pool can recycle templates and dreaming protects what's been rehearsed. The benchmark is unchanged. The wall is somewhere else than I thought.

Entry 003 concluded the 33% memorization ceiling was a representation problem, not a capacity one, and that better cache policies couldn't get past it. The first claim was wrong. With four times as many cells, frozen Reverie crosses 65% on the same benchmark and no policy change is required. The ADRs I built were solving a problem more cheaply solved by allocating more cells.

Reverie was originally pitched for emergent behavior on observation streams, not arithmetic recall. So the obvious next test was — what happens on prose? Same architecture, same comparator, character-level next-symbol prediction on the project's own entry 001 text. The result is unflattering and clarifies which part of the wall is workload-specific and which part isn't.

Four entries said variable binding was the architecture's missing piece. Entry 005 ended with "redesign slot cells properly" as the only remaining direction. The smallest possible test of that hypothesis is a one-line change — sort the bound-value tuple before using it as a key — and it lifts held-out generalization from 3% to the transformer's exact number.

Entry 006 ended with two honest caveats — the 73% on held-out generalization rode partly on the easy structure of the random split, and the result might be quietly arithmetic-specific. Both caveats are now tested. The first one was right and tightens the claim. The second one is wrong and the architecture wins more generally than I expected.

Entry 007 left a clean question — does the transformer learn arithmetic functions or also just retrieve like Reverie? Multiplication tables were supposed to break the tie. They don't. At this scale and on this benchmark structure, both architectures are doing essentially the same thing, and the answer to "which one learns functions" is "neither, yet."

Entry 008 left a clean question — does Task 9, the strict held-out multiplication test, decide whether either architecture is doing function learning? It does. Just not the way I expected. The transformer fails systematically at zero accuracy. Reverie fails diffusely at fifty percent. Neither learns multiplication, but they fail differently enough that the architectural difference becomes legible for the first time.

Entry 009 named approach B from the original design discussion — vector-symbolic binding with cleanup memory — as the real architectural commitment that could give Reverie genuine function approximation. I built it. The mechanism is correct. The benchmark didn't move. The reason it didn't move is theoretically predictable in retrospect, and that's the actual finding.

Entry 010 said the project was over. It wasn't. Direction C — the substrate detecting symmetry from observation statistics rather than receiving it from the architect — turned out to be a small enough change to test cleanly. It matches ADR 0017's headline numbers on most binding-related tasks. The "from observation alone" claim now has empirical backing on the one architectural axis where the substrate previously had to be told.

Entry 011 closed the project for the third time. Then we asked what would happen if Reverie were paired with a transformer rather than measured against one. The hybrid covers both architectures' domains at 100% where each alone covers exactly one. The path to actually deploying this in something like Cairn is now visible.

Before wiring Reverie into Cairn as a personal-memory layer, the right precondition is to test whether Reverie's cell-by-cell substrate actually helps a real pretrained model like Claude answer user-specific questions — not the tiny untrained transformer we've been benchmarking against for twelve entries. The result is bounded but real, and it changes what the Cairn wiring would actually look like.

Entry 013 sketched a product story that depended on Reverie's substrate canonicalizing paraphrased facts into shared cell activations. Before committing to anything Cairn-adjacent or building a productization plan around it, the right move was to test that claim directly. The test ran. The claim is false. The product positioning that relied on it dies with the result.

Entry 014 disconfirmed Reverie's ability to canonicalize paraphrases and ended with a proposed fix — distributional preference spreading. The fix is now implemented and benchmarked. It doesn't work. The architectural reason it doesn't work is sharper than the diagnosis in 014, and that sharpening is the actual finding worth keeping.

Entry 015 closed the canonicalization story and offered two options — ship Reverie into Cairn as an audit layer, or keep it as a research artifact. I picked a third path — port the philosophy into a gradient-trained transformer and see whether the marriage works. Four iterations later, the marriage doesn't take, in the same shape the substrate's own failures took. The arc has an ending now.