Mnemosyne OS

The sovereign AI Operating System

Open to build on · Private at the core

English ·  Français ·  Español ·  Deutsch ·  Português ·  Русский ·  中文

Everyone is building the intelligence. Mnemosyne OS builds the relationship: the memory that makes an AI truly know you, across sessions and across time. On your machine. Yours to see.

→ Why the relationship layer

🔏 Every installer above is cryptographically attested to this exact repo, workflow and commit, via GitHub Artifact Attestations (Sigstore-backed build provenance). Don't take the download on faith: verify the file you got matches what our CI actually built:

gh attestation verify Mnemosyne-OS-Infinity-Setup-x64.exe -R Mnemosyne-OS/Mnemosyne-Neural-OS

🌐 mnemosyne-os.io, the product, for builders · mnemosyne-os.com, the company, press & labs · 📖 docs.mnemosyne-os.io, the user guide

---

[!IMPORTANT] 🤖 New in 1.6.0: MnemoHermes, your memory on Telegram and by voice (beta). MnemoHermes installs Hermes Agent with one button and connects it to your vaults. Create your own Telegram bot and ask your memory from your phone, typed or by voice note. In the app, say "ask Hermes to …" and the orb hands it the task.

→ See how it works: mnemosyne-os.io/hermes · The cartridge on GitHub

[!TIP] 📖 The user documentation is live at docs.mnemosyne-os.io, with every engine explained step by step, in English · Français · Español.

🌍 Fully multilingual: the OS speaks your language

The entire interface is localized in seven languages: onboarding, settings, chat, the voice assistant, every dialog. Switching language even re-selects the ★ recommended embedding model for it, so retrieval quality follows your language, not just the labels. Open windows pick the change up instantly.

	Language		Status
	English	Your memory. Your machine. Your rules.	Stable
	Français	Ta mémoire. Ta machine. Tes règles.	Stable
	Español	Tu memoria. Tu máquina. Tus reglas.	Stable
	Deutsch	Dein Gedächtnis. Deine Maschine. Deine Regeln.	Beta
	Português	Sua memória. Sua máquina. Suas regras.	Beta
	Русский	Твоя память. Твоя машина. Твои правила.	Beta
	中文	你的记忆。你的机器。你的规则。	Beta

Sovereign, local-first memory, in your language: un système d'exploitation de mémoire souverain et local · un sistema operativo de memoria soberano y local · ein souveränes, lokales Gedächtnis-Betriebssystem · um sistema operacional de memória soberano e local · суверенная локальная операционная система памяти · 主权的本地优先记忆操作系统.

---

Not another agent-memory library

Mem0, Zep and Letta give agents a memory layer you wire into a cloud stack.

Mnemosyne OS is the control surface for your memory, your agents and your models, and it runs on your machine. You choose which model may read your memory, and a human governs it. On LongMemEval-M holdout questions, never used to tune the engine, it scores 77.1% in hybrid mode: embeddings and search on your machine, answers from a cloud model, gemini-3.8-flash (audit it yourself).

The AI that remembers you, not infrastructure you plug into someone else's.

Where the project lives

Published by XPACEGEMS LLC. These are its official addresses:

Product	mnemosyne-os.io
Organizations	mnemosyne-os.com
Documentation	docs.mnemosyne-os.io
Source	this repository
Packages	the npm scope @mnemosyne_os: the list

---

Why call it an "OS"?

Not because it has a kernel or drivers. Because it does what an OS does: it manages resources on behalf of processes that shouldn't have to manage them themselves. Linux does that for programs (CPU, RAM, disk, network). Mnemosyne OS does the same thing for AI agents, and the resources are just different:

An agent needs	Mnemosyne OS manages it via
Memory	Vaults, SQLite + vector stores, partitioned by domain, with AES-256 encryption at rest you arm
Context	Chronicles + semantic retrieval, the agent never rebuilds its past by hand
Compute	Routing across model tiers (budget/standard/premium, local/cloud) by task complexity
Hardware	Real GPU/CPU dispatch for local speech (CUDA detection, isolated sidecars) so a heavy model never blocks the app
I/O	A signed intent protocol (query / ingest / forget / focus) instead of raw reads and writes
Security	FGAC, scoped JWTs, Zero-Trust IPC validation
Persistence	Cross-session continuity, no cold start on every invocation

This isn't a marketing stretch invented for this repo. MemGPT (Packer et al., UC Berkeley, 2023, arXiv:2310.08560) proposed the same "OS for LLMs" analogy in a peer-reviewed paper, virtual context management modeled on OS memory hierarchies. Mnemosyne OS takes that same premise further: not a single-session context-paging technique, but a system that runs continuously, isolates multiple agents, and persists on the machine as a daemon, not a library you import and lose on exit.

