A quick update that did not make it into the locked application: the open memory server and free API are seeing real adoption, roughly 300 active users now and growing, all developer-led and unpaid. If it is useful for evaluation, the live 3D memory graph is at graph.mnemoverse.com and the code is at github.com/mnemoverse/mcp-memory-server. Happy to answer any questions here.
Likely AI-generated. Pangram flags 100% of this text as AI-written.
1
Honest evals and provenance for AI-agent memory
ProposalGrant
Closes August 14th, 2026$0raised
$15,000minimum funding
$50,000funding goal
Offer to donate
22 daysleft to contribute
You're pledging to donate if the project hits its minimum goal and gets approved. If not, your funds will be returned.
Project summary
AI agents forget between sessions, and the thing sold to fix that, so-called AI memory, is usually just vector search over old chat logs. It has no record of where a fact came from or whether the fact is even true, and there is no clean way to make it forget. So agents quietly pile up wrong things and repeat them, and the moment agents start reading each other's memory, one wrong fact spreads. I'm building two things for this, both open. One is a test: drop a known-false memory into a system and watch whether it spreads or gets caught, run across several memory systems, not only mine. The other is a small spec that records, for every memory, where it came from and whether anyone checked it, so the memory can be audited, corrected, or deleted. It grows out of research I published on the geometry of memory (SLoD, arXiv:2603.08965), and an engine that already runs in the open.
See it and try it
Explore the memory graph in 3D, live and clickable: https://graph.mnemoverse.com
Install the memory server and give your own agent persistent memory with one key (MIT): https://github.com/mnemoverse/mcp-memory-server
The honest benchmark numbers, each with the condition it holds under: https://benchmarks.mnemoverse.com
The product and docs: https://mnemoverse.com
The research it sits on: https://arxiv.org/abs/2603.08965
What are this project's goals? How will you achieve them?
The goal is a shared, reusable way to measure whether an agent's memory spreads false claims, plus a provenance spec other people can actually adopt. Here is how I get there. I build a testbed that plants one controlled false memory in a system and measures whether it propagates or gets caught, with runs pinned and reproducible and scored under several judges, not one, so the number is not an artifact of the judge I happened to pick. Then I add provenance scoring, a verification status on each memory, and feedback-decay, and I measure how much they hold the false memory back without hurting normal task performance. The testbed, the protocol, and the spec all ship open. My prediction, and it is falsifiable: provenance-gating pushes propagation below an untreated baseline without costing utility. If it does not, that is a real finding too.
How will this funding be used?
$15k, the minimum, covers the LLM API credits for the evaluation runs, the compute for the graph and multi-agent experiments, and the open-source release of the eval and the spec. That is enough to get a real result out in public. At the full $50k, and up to roughly $80k, I do the same across more memory systems, bring on a part-time engineer so the testbed is something other people can run instead of just my scripts, do a larger multi-agent run, and write proper docs. Either way everything ships open.
Who is on your team? What's your track record on similar projects?
Eduard Izgorodin: I'm a software engineer with twenty years on production systems and formal training in mathematics. I wrote SLoD (arXiv:2603.08965), and I built the memory engine and the benchmark pipeline myself. On this exact kind of work, my track record is that I audit my own numbers: I found two oracle leaks in my own LoCoMo pipeline, removed them, and published the lower, honest figure (about 65% retrieval recall out of the box, judge-free) instead of the flattering one. I also showed that swapping the LLM judge alone moves the same answers by about 40 points, and I ran that check on a competitor's answers, not just mine. Olga Timoshina handles operations and coordination; we have worked together for more than ten years. What is already live, mostly without funding: an MCP memory server (MIT, in the official registry), a Core API, a Python SDK, a 3D visualization of the memory graph, and an OAuth connector working inside Claude.
What are the most likely causes and outcomes if this project fails?
The most likely ways this goes wrong: the geometric and provenance approach might not contain false-memory propagation any better than a dumb baseline; the honest eval might expose real weaknesses in my own system; or other researchers might just be slow to pick up the testbed. If any of that happens, I publish the negative or limited result plainly instead of burying it. I have done exactly that before. In my Consistency Tax work I had headlined a detection mechanism, then under an honest, preregistered protocol it came out no better than chance, so I killed it and published that. Even a clean negative result moves the field, because right now nobody can measure this at all.
How much money have you raised in the last 12 months, and from where?
Nothing. Zero raised, zero received; I have self-funded this. I do have open applications in for this and closely related work (Foresight, BlueDot, Emergent Ventures, the IMI Fellowship, grantmaking.ai, and the Long-Term Future Fund), and none of them has come back yet. I would rather just be upfront about all of it.