We would like a personal assistant that actually knows us — one that remembers what we care about, learns our habits, and grows more useful the longer we use it. And we would like it to do all of that privately, on our own machine, without handing our lives to a company's servers.
There is a catch. The models clever enough to understand a person that deeply are, on ordinary hardware, painfully slow — a large one reading its weights from disk might manage only a word or so a second. You cannot hold a conversation with something that slow. Meanwhile the models quick enough to talk to are too small to understand you deeply. It looks like a choice: deep, or fast, but not both.
This is a way to have both. Let the slow-deep model do its thinking out of sight, behind the conversation, where its slowness costs nothing — and let a small, fast model do the talking, spending what the slow-deep model has worked out. One builds the understanding; the other puts it to use.
§ 01Two models at two speeds
The two models have clearly divided jobs. The slow one is a kind of compiler: given time, it reads back over the raw record of your conversations and writes what it learns into a private notebook (a wiki), in clean, organised pages. The fast one is the part you actually talk to; when you ask it something, it answers from that notebook rather than working everything out from scratch. The slow-deep model never speaks to you directly — it works behind the conversation, keeping the notebook current for the fast one to read.
That notebook is the heart of the system, and it is written in plain, human-readable form on purpose. That will matter later: because you can open it and read it, you can also correct it.
§ 02How memory forms
While you talk, the most recent few exchanges are simply kept as they were said, word for word, in a short-term buffer. When the fast model answers, it looks at two things: this buffer, for what was just said, and the notebook, for everything older that has already been thought through.
Later — often once you have gone quiet — the slow-deep model goes back over the buffer and works its contents into proper notebook pages (a little like dreaming): turning the loose events of the day into something settled and organised. Once a conversation has been digested this way, the word-for-word version can fade, because its meaning now lives in the notebook.
§ 03How the notebook stays good
Here the system borrows its way of working from evolution — and, since the fit is close, its words along with it. Everything it knows lives as a pool of rival notes (a gene pool). Rather than rubbing out an old note whenever a new one arrives, it lets several versions of the same subject (competing alleles of one gene) live side by side and compete, and keeps whichever proves fittest (selection).
The slow-deep model is what judges the contest, and over time the fittest account of each thing wins out. Those winners, gathered together, are the notebook the fast model actually reads (a genome) — read out, moment to moment, as the voice you meet (its phenome). How the fittest gets chosen is a problem in its own right; the companion paper handles it.
The reigning version always has to defend its place — so a better account can unseat it later, and the one it beats is not thrown away but drops back among the contenders, ready to win again if it was right all along.
§ 04When the slow-deep model runs
Because the slow-deep model is expensive, something has to decide when it may run. A simple governor watches the machine's spare capacity (its physiology, in a sense) — how much power and headroom there is, whether you are busy using the device — and lets the slow-deep model work only when there is room. When you are away and the machine is idle, it runs freely and does its heaviest thinking then (its sleep), for the plain reason that that is when nothing else needs the machine.
§ 05Keeping it honest
A small, fast model reading a mistaken note will repeat the mistake with full confidence, so the notebook keeps a few safeguards. Each note about you remembers where it came from and when — which actual exchange it was drawn from, and whether you said it outright or the system merely inferred it. The fast model can then stay tentative about anything old or guessed-at, and speak plainly only about what is recent and certain.
If nothing in the notebook clearly answers a question, the fast model is allowed to admit as much rather than reach for a poor match — a blank is better than a confident error. And because the notebook is plain and readable, the last safeguard is you: anything the system has got wrong, you can open and fix by hand.
The engineering behind this essay — the knowledge base, the ranked pool, the scheduling, and the failure modes it has to survive — is set out in White Paper 1 — A Two-Speed Architecture for Persistent Local AI Agents.
A working prototype runs privately today; the project's home is kaineros.com.