Lexicon

The jargon, explained.

We use precise words because they say precise things. Here they all are, without the fog. Everywhere on the site, dotted-underlined terms lead here — hover for the short version, click for this page.

Cartridge: A cartridge is an app that runs inside Mnemosyne OS. It gets the memory as its back-end (through the SDK, under FGAC), runs sandboxed, and ships signed so you know who built what you install. Cartridges are distributed on MnemoHub — or kept private.
Chronicle: A chronicle is one remembered thing: the content itself, a spine type that says what kind of memory it is, and a vector embedding that lets it be found by meaning. Everything Mnemosyne knows about you is made of chronicles, each one retrievable on its own.
Dream State: Like a brain during sleep, the OS consolidates: it re-reads recent memory, connects it to older chronicles, and writes dream chronicles — deliberately weak, dated, decaying summaries kept in their own vault. Everything happens locally; a dream never overwrites a real memory.
Embedding (vector): An embedding is a piece of text translated into a vector — a long list of numbers that places it in a semantic space. Two things that mean similar things land close together, even with zero words in common. Every chronicle is embedded, which is why you can ask for an idea and get the memory, not just a keyword match.
Engramm: The Mnemosyne OS license is an Engramm: a durable title of ownership, yours, transferable, recorded on the Base chain. The name comes from the engram — the physical trace a memory leaves in the brain. A license that is itself a memory trace, not a subscription that evaporates.
FGAC: Fine-Grained Access Control governs who reads and writes what: a cartridge receives an explicit scope (this vault, this right), never blanket access. It is the contract that makes the ecosystem safe — building on Mnemosyne does not open your memory.
Local-first: Local-first software works on your machine first: your data is born there, stored there, and stays usable without a connection. Cloud services can be added on top (remote models, for instance), but they are never required to own or read your memory.
LongMemEval: LongMemEval is an academic benchmark that tests whether a system truly remembers across many sessions: facts told once, updated later, spread over months. Mnemosyne OS measures 72.9% — reported as a lower bound, with the correction protocol and verdicts published so anyone can recompute it.
MCP: MCP (Model Context Protocol) is an open standard that lets AI agents use tools and read context in a uniform way. Mnemosyne ships an MCP server (@mnemosyne_os/mcp): your coding agents and assistants can query the vault, see resonances and git context — under the same FGAC rules as everything else.
Neural Map: The Neural Map displays your memory as a navigable space of topologies. The positions are not decorative: where a memory sits derives from its real place in the semantic space, and the map never rearranges them to please the eye. You explore what your memory actually looks like.
Off-chain signature (EIP-191): The MnemoHub catalog and its submissions are signed with a sovereign wallet key (EIP-191), but nothing is written on-chain: the signature travels in the data itself and any client can verify who signed it. The chain as a source of authority, not as a database — blockchain-grade verifiability without gas, latency or publicity.
Open-core: Open-core is a deliberate split: everything a developer needs is public and MIT-licensed (SDK, contracts, CLI, scaffolder), while the memory engine itself ships sealed inside the app. You build on a stable, open surface; the deep machinery — and your memory with it — stays on the user's machine.
RAG: RAG (Retrieval-Augmented Generation) is how a model answers from your memory instead of its imagination: the engine first retrieves the relevant chronicles, then the model writes its answer grounded in them. Without retrieval, a model can only guess; with it, it can cite your actual past.
Resonance: A resonance is a link the engine perceives between memories — two chronicles that echo each other across time or domains. Mnemosyne surfaces these links; it never acts on them for you. The tenet: memory perceives, situates and reveals; the human governs.
SDK: The SDK (@mnemosyne_os/sdk, MIT) is how developers build on Mnemosyne: ingest() writes into the vault, query() and ask() read by meaning — all under FGAC, over WebSocket or IPC. No database to provision, no auth to wire: the memory is the back-end.
Sovereignty: Sovereignty means the human holds the keys (encryption, identity, license), the data (on their machine) and the decisions (what enters, leaves, mixes or gets erased). Mnemosyne provides the engine; it owns nothing of your life.
Spine: Every chronicle carries a spine type — its semantic nature: technical knowledge, a decision, a profile fact, a dream… This taxonomy lets the engine filter and situate a memory at the right level, instead of treating everything as undifferentiated text.
Vault: Memory is organized into vaults: isolated stores, one per domain (code, research, journal, social…). Each vault carries its own protection and mixing rules; crossing two vaults is a human decision, never a default.
Zero-Trust IPC: IPC (inter-process communication) is how the parts of the app talk to each other. Zero-Trust means none of those messages is trusted by default — even locally, every request carries a scope-limited signed token and gets validated before it touches memory. A compromised or curious component still can't read beyond its grant.