Memory your AI agent can be held accountable for.
FerriteMem is a deterministic memory layer for AI systems, with no language model in its core. Every retrieval is reproducible, every result is cited to a stored record, and the whole engine runs inside your own boundary. Built for the places where “the AI said so” is not an acceptable answer.
The two empty slots are the whole difference. A model that rewrites the question can misread it, and a model that phrases the answer can invent it. Removing both is what makes a result reproducible — and what makes it possible to show where the result came from.
What FerriteMem is
a memory that sits beside the model, not inside itMost “AI memory” lives inside a language model — in weights and context windows you cannot inspect. FerriteMem takes the opposite position: a store of records and events that lives beside your model, which your model reads from and writes to under a human gate. The model reasons; FerriteMem remembers — verbatim, reproducibly, and with a citation for every result.
Deterministic measured
The same query returns the same answer, every time. No sampling, no drift. In a regulated audit, reproducible is the difference between evidence and hearsay.
Cited by construction measured
Every retrieved result points to the exact stored record it came from. FerriteMem returns evidence and leaves the judgment to you — it never invents an answer to fill a gap.
Unpoisonable core by design
Malicious input is stored as a record and never executed. There is no model in the core to hijack, so a prompt-injection attempt becomes a logged entry rather than a command.
Human-gated learning measured
FerriteMem proposes what is worth remembering; a person approves it. Memory improves with use through an audit trail rather than silent weight updates.
Conflict resolution without a model measured
When two stored facts disagree, FerriteMem decides by rule — deterministically, the same way every time. No language model picks between your contradictions, so the resolution is explainable and replayable.
Token-free memory by design
The memory layer runs no language model, so remembering, retrieving and resolving conflicts spend zero tokens — and precise cited records mean your own model reads a tighter context too.
The metric that matters
finding something is easy; finding everything is the jobMost systems measure whether they found something. Regulated work needs everything.
The one record that slips through is the one the auditor asks about. That is completeness, and it is what FerriteMem is built for: on a public long-memory benchmark it retrieves everything relevant 94.8% of the time — the strict metric most systems do not publish at all.
Why completeness changes everything“Find me something”
the chatbot question
One relevant result is a win. If a second existed and never surfaced, no harm done.
“Find me everything”
the audit question
Every relevant result must surface. Miss one and the answer is wrong, however many you found.
Conflict resolution
the result with no model in itWhen two stored facts contradict each other, something has to decide which one is current. FerriteMem decides it by rule — no language model anywhere in the path — and holds accuracy as the corpus grows from a few hundred facts to eighteen thousand.
| Corpus | Facts | Direct conflict | Chained |
|---|---|---|---|
| 6k tokens | 455 | 0.970 | 0.670 |
| 32k tokens | 2,310 | 0.960 | 0.640 |
| 64k tokens | 4,580 | 0.980 | 0.570 |
| 262k tokens | 18,332 | 0.960 | 0.390 |
Flat where it should be flat
Direct conflicts hold between 0.96 and 0.98 across a fortyfold increase in corpus size — and the 0.980 is within two-question noise, so we call it flat rather than rising.
Declining where it declines
Chained conflicts fall from 0.670 to 0.390 as the haystack grows. That is the honest curve and we publish all of it, because a page showing only the 0.670 would describe a system nobody runs.
All eight figures reproduced exactly
Every number above was re-measured seven weeks after it was first recorded, on the same corpus and the same configuration. All eight came back identical.
Which is what the absence buys
Not a better average — the same answer twice. A system with a model in this path cannot promise that, because the model is free to decide differently tomorrow.
Results
every number with its terrain named| What | Result | On | Status |
|---|---|---|---|
| Retrieval — recall_all / recall_any | 0.948 / 0.994 | public long-memory benchmark, full N=500, retrieval-scored | measured |
| Direct conflict resolution | 0.96 – 0.98 | no model in the path; flat from 455 to 18,332 facts | measured |
| Chained conflict resolution | 0.67 → 0.39 | four scales; the full curve, including its decline | measured |
| Fast-path latency | 19 ms | deterministic recall; 210 ms on the reranked path | measured |
| Write throughput | 7.8 / s | 64 concurrent writers, zero errors; each write searchable before it returns | measured |
| Reproducibility | 8 of 8 | eight figures re-measured seven weeks later, same corpus and configuration, unchanged | measured |
| Cross-tenant leaks | 0 | adversarial isolation testing; scope enforced inside every query | measured |
| Independent evaluation | in progress | scored by the evaluator on held-out data, with their model and their judging | in progress |
How it fits
different kinds of memory, each governed correctlyA fact you were taught, a thing that happened, and a decision that was made are not the same. They live for different lengths of time, and not everyone should be able to change them the same way. FerriteMem keeps these kinds apart, so passing context stays flexible and the record that must never quietly change is protected.
What is happening now
The live context of the moment — short-lived, and free to change as the work goes on.
What happened
Events and outcomes, kept word for word — the trail you can go back and check.
What was decided and known
The lasting record. It outlives every session and changes only through a person’s approval.