---

The flagship app: Mnemosyne OS Infinity Edition

The reference application of the ecosystem: a local-first AI Operating System that puts a sovereign memory core under strict user control. It runs LLMs locally or in the cloud, keeps every encrypted vault on your machine, and, for agent-to-agent sync, can speak over a libp2p transport (@mnemosyne-workspace/mnemosync-p2p).

Unlike fragmented AI wrappers, Mnemosyne OS never exposes your knowledge vault indiscriminately. Every agentic connection is governed by FGAC (Fine-Grained Access Control) and 400 Zod-validated IPC channels, ensuring total sovereignty over what executes, what's stored, and what syncs.

Core Modules

Module	Description
🧭 Neural Map	Your memory rendered as a living mathematical topology, nodes are memories, edges are semantic similarity between them, tuned live
🧩 MnemoHub	A store of cartridges (mini-apps) whose catalog is signed by a sovereign wallet and verified client-side before anything renders
💤 Dream State	A consolidation engine that replays and links memories during idle phases
🗄️ Vaults	Memory partitioned by life domain, each with its own protection level and consent boundary
🎙️ Voice Assistant	Local or cloud speech, streaming STT/TTS, gapless local playback
💬 Multimodal Chat	Text, voice, and file-grounded conversation with live retrieval from your own vaults
🧠 Adaptive RAG	Retrieval depth and ranking scale to the model you're running, laptop LLM to frontier cloud model
🔑 Sovereign Wallet & Engramm License	A local Web3 wallet drives licensing (verified on Base), pseudonym claims, and cloud credits, no account, no password, no gas fees
🎨 Spatial Canvas	Widgets live on a 2D canvas, not stacked tabs, position carries meaning

Under the hood: the engines

Not one big "AI" black box. Several independent, purpose-built engines:

• Embedding engine: a priority-ordered chain of embedding providers (cloud, local ONNX, Ollama). Tries each in order and fails loud rather than returning a null vector, a failed embedding must never silently become an invisible memory.
• Retrieval engine: an in-RAM, decrypted vector cache (int8-quantized to scale), ANN search unioned with exact term matching before the final re-rank pass.
• Spine engine: classifies every memory by semantic nature (its "spine" + tags), from a taxonomy that lives as data, not hardcoded logic, so new categories don't require a code change.
• Dream State: two-speed consolidation. A fast, low-latency tier extracts facts during active use; a heavier tier runs at idle/night to resolve contradictions and link memories across sessions. Output is appended alongside raw retrieval, never silently replacing it. See the benchmark results below.
• Adaptive RAG (the "gearbox"): rather than injecting every retrieved candidate, context selection (top-k / MMR / low-discrepancy sampling) scales to both the model tier you're running and the thinking mode you pick.
• Theia, the vision engine: named for the Titaness of sight, who in the myth is Mnemosyne's sister. A complete image-memory engine: your images are embedded 100% locally (SigLIP 2, in an isolated sidecar) into their own vector space, recalled in chat as thumbnails through three rank-fused channels: semantic, pixel-color palette, and emergent categories the engine discovers on its own, and browsed in a living gallery. The human always outranks the model: rate, pin, describe, teach, rename or merge its categories. Honest by construction: a cold or still-indexing engine says so, instead of inventing "no matches". Off by default, behind one Settings toggle.
• Voice engines, STT and TTS, fully independent: speech-to-text runs small models in-process and large models in an isolated GPU/CPU sidecar (a big STT model loaded in-process can crash the whole app); text-to-speech runs system, cloud, or local (offline binary or GPU voice cloning), scheduled sample-accurately for gapless playback. No NVIDIA GPU → automatic CPU fallback, never a hard block.
• 400 Zod-validated IPC channels connect all of the above to the UI, auto-generated and checked by a drift test on every build.

📄 Deep dive: The Resonance Engine, technical whitepaper. The full architecture behind these engines: why memory should resonate rather than be looked up, how consolidation and adaptive selection work, and the LongMemEval results, kept current as the engine ships.

📚 Full documentation: the user guide lives at docs.mnemosyne-os.io; concepts, architecture, governance, and design decisions live in doc/.

How memory works

flowchart LR
    A["Document · conversation · file"] --> B["Vault<br/>domain-isolated, graduated protection"]
    B --> C["Chronicle<br/>content + semantic type + embedding vector"]
    C --> D["Semantic retrieval (RAG)"]
    D --> E["query() / ask()"]
    F["Dream State<br/>cold consolidation"] -. replays & links .-> C

    style B fill:#1a1a2e,stroke:#7c3aed,color:#fff
    style F fill:#1a0e1a,stroke:#ff6b9d,color:#fff

Proven on LongMemEval-M: not just a pitch

77.1 % (37/48)	48 holdout questions, never used to tune the engine, full-haystack (hard) variant, official LongMemEval judge, September 2026
85.4 % (41/48)	the 48 questions used to tune the engine, strict judge
Two passes	a question counts only when both passes get it right
Every answer	published with every raw judge reply, and a verify.js that recomputes each figure

LongMemEval is a public, independent long-term-memory benchmark. Its full-haystack variant surrounds every question's evidence with ~480 distractor sessions, the closest published setup to a real, lived-in memory vault, and harder than the -S slice most reported numbers use.

The protocol was published before the run. The holdout questions had never been answered before. The run uses the hybrid mode: embeddings and search run on the machine, and a cloud model, gemini-3.8-flash, writes the answers. It measures the SDK and MCP door that agents use.

In September an outside audit found a wrong verdict in our August result. The erratum corrects it to 35/48 (72.9 %) under the strict judge and 37/48 (77.1 %) under the flexible one. We then ran the whole benchmark again. July's composed 72.9 % stays archived under its DOI. The reader, the engine and the judges changed between these runs, so the figures sit side by side and never chain into a progression.

Don't take any of it on faith. Audit it. The published grader and per-question verdicts let you re-derive every score in one command, no engine and no network. Full methodology, root-cause analysis, and the raw run logs of both campaigns are public too:

🔍 Audit it yourself: every answer and a verify.js →  ·  live results page  ·  raw logs & methodology

Citing this work. Both the evidence and the architecture are archived under permanent identifiers, so they can be cited rather than merely linked:

Verification kit, ledgers, grader, raw logs	10.5281/zenodo.21727140
The Resonance Engine, technical whitepaper	10.5281/zenodo.21728283
Author	Tony Trochet · ORCID 0009-0009-1087-3917

Interface Gallery

Turn memory on for your images. One Settings toggle gives your vaults an eye: drop in a folder of photos and Mnemosyne OS remembers every image you add: indexed 100% locally, organized in a living gallery you can rate, pin and teach, and recalled in chat: ask for "the pieces that look like a blue cup" and your own photos answer.

---

Two doors between your IDE and your memory

You already run an agent next to your editor. It opens every session without the history of the project it is working in, so it reasons its way back to conclusions you reached weeks ago, and it will do that again tomorrow. Part of that history survives: the agent wrote it down itself. It sits in a dot-directory beside the code, usually gitignored, read by nothing.

Mnemosyne OS opens two doors onto it, and they run in opposite directions.

Door one, memory reads the agent. DocWatch watches a folder you deliberately point at, whatever its name, so .claude/…/memory is treated like any other source and what your agent noted becomes retrievable next to your documents and your code. Shipped in v1.4.3: before that a blanket ignore rule dropped every dot-directory, in silence.

→ Connect your coding agent's memory

Door two, the agent reads memory. @mnemosyne_os/mcp is a Model Context Protocol server: one entry in your client config, and the agent can search a vault, ask it a question in prose, and write back what it worked out.

npx -y @mnemosyne_os/mcp

→ Connect Claude to Mnemosyne OS (MCP)

Three of those tools need neither the app, nor a vault, nor a single token: they read the transcripts your harness already writes to disk. That is what makes "is another session live on this branch before I commit?" cheap enough to actually ask.

The mechanism is the whole claim. We publish no measurement of what this saves in tokens or in minutes, so we assert none. Retrieval is not reasoning: a decision a model can look up is a decision it does not derive a second time, and the context it would have spent reconstructing where it is goes to the task instead. Watch it in your own sessions rather than taking a number for it.

---

Build on Mnemosyne OS

You've seen what it is and that it works. Now build on it. Your apps, agents, and skins talk to the private AI memory runtime through a public Gateway contract: a stable, documented surface you build against, while the Cognitive Core stays sealed and never exposed.

Two ways in:

• 🛠️ Build on it: scaffold an app and you're talking to the memory vault in minutes.
• 💾 Run it: install the flagship desktop app, Infinity Edition.

npm create @mnemosyne_os/app

Package	What it does
@mnemosyne_os/sdk	Connect an app to the local AI memory runtime (WebSocket / Electron IPC)
@mnemosyne_os/public-contracts	Shared types & Zod schemas, the integration contract
@mnemosyne_os/design-sdk	Build custom UI skins in pure JSON, zero TypeScript
@mnemosyne_os/create-app	Scaffold a new Mnemosyne OS app in one command

Start from the cartridge boilerplate and you're ingesting and querying the vault, under FGAC, scoped, and consent-gated, in minutes.