Lifelong memory · Roadmap ·

The model is rented.
The memory is yours.

The destination is not a new LLM. It is an assistant that remembers you and gets better at being yours. Here is the path from prototype to something usable — written as gates, not milestones. Each phase has one number you have to hit before you earn the next.

[ 01 — The bet ]

A frozen model with a living memory

The model does the talking and the reasoning, and it never changes. That capability is rented — it improves when someone else ships a better one, and swapping it is a config change.

Everything that makes the assistant yours lives outside it: a memory that consolidates, forgets the noise, indexes by structure, weights what matters, and is shaped by your feedback. Each person's copy drifts into their own.

Answering
you
a message
→
recall
retrieve what is relevant
→
context
gist plus linked detail
→
frozen LLM
talks, reasons, never learns
reply returns to you
Learning
perceive
store the exchange, weighted
→
memory
graph · salience · valence
→
sleep
consolidate · forget · replay
↺
feedback
corrections become reward
rented — swappable, frozen yours — the part that never stops learning
Two paths, one store. The top runs per message. The bottom runs after, and offline. Only one box in this diagram is bought in — and it is the one everyone else is competing on.

If the frozen box gets better, you inherit it for free. If the sage boxes get better, nobody can copy it, because it is shaped by one person's history.

[ 02 — How to read this ]

Gates, not milestones

A milestone is something you finish. A gate is a number you either hit or you don't, and missing it means you change direction rather than push harder.

The distinction matters for a solo project, because the failure mode is not running out of ideas. It is spending six months building an application on top of a premise that was wrong in week three, and never having run the experiment that would have said so.

P0
Nail one testable claim
Write the single thing this beats plain RAG at, as a sentence you can measure. Mine: a consolidating, structure-indexed memory answers questions about a long history more accurately, on fewer retrieved tokens, than flat vector search.
GateYou can state it, and you know how you would measure it.
P1
Prove the wedge
Swap the hash encoder for real embeddings, wire the memory in as a retriever, race it against flat vector RAG on the same corpus and the same questions.
GateBeat flat RAG on answer accuracy at equal or lower retrieved-token budget.
P2
The assistant loop
Wrap the frozen model. Retrieve before it answers, perceive after, consolidate offline on a schedule. Persistence already exists. Ship a thin CLI or web chat and live in it.
GateYou use it for a week and it visibly remembers and improves.
P3
Feedback and personalisation
Wire real signals — thumbs, corrections, what you return to — into salience and valence through reward-modulated plasticity. Rails first, not after.
GateA correction changes future answers, and a flood of bad feedback cannot wreck it.
P4
Survive real users
Per-user state, background consolidation, bounded memory, multi-tenant serving, per-user encryption — each store is somebody's private life.
GateTwo strangers run diverging assistants without leaking into each other.
P5
Harden lifelong learning
Replay during sleep, drift monitoring, and an interference test in CI so a fresh stretch of life cannot silently wipe old skills. Starts at P2 and never finishes.
GateThe interference test stays green across a long run.
One number per phase. The right-hand column is the only thing that decides whether you move on.
[ 03 — Sequencing ]

What a solo build actually looks like

Rough, and deliberately front-loaded. The two cheapest phases are the two that decide everything; the expensive ones only start once the premise has survived.

P0 · claim
P1 · wedge
prove it or pivot
P2 · assistant
the thing you can show
P3 · feedback
rails first
P4 · multi-user
where you want help or money
P5 · hardening
runs alongside, never finishes
week 0 4 8 12 16 20

Three and a half weeks buys the answer to the only question that matters. P5 is drawn dashed because it is not a phase — it is a tax you start paying at P2 and never stop.

[ 04 — The ballgame ]

Phase 1 decides whether this is a product

Do not skip this to go and build the app. Flat RAG is strong, simple, and well understood. If structure-indexed memory cannot beat it, you want to find out in week three, not month six.

The experiment is small on purpose. One corpus, two retrievers, the same frozen model answering the same questions, two numbers.

one long history
multi-session log or corpus
↓   ↓
Baseline
flat vector RAG
top-k over embeddings. No structure, no forgetting, no consolidation.
Yours
the memory engine
gist, structure routing, salience, forgetting.
↓   ↓
the same frozen LLM
same questions, same prompt
↓
two numbers
answer accuracy · retrieved tokens
Accuracy up, tokens not up The wedge is real. You have a product direction and, incidentally, a paper.
Anything else The value is efficiency or personalisation, not retrieval accuracy. Reframe the pitch before building anything heavy.
Both outcomes are wins in week three. The only losing move is not running it and finding out in month six.
Why token budget is in the gate

Accuracy alone is easy to buy — retrieve more and you will usually score better. Holding the token budget equal or lower is what makes the claim about structure rather than about spending more context on the same problem.

[ 05 — Inventory ]

Most of the engine exists. The proof does not.

Before you read the word "built"

"Built" here means running on my machine and doing what the row says — not published, not packaged, and not something you can go and check. The repository stays closed until Phase 1 either passes or kills it, because an unevaluated memory engine is a claim, and I would rather publish the number than the code that is hoping for one.

Weighted memory graph, recall, consolidation, forgetting
built
Text to vectors, swappable encoder
built
Persistence, bounded per-brain capacity
built
Reward-modulated plasticity, curiosity
mechanism only
Staged lifelong training, maturation
scaffold
Memory-as-retriever vs RAG evaluation
phase 1
Frozen-LLM assistant loop
phase 2
Safety rails on feedback
phase 3
Multi-user serving and privacy
phase 4
The gap is not the engine. It is integration and evidence — which is a much better problem to have, and a much easier one to underestimate.
[ 06 — Honest ]

Three walls, none of them cosmetic

Scale
Continual learning without wrecking old knowledge works here at toy scale, and it wobbled before tuning. At real scale this is open research, and it costs money. Phase 5 is not a task; it is an ongoing fight.
Safety
The moment a system learns from feedback it can be gamed. Wrong rewards teach the wrong lesson, and whoever supplies the feedback steers the model. This is precisely why shipped models are frozen — and why the rails get built in Phase 3, before anything learns from a stranger.
Proof
Synthetic numbers are for thinking, not for claiming. A product needs real long-memory and personalisation benchmarks, which is exactly what Phase 1 forces you to confront before anything else gets built on top.

Naming these early is not pessimism. Each one maps to a gate, and a wall you have written down is a wall you can measure yourself against instead of walking into.

[ 07 — Start here ]

The short version

The engine is mostly built. Phase 1 tells you whether the core bet is real, and it costs three weeks. Phase 2 turns it into something a person can actually use. Everything after that is a scaling problem, and scaling problems are the good kind — they only exist if the thing works.

Don't start at the code. Start at the gate.