Alimenter votre agent
La commande propre à l'éditeur. Ce n'est pas un endpoint PlugMCP.
Host a copy with our keys and logs.
npx -y @mnemosyne_os/[email protected]Claude Code n'a pas de lien d'installation pour une commande locale. Copiez la commande ci-dessous et exécutez-la dans un terminal.
MNEMO_DEFAULT_VAULT=<value> MNEMO_VAULTS=<value> MNEMO_SDK_PORT=<value> claude mcp add io.github.mnemosyne-os-mcp -- npx -y @mnemosyne_os/mcp@2.1.3À exécuter dans un terminal.
{ "mcpServers": { "io.github.mnemosyne-os-mcp": { "command": "npx", "args": [ "-y", "@mnemosyne_os/[email protected]" ], "env": { "MNEMO_DEFAULT_VAULT": "<value>", "MNEMO_VAULTS": "<value>", "MNEMO_SDK_PORT": "<value>" } } }}claude_desktop_config.json
URL distante ou commande sur votre machine ? Ce qui distingue les deux installations
Exécuter sur PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LancerDe l'éditeur
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.
Memory the human governs, on their own machine, plus what other coding agents here wrote.
🔏 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.9.0 · The Orb. The orb becomes your assistant: say "tidy my desktop" and it plans the steps and runs them, in 7 languages. A morning briefing and an evening journal, Google Calendar and your mail on the board, and your coding agents drive Mnemosyne OS from Claude Code, Cursor or Codex. Many features are still experimental.
[!TIP] 📖 The user documentation is live at docs.mnemosyne-os.io, with every engine explained step by step, in English · Français · Español.
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.
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 · суверенная локальная операционная система памяти · 主权的本地优先记忆操作系统.
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.
Published by XPACEGEMS LLC. These are its official addresses:
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:
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 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.
Not one big "AI" black box. Several independent, purpose-built engines:
📄 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/.
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
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 by Julien Gelee found a wrong verdict in our August result. It covered the published files, ledgers and arithmetic, and did not evaluate the product or the closed engine. 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:
Citing this work. Both the evidence and the architecture are archived under permanent identifiers, so they can be cited rather than merely linked:
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.
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.
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
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.
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:
npm create @mnemosyne_os/app
Start from the cartridge boilerplate and you're ingesting and querying the vault, under FGAC, scoped, and consent-gated, in minutes.
🛡️ Zero-Trust by design. Every SDK connection authenticates with a short-lived JWT, listens on
127.0.0.1only, and is bounded by the scopes your app manifest declares. The OS sees your requests; you never see the core.
The apps in MnemoHub aren't black boxes. Each ships its actual src/ (React + the SDK),
public and inspectable. Clone one as a reference implementation and read exactly how a
real app connects to the memory runtime, ingests, and queries the vault through the SDK. Don't
learn the SDK from API docs alone, download a working app and copy the patterns. A few live examples:
MIT cartridges are yours to fork and ship anywhere. The Cartridge License is source-available: read it, learn from it, modify it, with one condition: it runs inside the Mnemosyne OS ecosystem.
🧩 Make your own. Scaffold a cartridge from the boilerplate, build it against the SDK, and publish it to MnemoHub, exactly how these were made. From
npm createto a signed, installable cartridge, the whole path is yours.
The open surface of Mnemosyne OS is MIT-licensed and free to build on:
/packages) is the integration surface above: connect apps, build
skins, scaffold projects, evaluate against the Gateway./cli) is a separate developer tool with its own docs: see
cli/README.md. To give a coding agent memory, use the
MCP server instead.The open SDK and the sealed core are separated by a single boundary: the Gateway. Apps speak a public contract; the core's internals are never shipped to, or reachable from, third-party code.
flowchart TB
subgraph Renderer["Renderer Process (React)"]
UI["React 18 · TypeScript strict · Vite<br/>i18next (EN/FR/ES) · 30+ lazy-loaded routes"]
end
subgraph Bridge["contextIsolation: true · nodeIntegration: false"]
CB["Context Bridge<br/>400 Zod-validated IPC channels"]
end
subgraph Main["Main Process (Electron)"]
SVC["Services: AI · Vault · Drive · Workspace<br/>Shadow · Window · Network · FGAC · Scheduler"]
end
subgraph Net["Sovereign network (127.0.0.1 only)"]
SDKWS["SDK WebSocket"]
MCP["MCP server"]
end
subgraph Chain["Base L2, on-chain"]
ENGRAMM["Engramm License"]
end
UI <--> CB
CB <--> Main
Main --> SDKWS
Main --> MCP
Main -. verify via Gateway .-> ENGRAMM
style Main fill:#1a1a2e,stroke:#7c3aed,color:#fff
style Renderer fill:#0f172a,stroke:#38bdf8,color:#fff
style Chain fill:#1a1a0e,stroke:#f39c12,color:#fff
Running Mnemosyne OS is unlocked by an Engramm, named after the engram, the physical trace a memory leaves in the brain. Fitting for a memory OS: it's your own verifiable trace of ownership.
Rather than an account and a monthly subscription, your license lives on-chain (Base), bound to your wallet, not to a machine, not to an email. You hold it, so you own your copy and carry it to any device you want, and anyone can verify it. The same Engramm drives your sovereign pseudonym and cloud credits. Holding it and checking it cost you nothing. See below.
A local wallet is the only credential. No account, no password server-side to breach.
No gas fees, no crypto to manage. The chain is plumbing, not a paywall. You never pay a network fee, hold a token, or approve a transaction. Ownership is recorded on Base so it stays publicly verifiable, but every network cost is covered for you. A wallet you never have to think about.
sequenceDiagram
participant U as "You"
participant W as "Sovereign wallet (local)"
participant G as "Gateway"
participant C as "Base L2 (chain)"
participant T as "OS keystore"
Note over U,T: Cold boot (first launch / new machine)
U->>W: launch the app
W->>G: signed challenge
G->>C: verify Engramm on-chain
C-->>G: does this wallet hold the license?
G-->>W: signed verdict
Note over U,T: Arming encryption at rest, separate, and up to you
U->>W: turn on encryption at rest
W-->>U: 24-word recovery phrase, confirm it
U->>W: confirmed
W->>T: seal the AES-256 key
Note over U,T: Every launch after
W->>T: read the sealed key
T-->>W: key → vaults open encrypted
Note over W,T: Once armed, physical theft = encrypted SQLite.<br/>Until armed, vaults are local but in cleartext.
Security-first Electron architecture
contextIsolation: true, nodeIntegration: false on every windowsandbox: true for web content, relaxed only for the local-AI worker threads, mitigated by context isolation + Zod-validated IPCSovereignty enforced in code
Stack
useShallow atomic selectorsMnemosyne OS follows an open-core model: an open, MIT-licensed developer ecosystem built around a proprietary core.
The SDK and MnemoForge CLI are MIT licensed. Fork them, build on them, ship your own apps. The Mnemosyne Neural OS platform, the desktop application, Neural Map, MnemoHub, Dream State, Vaults, and associated services, is proprietary software. No part of the platform may be copied, modified, or distributed without explicit written permission from XPACEGEMS LLC.
End-user licensing is separate from the code license above. Running Mnemosyne OS is unlocked per user by the Engramm, an on-chain license bound to your wallet, not a subscription, while the SDK and CLI you build with stay MIT.
Why the core is closed. Everything you need to build is open; what stays sealed is the part that took years of full-time R&D to get right, the memory engines (Spine, Retrieval, Dream State) behind the LongMemEval numbers above. Keeping that core proprietary is what lets an independent lab sustain the project, fund the open ecosystem around it, and grow a team, instead of handing a hard-won engine to anyone who would re-skin it. The trade is deliberate: everything above the Gateway is yours to fork; the engine that makes it worth building on stays ours.
For licensing inquiries: [email protected]
TypeScript errors : 0 (strict mode, noUncheckedIndexedAccess)
ESLint warnings : 0
Test suite : Vitest + Testing Library (green CI)
CI pipeline : ✅ Green (typecheck → lint → i18n → tests)
Languages : 3 (EN / FR / ES)
i18n namespaces : 47
Electron security : context isolation · Zod-validated IPC · CSP
Mnemosyne OS is built on three principles:
1. Sovereignty: Your data stays local. Your models run locally if you choose. No telemetry without consent. FGAC controls what the AI can and cannot access.
2. Multi-model: No vendor lock-in. Claude, GPT, Gemini, Groq, Mistral, DeepSeek, and MiniMax in the cloud; Ollama or a local GGUF model fully offline; any OpenAI-compatible endpoint on top. Switch per task, or let the app route automatically.
3. Agentic by design. This is not a chat interface with file upload. A real orchestration layer where multiple AI agents coordinate, with policy enforcement and audit trails.
The numbers above come from published, citable research artifacts. Mnemosyne Labs is the research arm of the project: methodology in the open, benchmarks anyone can audit, artifacts archived with a DOI.
Both records are open access (CC BY 4.0), cite each other on Zenodo, and are bound to the founder's research identity, ORCID 0009-0009-1087-3917.
@mnemosyne_os/forge · Soul Protocol · Canvas Rules · Chronicle System · MCP ServerXPACEGEMS LLC, Independent AI software lab
Headquarters: 2932 NW 72 AVE, Miami, FL 33122, USA
Founder & Lead Architect: Tony Trochet
Product: mnemosyne-os.io: downloads, docs, build on it
Company: mnemosyne-os.com: press, research, Labs
Documentation: docs.mnemosyne-os.io: every engine, step by step
LinkedIn: Tony Trochet
GitHub: @yaka0007
Built through Neural Coding, human-architected, with Claude (Anthropic), Antigravity (Google DeepMind), and Cursor directed as instruments.
A new build ships most weeks. Windows builds are code-signed (Certum OV, RFC-3161 timestamped) and auto-update once installed.
The longer stories behind the releases and the campaigns, on the product site:
Memory decides who an agent stays between sessions, not whatever model happens to be running.
Memory the human governs, on their own machine, plus what other coding agents here wrote.
{ "mcpServers": { "io.github.mnemosyne-os-mcp": { "command": "npx", "args": [ "-y", "@mnemosyne_os/[email protected]" ], "env": { "MNEMO_DEFAULT_VAULT": "<value>", "MNEMO_VAULTS": "<value>", "MNEMO_SDK_PORT": "<value>" } } }}Outils
Pas encore de liste d'outils. Les serveurs distants en obtiennent une après le premier contrôle d'état.
FAQ
Copiez sur cette page la configuration stdio pour Cursor, Claude Desktop, Claude Code ou VS Code. Elle utilise l'installation de l'éditeur, pas un proxy PlugMCP.
L'éditeur indique ces variables d'environnement : MNEMO_DEFAULT_VAULT, MNEMO_VAULTS, MNEMO_SDK_PORT.
Mnemosyne OS s'exécute en local via stdio.
Dernière vérification : 2026-11-15. Memory the human governs, on their own machine, plus what other coding agents here wrote.