What it does
One question. One answer drawn from your own sources.
Mnemosyne OS vectorizes your source code, your images, your PDFs, your docs, your notes, your conversations, and more. Then it chooses which vaults to query, doses the context, ranks it and drops the sources that add nothing. All of it runs on your processor. Not a single line leaves your disk.
The dose matters more than the quantity. With the same model, the same question and the same retrieval, 91 injected sources give a hollow answer. 12 chosen sources give a structured synthesis.
The architecture
Everything fits inside your machine. Only one line leaves it.
The kernel queries your memory, sorts it, and consolidates it when the machine is at rest. The cartridges plug into it without ever touching it: the reader, the CRM, the translator. Each one writes into its own vault, isolated from search and invisible to the rest.
Cognitive firewall
A checkpoint stands between your data and the model.
The model never touches your vault . Mnemosyne OS assembles every retrieval on your machine, filters it, and hands the model only the chosen sources. That boundary stops a clever prompt from exfiltrating your memory.
Zero-Trust applies even on your own machine: every SDK or MCP request carries a scope-limited signed token (FGAC ). When nothing relevant comes back, Mnemosyne OS says so instead of inventing an answer.
How it works
Four mechanisms, and why they exist.
I
The vaults
Your memory is cut into watertight vaults, one per life domain. Each vault has its own rights: who can read it, what it may be mixed with, whether it appears on the map. Your private journal only mixes with your code if you decide so. Never by default, never by accident.
II
The topics
Memory sorts itself into topics on its own. That structure is stored as data. It makes the rest possible.
III
The dream state
When the machine is at rest, Mnemosyne OS rereads its own memory, topic by topic. It writes out its ledger: every occurrence, every value, every date, the running total. The ledger settles alongside the raw, never in its place. That earns +4.9 points on the real query path, and 1/8 → 5/8 on the hardest category.
IV
The sandbox pact
Each application gets exactly one vault. That vault is isolated from federated search, invisible to the map and the dream. The app cannot widen its own walls. The network cannot open permanence. Only your hand on your keyboard can. An agent can propose a memory. Only you can engrave it.
The engine
Any model, local or cloud, on the same memory.
Pick the best model for each task, the cloud for raw power, a local model for absolute privacy. Your memory stays the same underneath, so you switch providers without losing anything.
Reasoning & chat
Embeddings & resonance
Hubs & providers
Under the hood
The engines.
Mnemosyne OS runs several independent engines. Each one does a single job.
Embedding engine
It tries providers in order: cloud, local ONNX, then Ollama. It reports a failure instead of returning a null vector. An embedding that failed in silence would become a memory you can never find again.
Retrieval engine
It keeps a decrypted vector cache in RAM, quantized to int8 so it scales. It unions the ANN search with an exact term match, then re-ranks what comes out.
Spine engine
It classifies every memory by its semantic nature, a "spine" and a set of tags. The taxonomy lives as data, so a new category needs no code change.
Dream State
Consolidation runs at two speeds. A fast tier extracts facts while you work. A heavier tier runs when the machine is at rest, resolves contradictions and links sessions. What it writes sits alongside the raw memory, never in its place.
Adaptive RAG, the gearbox
It picks which sources to inject, using top-k, MMR and low-discrepancy sampling. How deep it goes follows the model you run and the thinking mode you pick.
Voice: STT and TTS
Speech to text and text to speech run as separate engines. Small STT models run inside the app, large ones in an isolated GPU or CPU sidecar. TTS can use your system voice, a cloud voice or a local one. It is timed to the sample, so playback never breaks. Without an NVIDIA GPU it falls back to the CPU rather than blocking.
Theia, image memory
Theia is the Titaness of sight and the sister of Mnemosyne, so the memory OS gains an eye. It embeds the images in your vaults on your own machine, with SigLIP 2. Ask in chat for "the pieces that look like a blue cup" and the matches come back as thumbnails. Three channels find them and are fused by rank: semantics, pixel palette, emergent categories. It is off by default. An engine that is cold or still indexing says so, instead of answering "no matches".
572 IPC channels
Zod-validated channels connect every engine to the interface. They are generated from the code and checked by a drift test on every build.
The modules
Nine modules. One kernel.
Mnemosyne OS runs nine independent modules, each cut for its task, all plugged into the same memory core. This list is what you see and use. The internal engines stay sealed.
Neural Map
Your memory drawn as a graph you move through: nodes are memories, edges are measured semantic links, tuned live.
Dream state
A consolidation engine that rereads and reconnects your memories during rest phases.
Vaults
Memory partitioned by life domain, each with its own protection level and consent boundary.
Adaptive RAG
Retrieval depth and ranking adapt to the model you run, from a laptop LLM to a cutting-edge cloud model.
Voice assistant
Local or cloud voice, streaming STT/TTS, gapless local reading.
Multimodal chat
Text, voice and file conversation, with live retrieval from your own vaults.
MnemoHub
A catalog of cartridges signed by a sovereign wallet and verified client-side before any render.
Sovereign wallet & Engramm
A local sovereign wallet drives the license (verified on Base), the pseudonym and the cloud credits. No account, no password, no gas fees.
Spatial canvas
Widgets live on a 2D canvas. Position carries meaning.
Go deeper
The architecture, in a paper you can cite.
The Resonance Engine groups the engines above and the governance layer that rules them. A technical whitepaper describes it, deposited under a permanent identifier and released under CC BY 4.0.