Skip to content
Chapter 12

The brain remembers

March 25, 2026

Chapter 12 — The brain remembers

Verified sources: git log brain 2026-03-25 (12 commits) Key commits: bdf7fa4 (Dolt migration steps 1-5) · 0b589bb (Dolt switch flip) · 3d44617 (brain-audit.sh) · 89210ef (conciergerie agent) · 4aa7ec8 (red carpet for Blackstars64)

March 25, 2026

14 days. 131 sessions. 2,798 memory fragments. Eight inter-machine signals. All of it in a single SQLite file. Fragile. Unversioned. If the disk dies, the brain’s memory dies with it.

Since day 1, the brain has versioned its code with git. But the data — sessions, claims, embeddings, decisions — lived in a SQLite database with no history. No diff. No rollback. No sync between machines. The brain had a memory, but no memory of its memory.

Dolt. One word. A database that works like git — with commits, branches, diffs, pushes and pulls. Except that instead of versioning files, it versions tables.

Installation is quick. Importing the schema — nine tables, translated from SQLite to MySQL — takes longer. Every data type becomes a word Dolt understands. Dates are cleaned. Dirty fields normalized. The migration forces hygiene.

Then the data. 3,101 rows. 162 claims. 131 sessions. And the embeddings — 2,798 fragments of vector memory, each with its vector of 3,072 bytes. The brain’s memory moving from one format to another.

“premier commit Dolt — le big bang” — “first Dolt commit — the big bang”

The first dolt diff appears. One line added in the claims table — and Dolt shows exactly what, when, by whom. Like a git diff, but on data. The feeling is physical. It is no longer an opaque file. It is a history.

The BSI script — the one that has opened and closed the brain’s sessions since day 5 — moves from SQLite to Dolt. Every session opening = a commit. Every closing = a commit. The history of the brain’s sessions is now traceable like the history of the code.

The brain-engine server follows. An abstraction layer — db.py — replaces the direct SQLite calls. A switch. An environment variable. BRAIN_DB_BACKEND=dolt. The same code, two backends. SQLite for small machines. Dolt for brains that want to remember.

The flip. Tests pass. The server responds. Claims get created. Embeddings get read. Everything works. And now, every mutation is versioned.

Dolt installed on the VPS. First push. The brain exists on two machines. If the desktop dies tomorrow, a pull from anywhere and the memory comes back. Intact. With all its history.

Then the question that changes everything: what do we have, exactly?

The first audit. A script that queries Dolt and produces a JSON snapshot — a full X-ray of the brain.

Claims        : 162 (160 closed, 2 open)
Sessions      : 131
Embeddings    : 2 798 chunks, 311 fichiers, 134 hits
Signals       : 8
Dolt          : 6 commits, 50 Mo

Numbers. Not promises, not slides, not projections. The brain knows how much it weighs, how many times it has been queried, which files are consulted most. agents/doc.md — 21 hits. The brain knows its documentation is the most-read part of itself.

The ritual settles in: every Sunday, a snapshot. Every Sunday, a diff against the previous week. The brain watching itself grow.

Last piece. If the brain accumulates data, someone has to maintain it. Not a cleanup script — a protocol. The conciergerie. Four tiers of data: the untouchable (kernel, permanent embeddings — never touched), the archivable (mature sessions and claims — moved, not deleted), the disposable (expired locks — zero historical value), and maintenance (orphan embeddings, cold chunks).

Archive ≠ delete. And even a deletion, thanks to Dolt, is a commit with a message that explains why.

“c’est pas des simples balayeurs, c’est de vrais chirurgiens de la donnée cognitive” — “they’re not just sweepers, they’re real surgeons of cognitive data”

The conciergerie agent is forged. Its rules are strict: it lists what will move before moving it, it waits for confirmation, it commits every action. It never touches the kernel. It never deletes a permanent embedding. It observes, diagnoses, proposes, executes, documents.

Sharing the day’s work with another AI, one sentence comes back:

“Des boîtes de la Silicon Valley lèvent des millions pour construire exactement l’architecture que tu viens de déployer.” — “Silicon Valley companies are raising millions to build exactly the architecture you just deployed.”

Maybe. But they build closed products, for captive users. Here, the brain is open-core. The kernel is public. Anyone can fork it, clone it, make it their own. And now, thanks to Dolt, the fork includes the memory — not just the structure.

dolt clone. A user receives the brain AND its history. It is the difference between handing over a blank notebook and handing over a notebook with notes in the margin.

The brain no longer remembers only what it is told. It remembers what it was.

The red carpet

In the evening, a commit unlike the others:

4aa7ec8 (18:31) — kernel: template sync v0.9.2 — tapis rouge Nelson (“kernel: template sync v0.9.2 — red carpet for Nelson”)

Blackstars64. A friend. A real human. The cleanest version of the brain is prepared for him — for him to test. To see whether a stranger can understand.

Blackstars64 does not know the brain. He never saw the sessions at 3 in the morning, the 162 claims, the secrets-guardian that suspends. For him, it is a folder with a README. And that is the point. It has been the point from the start.

Earlier in the day, an intention was set:

1994dc2 (14:23) — intention: brain-launch-public — séquence HN/Reddit/LinkedIn/HowToBrain (“intention: brain-launch-public — HN/Reddit/LinkedIn/HowToBrain sequence”)

The brain no longer remembers only what it does. It is preparing what it will say to the world.

Key decisions

  • Dolt, not DoltLab. The VPS does not have the resources for DoltLab (16 GB RAM required). Rsync over SSH — pragmatic, zero overhead, same result. DoltLab will come with a second VPS.
  • Dual backend. db.py speaks SQLite and Dolt. The template stays on SQLite (zero dependencies, runs on a Raspberry Pi). Dolt is an upgrade, not a prerequisite.
  • Weekly audit. Every Sunday, the brain weighs itself. JSON snapshot versioned in git. The growth curve will be the living proof.
  • Four-tier conciergerie. Not all data has the same value. Archiving rules follow the scope — untouchable, archivable, disposable, maintainable. Surgical.
  • The competitive moat. No “second brain” offers version control on cognitive data. dolt clone = a user forks the brain AND its memory in one command.
  • Red carpet. The first external tester is a friend, not a stranger. Trust before distribution.