Why this exists.

Every conversation with an AI starts from nothing. You explain your projects again. You paste the same context again. You correct the same wrong assumption you corrected last Tuesday. The machine is not stupid. It is that nothing it ever learned about you was allowed to persist anywhere you control.

So you do what everyone does. You keep notes. In an app. Then a second app, because the first one could not do one thing. Then a third, because the second changed its pricing. Your knowledge ends up spread across a dozen products you do not own, that do not speak to each other, each one a business decision away from changing the terms.

MacBrain is the other answer. One private memory, in one file, on hardware you own, that any AI you trust can read from and write to. That is the entire pitch, and it takes sixty seconds to make.

This page takes longer, because it is about why the thing is built the way it is. The honest way to tell that is through the three times it went wrong.

Failure oneThe nag that taught its reader to ignore it

Every night, an agent looks over the whole system and writes up what it thinks needs attention. Useful — for about a week. Then you notice you are skimming it. Then you notice you have stopped opening it.

Here is what was actually happening, measured across twenty-three consecutive archived reports: one single item was reported on fourteen of them. Not because it kept happening. Because a human had looked at it, decided it was fine, and had nowhere to say so. Two of those nights carried no new information at all.

A report that repeats a decision you already made is not a reminder. It is training you to skim, which is worse than sending nothing.

The fix was not a smarter detector. It was memory of a different kind — the system had to remember the verdict, not just the condition. Now, when you dismiss something, it stays dismissed. Finding it again is treated as evidence the condition still holds, never as an argument about whether it matters. It comes back only when it genuinely changes, or when you ask.

A decision you make once should stay made. Almost nothing you use every day gets this right.

Failure twoThe feature that was built, measured, and switched off

Two checks were designed to catch notes going stale: one for pages promising something on a date that has since passed, one for abandoned to-do boxes. Both were specified, built, and unit tested. Both sounded obviously worth having.

Then they were run against the real thing — a vault of 137 files. The first returned four hits and zero of them were real. Every one was a row in a book list, where a title containing the word "Will" or "Next" happened to sit beside a purchase date. Exactly the pattern it was written to catch, and in this collection it never once meant what the check assumed. The second returned nothing whatsoever, because there were no abandoned to-do boxes anywhere.

Neither was switched on. Both are still in the source, disabled, with eight passing tests and no way to reach them. And the decision to leave them off is held in place by a test that fails if anyone quietly wires one back in, with the measurement that justified it written directly above.

Most software deletes the experiment that failed and keeps the story. This keeps the experiment, and turns the story into a test.

Which matters more than it sounds. Delete the code and the measurement goes with it, and in a year someone rebuilds the same bad idea from scratch, because it still sounds obviously worth having.

Failure threeThe good idea that lost to its own control

Putting a page's title into the search index worked, measurably. The obvious next step was to do the same with its alternate names. Same argument, one step further. It was so obviously right that it reached production before the check that was supposed to confirm it had finished running.

The check disproved it. Retrieval quality fell — 0.746 to 0.699 on one measure, 0.640 to 0.582 on another. A handful of short alternate names quietly drags every passage on a page toward them, and away from what the page actually says. So it was reverted, and alternate names are now indexed only where short exact strings belong.

Two things generalize, and both are uncomfortable. A change that extends an argument that already worked is not therefore correct. And a control you run after you have already shipped is still worth running: it is the difference between a regression somebody eventually senses and one that is measured, dated, and undone in an afternoon.

What it means in the designDeterministic on purpose

All three of those stories depend on the same property: you can tell what the system did. That is not free, and it is the reason for the design decisions underneath.

Your files stay canonical. Your notes are plain markdown in your own git repository. The database is an index built over them — the search tables, the meaning-vectors, the links between pages, all derived. Delete the whole database and rebuild it from your notes. The reverse is not possible, deliberately: it puts a hard ceiling on what any bug in the indexer can ever cost you.

Search is deterministic. Keywords through a full-text engine, meaning through an embedding model that runs on your own hardware, the two rankings fused into one. Nothing about your memory is uploaded, and the same question gets you the same answer.

And the daemon itself runs no language model. Ever. That is a claim about the daemon, not about the whole system, and the difference is worth being exact about. There is a model. It runs every night. It runs outside.

It is the same nightly pass the first story is about. It reads your brain after hours and writes you a digest: this link points at a page you never wrote, this page has nothing pointing at it, here is what actually changed. Ask it to and it will go hunting for pages that contradict each other — that one costs real money per run, so it stays off until you turn it on. It is genuinely useful, and it is deliberately powerless. It reaches your memory through the same read-only tools any assistant gets. It cannot open the database, and it has no path to your files at all. It may raise a suggestion; it cannot act on one, and it cannot rule that its own suggestion was unimportant either. That verdict is yours — because anything that could both raise a finding and dismiss it could quietly decide it had no work to do.

So nothing tidies your notes while you sleep. Something reads them and hands you a list. A suggestion becomes part of your memory when you write it into the file yourself, which is a commit, with your name on it. This is the part that sounds like a limitation until you have lived with the alternative — and it is precisely what made the third story possible. When you cannot tell whether the system is being clever, you cannot tell whether it is being wrong.

Every AI you authorize, and none that you do not. Twenty-two tools over an open protocol, so this is not a plugin for one company's chatbot. Each client gets its own key with its own permissions. A read-only assistant can search everything you have and change none of it.

Where it comes fromFilling it cannot be a chore

Every knowledge base you have ever started is empty right now, and it is the same reason each time. Filing things is work you do on top of the work, and it loses. So the honest question is not whether a memory is a good idea. It is who is going to write it down at six on a Thursday.

The answer is that you do not. You finish working — with an assistant, on something real — and the assistant writes it up, because it was there for the whole thing and does not need to be briefed. That is the moment the knowledge is cheapest to capture and the moment it is always lost.

Which still leaves the evenings you meant to write something up and didn't. So the session is not simply forgotten. If it ran long enough to have been about something, it leaves itself a note — and that note is the first thing waiting the next time you sit down, before you have started anything new, while you can still remember what happened. Write it up, or say why not. "Not worth it" is a real answer: it is recorded as a decision, with your reason, and it stops asking. What it will not do is quietly disappear because you ignored it twice.

None of this is the memory's doing. It is a small thing standing beside it that you can throw away — and that is the point. The system holding your knowledge should not also be the one nagging you to feed it.

One question gets asked before anything new counts: is there something pointing at this? A note nothing links to is a note you will never find again. So it is caught while you are still writing, when fixing it costs you a sentence, instead of surfacing a year later on a list of things nobody can reach.

And what gets written is just a file. Not an entry inside a product you cannot open — a plain text note among your own files, saved into your own history, so there is a dated record of what was added and when. Write one yourself in whatever you already use and it is picked up the same way. Either road, you end up with something you can read without MacBrain, correct by hand, or delete outright. Nothing is ever only in the database.

HonestyWho this is not for

There is no signup button and no hosted version — you run it, on a small server or just on your laptop. If your notes are not files you can keep in git, the notes half of it has nothing to work with. Encrypted sync between your devices is not built; today they share one server on your own network. And it is not open source yet. That happens when it is genuinely ready for someone else's machine, not when it would make a better announcement.

FinallyThe ordinary version of this

Picture it working, which is deliberately unspectacular. You sit down and the assistant already knows what you decided last month, and why you rejected the other option. You stop being the integration layer between your own tools. Nothing has to be re-explained, because nothing was thrown away.

And when somebody asks where your knowledge actually lives, the answer is not a company. It is a file, on a machine, in your house.