Canonicalization disconfirmed

The Cairn integration shape entry 013 ended on had three claims behind it, in increasing strength: Reverie’s substrate stores observations cell-by-cell (uncontroversial), each cell is auditable and deletable (uncontroversial), and the substrate canonicalizes paraphrases of the same underlying fact into similar cell-activation patterns (uncontroversial-sounding but never directly measured). The third claim was load-bearing for the “Reverie sits in front of RAG as a canonicalization layer” product positioning. If it’s true, indexing Reverie’s templates with RAG produces a smaller, deduplicated retrieval corpus and a real engineering wedge. If it’s false, Reverie reduces to a parallel audit log on top of whatever RAG already does, and the productization story shrinks accordingly.

So I ran the test before the productization conversation went any further.

The experiment

Five fact groups, each containing four to five paraphrases of one underlying fact. Examples:

• prefers_tea: “I prefer tea over coffee”, “tea is my morning drink”, “I drink tea every day”, “no coffee for me tea only”, “I always choose tea”
• works_engineer: “I work as a structural engineer”, “my job is engineering”, “I am employed in engineering”, …
• lives_utrecht, wife_halime, drives_volvo: same shape.

Five groups × 4-5 paraphrases = 23 total facts. Reverie substrate: 512 cells, K=8 context window, observe all facts in mixed order eight times.

For each fact, the substrate’s “activation signature” is read by deep-copying the trained substrate, observing the fact’s tokens, and recording the final cell-activation vector. This isolates each read so signatures don’t contaminate one another. Pairwise cosine similarity is computed over all signatures. Within-group pairs (paraphrases of the same fact) and cross-group pairs (unrelated facts) are aggregated separately.

If the substrate canonicalizes, within-group similarity should substantially exceed cross-group similarity — paraphrases of the same fact activate similar cells, even when surface tokens differ. If not, the two should be roughly equal.

What the test showed

    seed   within (paraphrases)    cross (unrelated)   ratio
      42       0.379 ± 0.283        0.331 ± 0.254      1.15
      43       0.373 ± 0.286        0.316 ± 0.258      1.18
      44       0.368 ± 0.283        0.306 ± 0.245      1.20

  Overall:  within = 0.374   cross = 0.318   ratio = 1.18

Paraphrases are 18% more similar than unrelated facts. The standard deviations (~0.28 for both) are larger than the gap between the means. The distributions overlap heavily. The reading guide built into the script puts this squarely in the “ratio ~ 1.0-1.3: effectively no canonicalization” band.

The substrate does not canonicalize.

Why the substrate doesn’t canonicalize

This isn’t a tuning issue. It’s structural. Reverie’s cell activations are determined by token-level co-occurrence preferences: each cell accumulates a preference distribution over the vocabulary based on which tokens it has observed firing alongside it. Paraphrases of the same fact like “I prefer tea over coffee” and “tea is my morning drink” share a few tokens (tea, I, my), but the bulk of their content uses entirely different words (“prefer” vs “morning”, “over” vs “drink”, “coffee” vs nothing). Cells without an explicit semantic-embedding layer can’t recognize “drink” and “prefer” as pointing at the same underlying concept. The substrate sees two distinct token-co-occurrence patterns that happen to overlap slightly, and that’s exactly what 1.18× looks like.

This is consistent with everything in entries 002 through 013. Reverie doesn’t do semantic abstraction; we just hadn’t measured the consequences directly for a retrieval-style use case until now.

What dies, what survives

The product positioning entry 013 sketched as the cleanest one (“Reverie sits in front of RAG to deduplicate paraphrases, RAG handles retrieval”) depended on canonicalization being real. It isn’t. So that positioning is dead.

What survives is narrower:

• Audit / delete layer. Reverie’s cell-by-cell substrate can still serve as inspectable storage in parallel to RAG, where the user lists and deletes specific learned patterns. RAG handles retrieval; Reverie owns the auditability surface.
• No-embedding-model dependency. Pure-numpy substrate; updates are microseconds of CPU; no embedding inference for ingest. Still real, still useful for on-device deployments.
• Online updates without retraining. Still real.
• Time-decay forgetting. Still real via preference_decay_rate.

What does not survive: any product framing built on “smaller, signal-richer index” or “deduplicated memory” or “canonical patterns.” Those claims required the experiment to come out the other way. It didn’t.

What this changes about the productization plan

Entries 012 and 013 had been moving toward “Reverie as the memory-infrastructure layer for AI applications.” That positioning competes with Mem0, Letta, and the broader memory-layer-for-agents category. The wedge against those competitors was supposed to be canonicalization + audit + no-embedding-dep. With canonicalization off the table, the remaining wedge is audit + no-embedding-dep — and neither of those by itself supports a paid SaaS product. They could justify an open-source library, but not a venture-scale or even sustainable-solo-founder business.

This is a sharper version of what entry 010 already said when it first tried to close the project: Reverie alone isn’t competitive with the available alternatives at the things benchmarks measure. Entry 012 reopened it with the hybrid result, entry 013 narrowed it to “Reverie + RAG with auditability as the differentiator,” and now entry 014 has narrowed it further to “Reverie as a parallel audit log on top of RAG, no canonicalization.”

The product story isn’t gone. It’s just smaller — Reverie as an open-source library someone might use for the specific deployment properties it has, not a category-defining memory infrastructure.

What I’m going to try next

The disconfirmation is honest, but it’s also a specific result about Reverie as it currently stands. The architectural reason for the failure is clear: cells preference individual tokens, not semantic neighborhoods. If a learning rule existed that let cell preferences spread to co-occurring tokens during training, paraphrases sharing semantic neighborhoods (even with different surface words) would activate more similar cells. That’s a concrete architectural change to try.

The next entry — 015, if the attempt is worth writing up — will report whether a distributional-preference-spreading mechanism (ADR 0020 candidate) closes the canonicalization gap. The plan is straightforward: when a cell reinforces its preference for an observed token, also slightly reinforce its preference for tokens in the recent window with a spread factor. Over training, cells develop preferences over neighborhoods of related tokens rather than individual tokens, and the activation signature for a fact reflects the semantic content rather than the surface words.

If that lifts the within-vs-cross ratio meaningfully (from 1.18 to something like 2.5+), the canonicalization story is back — possibly with a different mechanism but with the same product implications. If it doesn’t, then canonicalization isn’t reachable from Reverie’s substrate without becoming something other than Reverie, and the productization plan stays in its narrower form.

The next entry should be one paragraph or several thousand words; I won’t know which until the experiment is done. That’s the right shape for a research log to be in.

— Kaan, with Claude as collaborator on the build, the experiments, and these notes. Experiment script at model/scripts/canonicalization_experiment.py; reproduce with --seeds 3. The fix attempt is in flight.