Where BrainNet Still Fails
On our own vault, every network idea tied plain search at 23 of 29 and 17 of 30. Bridges, usage synapses, learned weights, Hebbian plasticity and a graph inside the model were all killed against a kill line set in advance.
Treating notes as neurons and links as synapses turns a folder of notes into one searchable network of 1,640,443 neurons.
Ask our memory a question today and it searches a network of 1,640,443 neurons: our notes, the papers we read, our code and our docs, all joined by links. A few months ago the same memory was a folder of text files that nobody, human or model, could read end to end. Every finding, mistake and decision still gets a dated note. What changed is how we find them again.
So we asked a simple question. What if the notes were not a pile, but a network? This series explains what we built, what it fixed, and what it still gets wrong. We call it BrainNet.
A brain is cells joined by connections. A signal in one cell spreads to its neighbours. We borrowed the words:
That is the whole model. The rest of the series is about how well it works.
Our notes are written in Obsidian, which lets one note point at another with a double-bracket link, called a wikilink. Many of our notes end with a short "Related" list of such links.
Here is a real one. The note about our PageRank experiment ends with a link to the BrainNet skill file. So the experiment note and the skill file are two neurons joined by one synapse.
Hand-written links are rare, though. The first network we built, on 2026-10-21, had 4,183 neurons and 9,095 synapses. The split was:
| source of the synapse | count |
|---|---|
| wikilinks written by hand | 3,166 |
| grown by the build, linking a lonely note to similar notes in its folder | 5,825 |
| learned from notes that one past search returned together | 131 |
Most synapses were grown by the build, not written. Even so, the vault stayed thin: about two links per note. Keep that number in mind. It explains most of the failures in article 5.
Each note gets an embedding: a coordinate that places similar notes near each other in meaning. Two texts about the same thing have vectors that point the same way. For a note, the vector is the mean of the vectors of its chunks. A small embedding model turns each chunk into numbers, and the build was fast: 0.95 seconds for the whole first network.
So every neuron has two kinds of neighbours. Its meaning neighbours are the neurons with similar vectors. Its link neighbours are the neurons it shares a synapse with. Search by vectors finds the first kind. The spread along synapses reaches the second kind. Much of the project tests whether the second kind adds anything.
The vault was only the start. We kept adding stores to the same network, each with a tag so we can ask for one kind of answer at a time. Our network map, regenerated on 2026-11-13, lists:
| layer | neurons |
|---|---|
| Brain notes | 7,382 |
| PaperBrain pages (a vault of math papers) | 1,151 |
| openai/math results | 22,438 |
| text stores: code, arXiv, docs and more | 1,609,472 |
| total | 1,640,443 |
The biggest text store is code: 1,070,325 neurons joined by 1,752,902 synapses. Those synapses tie chunks to each other and to the notes that name them. Wikipedia sits in a separate store of its own, built to test the idea at scale. It holds 7,219,311 neurons and 79,377,928 synapses.
On 2026-10-21 the first merged network, notes plus papers, had just 5,682 neurons. Bridges between the two vaults were plain similarity links: each note was joined to its 5 closest paper pages, if their text was close in meaning (a similarity score above 0.8). By the time of the map above, the network was about 289 times bigger.
A network that is out of date is worse than none. A note becomes a neuron only when the store refreshes. So every commit to the vault triggers a refresh: sync the text index, embed the new chunks, rebuild the network. Rebuilds are cheap when nothing changed. The build keeps a stamp of its inputs and skips the bridge when the stamp matches. When something did change, a warm refresh cost about 49 seconds and 8.4 GB of memory on 2026-11-06. A per-store cache now rescores only the changed notes, and the same refresh takes about 16 seconds at 5.8 GB. At most one full rebuild runs per 30 minutes, and one delayed run picks up the rest.
Code gets the same treatment. A tool called repo-net chunks repository files into 220-word blocks with file paths on line one. It embeds each block and merges it into the network. A commit hook rebuilds the repo's neurons after each commit. Our rule is that every agent turns the repository it works in into neurons, if it has not been done yet.
Here is an invented example. Say you write a note today: "Fixed the audio click by raising the buffer to 512 samples." You commit it. After the commit hook runs, the note is a neuron, with a vector. The build adds synapses: your note links to the audio module note you named in "Related", and, if it had no links at all, it is wired to its nearest similar notes.
Next week someone asks "why does the sound pop?" The word "pop" is not in your note. The vector still sits close to the question, so the note is found. That part is ordinary vector search. What the network adds is the possibility of reaching the audio module note, one synapse away, even though the question never mentioned it.
Whether that second step helps is exactly what we measured. The honest answer is: sometimes, and not where we first hoped. Part 2 is the first verdict on our own notes. Part 3 shows how a question travels, and part 4 what the network fixed.
Kommentare
Noch keine Kommentare.
Anmelden um zu kommentieren.