friday deploys — then open
the result marked fading.
the dashboard doing its job, recorded. Open this page on
a laptop to drive it yourself.
open full screen ↗
iai-pme is a memory that lives on your own computer. It keeps what you said, word for word, and hands the right piece back to your assistant before you have to repeat yourself.
Five things happen. It handles all five.
You work exactly the way you already work. Same habits, same commands, same shortcuts.
In the background, every message is written down — yours and the assistant's — exactly as it was typed.
Other tools ask a model to summarise your session and keep the summary. That is cheaper, and it costs you the one sentence you actually needed — usually the specific one, with the number in it.
Here the original wording stays, word for word. Months later you get the sentence itself.
When your machine is idle, the engine goes back over what piled up. It groups related moments, notices what keeps coming back, and turns repeated patterns into something shorter it can reach for quickly.
What you keep returning to grows stronger. The rest fades quietly, and anything you pinned stays for good.
You open a new conversation and the assistant already knows what matters: the decisions you made, the rules you set, what broke last time and why.
This happens twice: once when the session starts, and again before each message, so what arrives is what this question needs.
You once said deploys go out on Friday. After a bad night you decided Tuesday. Ask about deploys now and you get the current rule — and a note that it replaced an earlier one, which is still there if you want to read it.
Every version you ever held stays on the record. This is the part that keeps an assistant honest about what you believe today.
Every message of every session, exactly as written.
What it works out from those moments while your machine is idle.
How you like to work, applied on its own.
What you marked as permanent. It stays permanent.
Most memory projects are a thin wrapper around somebody else's vector database and somebody else's graph library. We wrote ours. One line installs the whole thing and it runs on your machine alone, because every piece doing the work was built for this exact job:
Keeps the records, the search index and the connections between memories in one encrypted file on your disk. Our own engine, written for this shape of data.
Works out which memories belong together, so recall spreads through the right neighbourhood rather than the whole store. Written to be light enough to run through your whole memory every night.
Gives moments, knowledge and habits different internal shapes, which is what lets you find a memory by its shape as well as its wording.
The embedder and the graph work run as native code. This is where the speed comes from, and why recall feels instant on a laptop.
Being honest about the borrowed parts: the encryption, the maths library and the tensor kernels are all somebody else’s, deliberately. They sit on boring, audited, permissively licensed code, because inventing your own crypto is how you lose someone’s data.
We built the rest ourselves because the hard case here is change, not size. A memory that stays exact while it is reorganised every night, questioned on every message, and required to keep every old version of a fact is a different machine from a vector store you fill once and read from.
One person on one laptop is where that engine is proving itself, and it was built for more. The same core is what a whole company runs on next: every engineer’s machine feeding one brain that remembers all of it and answers from any seat. This is the first floor of that building, which is exactly why we own the foundation.
Every mechanism in the engine comes from a field that already studied the problem, and the people who did that work are named below, so you can go and read the same papers we did.
Marr 1971 · McClelland, McNaughton & O’Reilly 1995 · Wilson & McNaughton 1994 · Nader, Schafe & LeDoux 2000 · Raichle et al. 2001
Human memory runs on two stores. A fast one records today and a slow one keeps what matters, and the fast one hands over to the slow one during sleep — the complementary-systems account that McClelland, McNaughton and O’Reilly set out in 1995, building on Marr’s 1971 theory of the hippocampus. That is the shape of this engine: everything lands in the fast store immediately, and a nightly pass moves the durable parts across. The rest of the night’s work comes from the same field — replaying related episodes together, as Wilson and McNaughton observed happening during sleep; reopening an old memory when something new touches it, which is Nader and LeDoux’s reconsolidation; and idle-time reflection, the default mode Raichle described.
Traag, Waltman & van Eck 2019 · Traag, Van Dooren & Nesterov 2011
Memories form a graph, and a graph has neighbourhoods. Finding them is a studied problem, and the modern standard is the Leiden method of Traag, Waltman and van Eck (2019), scored with the CPM objective from Traag’s earlier 2011 work. That objective is the piece of published science we have in common with them, and the credit for it is theirs.
What clusters your memory every night is ours, and it is a different machine, because our problem is one the standard was built for a different world to solve. Three differences carry the weight:
Communities keep their identity. Run ordinary clustering twice on a slightly changed graph and you get two unrelated sets of groups with fresh arbitrary labels. Ours tracks every community across every nightly pass and through every split and merge, so “the pricing cluster” is still the same thing next week and its history is something you can ask about. Standard implementations leave that idea out entirely.
It settles its own resolution. How coarse or fine the grouping should be is normally a number a human picks, and re-picks whenever the data shifts. Ours decides that itself against several competing goals at once, every cycle, because a laptop at three in the morning has to settle it alone.
It is built to run out of time. Clustering here has a hard wall-clock budget: the idle window, to the second, and it has to hand back a good grouping the moment that window closes. That single constraint shapes the whole design, and offline graph tooling is free of it.
Same question as theirs, same scoring function, an entirely different answer to how you compute it under these conditions. We name them because that is how honest engineering reads — you say whose shoulders you stand on, then you say plainly what you built yourself.
Kanerva 1988, 2009 · Plate 1995 · Gayler 2003
Pentti Kanerva’s sparse distributed memory, and the wider vector-symbolic tradition that Tony Plate and Ross Gayler shaped, represent things as very wide patterns you can combine and compare whole. It is why a moment, a piece of knowledge and a habit can share one store while staying distinct, and why you can find a memory by its shape as well as by its words.
Shannon 1948
Some gaps in what it knows are worth asking about and most are noise. Shannon gave us the measure of how much an answer would actually tell you, and the engine uses it to decide which few questions are worth keeping. That measure is the only thing standing between you and a system that reports every gap it finds.
Wiener 1948 · Ashby 1952, 1956 · Pask 1975, 1976
An old and unfashionable field that got there first. From W. Ross Ashby comes the idea that a system stays alive by holding a few essential variables inside survivable bounds, which is exactly what the engine watches while it reorganises itself, in place of optimising one number into the ground. From Gordon Pask comes something we use almost literally: his teach-back, where understanding is demonstrated by explaining a thing back and being corrected where the explanation fails. After each consolidation the engine attempts precisely that on its own conclusions and flags every contradiction it finds. Wiener named the field in 1948; it deserves more than nostalgia.
Murray, Lesser & Lawson 2005
This is where the name comes from, and it is a design decision rather than a metaphor. Monotropism, the account of attention Dinah Murray, Mike Lesser and Wenn Lawson published in 2005, describes deep narrow focus over shallow broad attention, and that is how recall here behaves. The exact words ahead of the gist. Rare things kept rare. Most memory systems are built to generalise; this one is built to be literal, which is precisely what you want from something that has to remember what you actually said.
Credit where it belongs entirely to others: the text embeddings come from the openly published bge-small-en-v1.5 model, the encryption is a standard audited implementation, and the numerical libraries underneath are other people’s excellent work. We name all of it in the repository.
Two honest caveats. These are working principles borrowed from the science, and calling the result a brain would be a stretch any serious engineer should refuse. A good story about mechanism also proves very little on its own, which is why everything here is measured, and why the numbers and the tests that produced them ship in the repository.
No account, no sign-up, no API key of ours, no analytics. The memory is an encrypted file in your home folder. Everything is worked out on your own machine, and the only thing that goes to the internet is the model call your assistant was already making.
Want it gone? Delete the folder. That is the entire deletion story.
You can teach it directly, ahead of any conversation. Drop a file on the dashboard — notes, a runbook, a PDF, a spreadsheet — and it reads the file, breaks it into pieces and connects those pieces to what it already knows. Anything it already holds is recognised and kept once.
The whole surface, in plain terms. Most of it runs on its own while you work. The full version of this page lists every feature with the numbers behind it.
That one line brings the engine, the dashboard and the connector your assistant talks to. Claude Code users then install a plugin and are finished; any other assistant that speaks the standard connector protocol takes one more line. macOS and Linux are fully supported, Windows is in beta.
Free and open source under MIT, in full, permanently.
A side effect worth knowing about. An assistant that has forgotten something goes looking for it: reads files, searches the repository, spends thousands of tokens rebuilding a fact you already gave it. Handing it that fact from memory costs about 88% less.
The dashboard keeps your own count, live: how often memory answered in place of a search, and what that saved you.
Every number on this page ships with the harness that produced it. The benchmarks live in the repository. Clone it and run them yourself.
| What was measured | Result | Command |
|---|---|---|
| Finding the right memory | R@5 0.962 | python -m bench.longmemeval_blind |
| A replaced fact is still reachable | 1.000 | python -m bench.contradiction_longitudinal |
| Its original wording survives | 1.000 | python -m bench.contradiction_longitudinal |