The substrate

This is the first public entry of Reverie. It exists because a substrate has been built, and the substrate has produced enough findings — including some I didn’t expect — that they’re worth recording before the next iteration starts to forget where it came from.

The project began with a definition. Intelligence is being able to recognize patterns in observations, creating meanings from them, generating links, and changing internal state each time. That’s it. No goals imposed. No success criteria. No external reward. Whatever the system does, it has to do because of how it’s built — not because it’s optimizing toward something we told it to value.

Fourteen architectural decisions and ninety-nine tests later, the substrate exists.

What was built

The system processes observations one at a time. Each observation is a token — a Python value, anything hashable — and arrives via a single function call: observe(token). Between observations the system runs internal cycles via excite(). From its current state it can generate(token) — sample a token from the distribution it has accumulated.

The architecture is built from cells. Five types ended up necessary:

• Mimicking cells make local predictions and learn from being right or wrong about them. They specialize on what they predict.
• Hebbian cells strengthen connections between things that fire together. They build associative structure.
• Predictive cells make bets about what comes next and evaluate those bets one tick later. They learn forward in time.
• Context cells lock onto specific multi-token patterns they’ve seen and predict what should follow.
• Slot cells generalize one step further — their templates have wildcard positions, and they bind concrete values to those wildcards at observation time. They learn parametrized functions of bound values.

The substrate also has connections between cells at multiple temporal lags, lateral inhibition, replay during dreaming, decay, normalization, stagnation detection, and spontaneous output. Every one of these is described in a numbered Architecture Decision Record — the substrate is documented as much as it is built.

What the system does

Two hypotheses were under test from the beginning.

The artist hypothesis says: even without external goals, a system whose cells learn from observation alone will produce meaningful, content-dependent emergent behavior. Its outputs will reflect what it has seen, and its dreams between observations will have content rather than being inert decay.

The artist hypothesis holds. With spontaneous output enabled, the system between observations produces a continuous stream of tokens that reflects its training history. Imbalanced input produces imbalanced output. Multi-word vocabularies produce dreams that walk through the full vocabulary without collapsing onto one token. Long dreams under decay exhibit something like phases — token frequencies drift, settle briefly, drift again. There’s no goal involved. The system is doing what its mechanism naturally does, and what it does happens to look like content.

The memorizer hypothesis says: with the right architectural primitives, the system can learn specific symbolic facts from observation. The test case from the original sketch was simple arithmetic: train on "1 + 1 = 2"-style facts, then ask for the sum.

The memorizer hypothesis also holds, but only after the right primitive was added. Through ADRs 0008, 0009, 0010, and 0013 the system was repeatedly shown unable to do arithmetic — its mechanisms encoded marginal associations between tokens but not the conjunctive “this specific 4-token sequence implies this specific next token” relationship that arithmetic facts have. ADR 0012 added context cells with multi-token templates and conjunctive binding, and the arithmetic test went from 0/8 to 8/8. The correct answer wins each query by a factor of 4 to 8 over the next-most-likely token. Memorization works.

What was found at the ceiling

The hypothesis that didn’t hold is the bridge between the two. The system memorizes; it does not generalize.

Trained on the eight facts that span 1+1, 1+2, 2+1, …, 3+2, the system retrieves them all. Asked for an untrained sum like 5+4, it produces noise. Even with explicit variable binding added (ADR 0014) — cells that hold role representations, where “operand-1” and “operand-2” are slots filled by whatever happens to be there — the system cannot generalize from 1+2=3 to the commuted 2+1=3 if the second wasn’t trained directly. The bindings (1, 2) and (2, 1) are distinct dictionary keys. Learning one doesn’t reach the other.

This is an honest result, more useful than a partial victory would have been. The substrate’s ceiling sits below abstract operations. Closing the gap would require an architectural primitive this design doesn’t have — something that recognizes ”+ is the same operation regardless of operand ordering” as a learnable, exploitable structure. That’s symbolic AI’s territory: rule extraction, variable-quantification, commutativity priors. Reaching it from observation-driven learning alone is a different research direction.

What’s preserved

Each architectural decision is recorded in its own document — what was chosen, what alternatives were rejected and why, what behavioral predictions it made, and (often) what empirical findings either validated or surprised them. Some of the most valuable entries are the surprises:

• The first version of STDP used a centered outer product that was symmetric in magnitude and couldn’t distinguish direction — caught only when the test of “did A→B encoding actually form” came back showing zero asymmetry. The fix is now in the document.
• The first version of normalization broke connection formation by compressing the activation variance that lateral inhibition depended on. Now opt-in, and the tension between mechanisms is named.
• The first version of context-match boost left non-matched cells contributing enough background activation to drown the match. Stronger suppression was needed; the magnitude was tuned empirically and documented.

Future iterations of this project — by me or by anyone else — won’t have to rediscover these. The decisions are written down with the work, and the work has been done in public.

What’s open

Three things, in increasing order of architectural difficulty:

The first is small: more tuning, more experiments with the existing substrate. The system has many parameters; the defaults are reasonable but not optimal. Different parameter regimes might produce different emergent dynamics worth examining.

The second is medium: extending the current mechanisms. Slot cells could learn their wildcard positions from data rather than being told. Context cells could approximate-match with smarter semantics than the current sharpness exponent. Replay could be made richer, including self-outputs as imagined experience.

The third is large, and probably outside this substrate: the bridge to abstract operations. If the system is ever to do arithmetic in the sense of computing, not just recalling, something needs to be added that recognizes operations as structures parameterized by their operands — and that recognition has to be learnable from observation, not configured by an architect. I don’t know what that primitive looks like inside Reverie’s framework. It might not exist there.

This is where the project sits at v0.13. The substrate works. The architecture has produced what was promised and stopped where it was always going to stop. Whatever comes next will be a new chapter.

— Kaan, with Claude as collaborator on the build and these notes