ModelNumquamOblita, or MNO, is my local-first memory project for agents.
The simple version: it helps an assistant remember from real evidence instead of guessing from vibes.
MNO is built around a small rule that matters a lot:
No memory claim without evidence.
That means memories are not just loose notes floating around in a prompt. They come from source material, get shaped into reviewable memory, and stay tied to the evidence they came from. If MNO cannot find enough support for something, it should be able to say so.
Long-term memory for agents can get weird fast.
Sometimes systems remember things that were never said. Sometimes drafts turn into "truth" without anyone noticing. Sometimes a model sounds confident because confidence is cheap, not because the evidence is there.
MNO is my attempt at a more grounded path:
- keep the source evidence close
- separate drafts from reviewed memory
- let a human stay in charge of what becomes durable truth
- give agents a local memory runtime they can query without taking over the whole system
- make it possible to inspect why something was recalled
It is not trying to be a giant hosted memory platform. It is a local, inspectable memory runtime for people building agents who care about provenance, correction, and honesty.
These are the plain-language diagrams. They are intentionally simple because the main idea should not require a PhD in repo archaeology.
How raw source material becomes usable, reviewed memory.
How an assistant, MCP sidecar, or integration talks to the local runtime.
The practical shape of the current system.
How a runtime answer moves through memory, evidence, and the decision to answer or abstain.
More diagrams live in:
MNO can help you build a local memory layer for:
- personal assistant experiments
- agent sidecars
- MCP-based tools
- local research or writing companions
- systems where memory needs to be reviewable instead of magical
It can start from raw files and folders, or from an existing MNO store. The setup flow can import source material, build draft memory, let you review what should become durable, and then run a local memory runtime over that reviewed set.
MNO's benchmark story is about evidence, not bragging rights.
The useful question is: when the system remembers something, can it find the source material that supports that memory?
Current public aggregate runs:
- LongMemEval-S retrieval/source support: R@5
0.9660, R@100.9760, gold source in store1.0000 - LoCoMo retrieval/source support: eligible R@1
0.6075, R@50.8491, R@100.9258, MRR0.7157
These are retrieval and source-support scores, not final answer F1. They show that MNO can usually recover the right evidence before an assistant speaks. That is the part this project cares about most: less "trust me", more "here is what I found."
Read the benchmark notes and public-safe aggregate summaries here:
MNO can:
- import raw source files like
.json,.jsonl,.txt,.md, and mixed folders - preserve bounded original wording for quote and provenance lookups
- build draft episode cards for human review
- keep draft/proposal/helper memory separate from reviewed truth
- compile reviewed episode cards for runtime use
- run locally through the desktop shell, HTTP runtime, MCP server, or integration routes
- show evidence and context for why memory was recalled
- abstain when evidence is too weak
The main public integration boundary is integration-v1.
MCP is available when you want tool-style local agent integration. Compatibility adapters also exist for reference, openclaw, and nanobot.
MNO does not promise:
- magic memory
- silent truth mutation
- unreviewed drafts becoming published memory
- a hosted multi-user memory service
- that every old internal route is a stable public contract
The bias here is deliberate: better to be a little slower and more inspectable than fast and quietly wrong.
Use the setup workspace if you want the guided path:
./launch_setup_workspace.shPowerShell:
./launch_setup_workspace.ps1Command Prompt:
launch_setup_workspace.batOr run local setup directly:
./setup_local.shPowerShell:
./setup_local.ps1Command Prompt:
setup_local.batThe setup workspace is the easiest way to:
- choose files or folders to import
- create or append to a local memory store
- build reviewable memory
- export or install an integration bundle
- prepare MNO for an assistant, MCP client, or sidecar
Import raw source:
python3 tools/import_memories.py --input /absolute/path/to/source-or-folder --store runtime/imports/atoms.sqlite3Start the local runtime:
python3 tools/run_live_runtime.py --memories runtime/imports/atoms.sqlite3Launch the desktop shell:
npm run desktop:dev --prefix app/desktopRun MCP against the runtime:
python3 tools/run_mcp_server.py --transport stdio --runtime-base-url http://127.0.0.1:7340engine/: runtime, retrieval, memory, MCP, adapters, and local UIapp/desktop/: Electron desktop shelltools/: setup, import, build, runtime, and MCP launcherstests/: validation for setup, runtime, MCP, adapters, packaging, and contractsruntime/: empty local workspace skeleton for generated datadocs/: guides, API notes, security/privacy docs, and diagrams
Generated runtime data is intentionally not committed. Your imported stores, setup reports, diagnostics, desktop logs, and local state should stay local.
If you are new to the project:
If you are integrating an agent or tool:
Integration-specific notes:
Longer public writeup:
The short technical shape is:
raw source -> import/normalize -> atoms.sqlite3 -> draft episode cards -> human review -> reviewed episode cards -> runtime
The runtime includes bounded retrieval, reviewed memory, optional local ANN candidate generation, raw-context lookup for exact wording, and verification/abstention behavior. The ANN and raw-context sidecars are helpers only. They are not truth sources and do not bypass review.
Engineer-facing diagrams:
