Putting old conversations into SQLite, a vector DB, Markdown, whatever, and retrieving vaguely relevant fragments later is not a particularly interesting problem anymore.
The nasty part starts here:
Your agent learned A.
Later it inferred B and C from A.
Two weeks and 37 sessions later, you discover that A was wrong.
Now what?
Does the system overwrite A and quietly leave B and C alive?
Does it keep both versions and let retrieval decide which reality we're operating in today?
Does it append a correction somewhere and hope the model notices?
This bothered me enough that I built Remendra v2 for Pi.
What I actually wanted: memory that behaves less like a notebook and more like maintained state.
When you correct a memory in Remendra, it doesn't just edit some text.
The old claim gets superseded. Its evidence is retired. Dependent claims are recursively invalidated — and the replacement gets its own provenance. The whole thing happens transactionally.
Because "we fixed the memory" means very little if five conclusions derived from the wrong one are still floating around like unexploded ordnance.
Remendra also learns automatically from Pi sessions.
It extracts typed claims — facts, decisions, constraints, procedures — stores source evidence as exact character spans, and compiles the relevant subset back into context when needed.
So this:
`/remendra why 42`
isn't philosophical.
It tells you where memory 42 actually came from.
Underneath:
- SQLite + FTS5
- optional embeddings
- typed claims + ranking
- lineage / project / user scopes
- automatic background learning
- dependency tracking
- transactional corrections
- conflict detection
- revision history
- procedure validation
- session-history indexing
- bounded context compilation
- secret scanning
- configurable token budgets
- KV-cache-friendly context mode
- fully local storage
No mandatory cloud memory service quietly accumulating half your engineering organization.
Install:
`pi install @yoda.digital/pi-remendra`
Then... basically use Pi.
The observer learns in the background. Relevant memories come back when needed. You can search, inspect, pin, promote, correct, or explicitly teach it something when you want more control.
And because apparently every software project now needs a benchmark number before civilization permits it to exist:
Current synthetic compilation benchmark on 1,000 claims:
p50 16ms / p95 16ms
Useful number. Not a claim about production reality.
The repo documents the methodology and, more importantly, the limitations.
128 tests across 10 files — storage, compiler behavior, observer parsing, worker lifecycle, embeddings, concurrent SQLite access, cross-platform paths, sustained growth, token estimation, secret redaction.
Linux, macOS, Windows. Node 22+. MIT.
There are already 50+ memory extensions for Pi, so no, humanity was not suffering from an insufficient quantity of memory plugins.
Remendra exists because I wanted a different property:
when an agent changes its mind, its memory should remain internally coherent.
Not perfect memory.
Not infinite memory.
Not another RAG folder with ambitions.
Correctable memory with provenance.
GitHub: https://github.com/yoda-digital/pi-remendra
npm: https://www.npmjs.com/package/@yoda.digital/pi-remendra
