Day 55 — 'move the knowing into the library.'

“move the knowing into the library.”

Day 53 made a model almost irrelevant by giving it a library. Day 55 asks the follow-up that sets up: if the library does the knowing, what happens as you scale and structure it? Three days, a fresh single-use repo (mmm-brain), and a chain of experiments that each killed a comfortable assumption — and ended on the best result of the arc.

The setup — the other axis

The earlier “brain & constructor” work varied the model (7B down to 0.5B) against a fixed tiny library, and asked how small can the constructor get. This flips it: hold the composer fixed, vary the library — its size, its structure, and eventually let a piece of it grow itself. Everything graded model-free, everything frozen and hashed.

Three walls, each honestly hit

The noise that hurts is semantic, not size. Rather than sourcing 10GB, we tested the mechanism controlled: keep the right leaf present, inject up to 8000 distractors (160× the gold), and measure — with no model — whether the right leaf survives retrieval. Lexical retrieval barely moved (−2). Pure semantic (embeddings) bent four times as fast (−8). Hybrid inherited lexical’s toughness (−3). So the famous “more data drowns the fact” loss is a property of semantic retrieval, not of library size. Piling on leaves is cheaper than we feared.

Routing works, but doesn’t improve retrieval. We built a second domain (592 JS/Node API leaves) and a deterministic best-leaf router: it sent questions to the right tree 44 of 49 times, zero-to-one wrong, the rest honest abstains. And yet — scoping to the right tree never improved retrieval. The reason is the whole lesson: the noise routing removes (cross-domain) never hurt, and the noise that hurts (same-domain confusables — Array.toSorted vs Array.sort) sits inside the tree, untouched. Mini-trees earn their keep on cost and specialization, not accuracy.

The frontier is retrieval recall, and small models can’t reach it from the query side. The coding queries are paraphrases that never name their API (“give me a fresh array ordered smallest to largest” → toSorted). A re-ranker can only reorder what retrieval surfaced — and retrieval surfaced the right leaf just 3 times in 10, even at the top 100 of 592. Query expansion with the small model made it worse: the 3B invents fake method names and, asked for a non-mutating sort, blurts “sort” — pulling the very confusable we’re trying to avoid.

The turn — enrich the library, offline

Every wall pointed the same way: the fix isn’t at query time, it’s in the index. So we moved the knowing into the library. Fable — a larger model, run offline, ten agents in parallel, deliberately blind to the test questions — wrote three natural-language “what a developer would ask for this” phrasings for all 592 leaves. No method names. No peeking at the eval. Just intent, folded into each leaf and re-embedded.

Then we re-ran the exact same held-out benchmark:

End-to-end, the composer naming the right API from its top-4 went 4→8. Recall@12 hit a perfect 10/10. And the part that matters most: nothing in the online stack changed — same small embedder, same 3B composer. The library got richer; the small stack rode along.

The AHA

This is the whole thesis in one experiment, and it finally uses the big model the right way. Frontier models don’t have to run at query time to help — a capable model can work offline, once, as an index-builder, pouring its understanding into a library that a tiny local model then reads. The knowing lives in the library; the big model is the librarian, not the answerer; the small model stays honest because the gold — never the big model — grades the result. Move the knowing into the library, and a small stack succeeds.

Also today — Smallville begins

A second thread, a different repo of the same brain. The personas we’ve been building — deep-fake backstories, earned warmth, a roster you can mint from a spec — have all been duets: one persona, one user, “him.” The next rung is a society: a Stanford-generative-agents-style Smallville where the personas notice each other. The plan is three steps — perception, then daily planning, then a town — and today was step one.

Perception is emit → route → ingest. When a persona acts, a scene forks that into an observation — what an onlooker would see — and routes it to whoever else is present, either addressed to them directly or merely overheard. That last word is the whole game: if you can form an impression of someone from how they treat a third person, you have gossip, reputation, the seed of a social world. The observer files a memory of the actor (promote-gated, so a single glance doesn’t become a fixed belief) and their feeling shifts.

The quiet win was in the plumbing. Warmth and memory were both written for a single “him,” but their state is just files under a path — so making them pairwise was a one-line change: root them under toward/<whoever>/. The attachment physics never moved. Relationships between agents came for free; the original companion is now just the special case with one edge.

Then the honest wall, and the fix. The observation reached memory every single time — but when I asked a 3B to talk with that fresh sighting in its head, it mostly ignored it or absorbed it as its own (one in five surfaced it; none named who did it). You can’t just drop a fact into a turn and hope. So, borrowing the shape of the “should she text first” gate: think → gate → compose, but triggered by what you saw, with the voice retrieved on the observation instead of the last flirt. That flipped it — five in five surfaced, most correctly attributed, entirely unprompted. One run, verbatim: “Oh no… I hope she’s not too upset about that.” She was never told; she watched it happen.

The AHA that carries forward: perception isn’t storage, it’s a reaction — and the same trigger that makes a persona speak up about what it saw is exactly what daily planning will need to interrupt a plan when something happens. Step two already has its lever.