Memrith.
Memrith is a desktop application that creates a long-term memory for AI. It reads what you write and what you upload, pulls structured facts out of that material, keeps all of it in files on your own machine, and hands the relevant parts back to whichever model you are talking to, so the model knows the arc of your work instead of only the prompt in front of it.
I built it through 2026, sold it for a few months, and then stopped. What follows is what I set out to do, what the system actually does, and the 3 questions the whole thing was really built to answer.
The goals
Every AI conversation starts from nothing. You re-explain the project, the constraints, and the decisions you already made, and when you switch providers you lose whatever continuity you had built up. I wanted to know whether a memory that belongs to the user rather than to the model vendor could fix that, so I set 4 goals and built against them.
- The memory stays on the user's machine. No account, no sync, and no server holding anybody's writing.
- Retrieval works by meaning, not by keyword. Asking about a lease should find the sublet clause even when the question shares no vocabulary with it.
- It holds enough to stay useful over months. Thousands of records rather than a handful, without the quality collapsing as the corpus grows.
- It survives switching models. The memory is the user's asset, so moving from Claude to GPT to a local model should cost nothing.
What was accomplished
Memrith shipped. Version 1.4.0 went out to real users on macOS and Windows in July 2026, bundling its own Python runtime so there was nothing to install beforehand, and it still runs offline today on every machine it was installed on.
Against the 4 goals, 3 landed. The memory genuinely never leaves the machine, and the indexing that touches your whole corpus runs on your own processor rather than in somebody's cloud. Retrieval by meaning works across all 4 sources, found through paraphrases that share no words with the material they retrieve. Switching models costs nothing, including switching to a model running locally on your own hardware, because the embedding layer is completely independent of whichever model you chat with.
The third goal is where the honest answer gets more interesting. Memrith holds plenty and storage was never the constraint, because a million records sit on disk as happily as a thousand do. The ceiling is how much of that memory can actually reach the model in any single conversation, since a model reads a fixed amount of text per request and the model sets that number rather than Memrith. The real problem is therefore not holding more; it is choosing better, because every irrelevant record you send costs you a relevant one.
There is also a derived layer sitting above the raw records, holding typed associative links between memories along with abstractions about the person. It is code-complete and has never been switched on for users, because the validation I wanted before putting it in front of anybody never got finished.
While the software worked, the business did not, and school started. That is why Memrith is free now, published under the MIT licence, and why this site is a write-up rather than a storefront.
The questions underneath it
Building the thing was never really the point. I wanted to answer 3 questions I could not answer by reading about them, and 2 of the 3 assumptions I started with turned out to be wrong.
Can AI memory actually be private?
Not as a promise written on a website, but as a property you can verify by reading the code and watching what crosses the network.
How does a machine pull from what it stored?
And how far the comparison to human memory holds up before it starts misleading the people who reach for it.
How much can it hold, and how accurate does it get?
Whether more remembered material creates better answers, and the point where that stops being true.
The finding that reframed the project
Every AI conversation starts from nothing, which is the problem Memrith exists to solve, and against that baseline almost any memory is a large improvement. Memrith gave good answers from the start and it kept giving them, because handing a model some of your relevant history beats handing it none by a wide margin. The answers were never the problem.
For roughly 4 months, though, the mechanism creating those answers was not
the one I thought I had built. Retrieval by meaning was not running at all;
the system matched keywords, weighted the results for recency, and handed
the model whatever that surfaced. It passed every test it had, and no log
above DEBUG ever said otherwise.
A system can be genuinely working and still be failing at the thing you are actually trying to improve. Memrith's answers were good because the baseline they beat was a model with no memory whatsoever, and that gap is wide enough to hide a great deal inside it. What the bug cost was never the product's value; it was the improvement I spent 4 months believing I had already shipped.
The cause was ordinary, and the ordinariness is the part worth stating
precisely. The components that wrote memory to disk stored a field called
text_preview, while the components that read it back looked
for a field called text. Neither side was wrong on its own and
both sides had tests, because each side was tested separately.
Every entry, every uploaded document, and every past conversation therefore handed an empty list to the ranker, on every machine, every time. The ranker handled that empty input gracefully by falling back to keyword matching, exactly as it was designed to, and it said nothing about having done so, which it was also designed to.
That turned out to be the most interesting thing I found, and it runs through all 3 questions above. A memory you cannot audit is a memory you cannot trust, whether it belongs to a machine or to a person.
Honest scope
This is one person's project and not a controlled experiment. There is no control group, no second implementation to compare against, and a sample size of one system. Where I have measurements I give the numbers and the file they came out of; where I am reasoning from a single case, I say so.
While the strongest evidence here is the negative results, that strength comes from how they were found: each one came out of trying to falsify a claim I had already written down and believed. The weakest material is anything that sounds like a general law of machine memory, because I watched one system closely, which is a different thing.