live demo · synthetic memories try it above: search friday deploys — then open the result marked fading. open full screen ↗

Your assistant forgets you every session. This one doesn't.

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.

pip install iai-pme GitHub PyPI

How it works

Five things happen. It handles all five.

1

You just talk to your assistant

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.

2

Your exact words come back

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.

3

While you are away, it tidies up

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 can watch this happen. The demo at the top of this page is that same screen: search it, open a memory, pin it, let it fade, drop a file in.
4

Next session, the right piece is already there

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.

5

When you change your mind, both versions stay

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.

What it keeps

Moments

Every message of every session, exactly as written.

Knowledge

What it works out from those moments while your machine is idle.

Habits

How you like to work, applied on its own.

Pinned

What you marked as permanent. It stays permanent.

The parts that matter are ours

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:

Hippo — the store

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.

MOSAIC — the sorting

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.

Lilli HD — the shapes

Gives moments, knowledge and habits different internal shapes, which is what lets you find a memory by its shape as well as its wording.

Rust core — the speed

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.

What it is built on

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.

Memory neuroscience

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.

Network science

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.

Hyperdimensional computing

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.

Information theory

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.

Cybernetics

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.

Autistic cognition

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.

It never leaves your computer

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.

Teach it something directly

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.

Everything it does

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.

Remembering

  • Writes down every turn, yours and the assistant's, word for word
  • Hands back the right piece on a cue, before you ask twice
  • Answers by time — "what did I say about pricing in May"
  • Finds a memory by its shape as well as its wording
  • Plain text search, and a way to write one in by hand

Keeping you honest

  • Memories that contradict your question come back next to the ones that match
  • When a fact changes, the old one is filed and both stay reachable
  • Nothing is ever rewritten, so the original sentence survives
  • Each memory arrives with its age and how often it has been revised

Costing you less

  • A fact from memory in place of a repository search — about 88% cheaper
  • What it adds at the start of a session stays under a fixed small budget
  • A live count of what memory answered and what that saved
  • Tells your assistant to clear old traffic of ours out of the conversation
  • Long summaries are compressed; your own words stay whole

Working while you rest

  • Learns the hours you are away and does its heavy work then
  • Sleeps, wakes and puts itself back to sleep on its own
  • Every night it groups what is related, strengthens what you keep coming back to, and lets the rest fade
  • At most one small model call a night, through the subscription you already pay for
  • Prepares what it thinks you will need next, before your next message

The dashboard

  • Search the memory and watch the map collapse to what that memory is wired to
  • Pin one to keep it for good, let one fade, or rescue it mid-fade
  • Drop in a file — notes, a runbook, a PDF, a spreadsheet — and watch it studied
  • Folders that organise themselves, by time, topic and conversation
  • Contradictions drawn as red links between the old fact and the new one
  • Also ships as a desktop app for macOS and Linux

Fitting your setup

  • One command wires it into six assistants, or all of them at once
  • Leaves a config it did not author alone and prints the block for you
  • Swap in your own text model if you work in another language
  • A terminal tool for the moments you want to ask memory directly
  • Free, MIT, no paid tier waiting for you later

Looking after itself

  • 27 checks on demand, and it repairs what it finds
  • Your assistant runs that check for you if the engine goes quiet
  • Updates itself and then proves the update by asking the engine its version
  • Tells you a new version exists and waits for you to say go

Your data, your keys

  • Everything on disk is encrypted, with the key readable only by you
  • Rotate the key, or recover with the previous one if you rotated too early
  • No account, no sign-up, no key of ours, no analytics, no network calls
  • Delete the folder and it is gone. That is the whole story
fifteen tools your assistant can call:
memory_recall · memory_temporal_recall · memory_recall_structural · memory_search · memory_capture · memory_contradict · memory_reinforce · memory_consolidate · profile_get_set · topology · schema_list · events_query · episodes_recent · curiosity_pending · camouflaging_status

Getting it running

pip install iai-pme

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.

It also makes your assistant cheaper

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 here ships with the test that produced it

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 measuredResultCommand
Finding the right memoryR@5 0.962 python -m bench.longmemeval_blind
A replaced fact is still reachable1.000 python -m bench.contradiction_longitudinal
Its original wording survives1.000 python -m bench.contradiction_longitudinal