One memory. On your machine.
Mnema is a free local memory store that every LLM and agent on your Mac can share — a formally verified engram database with an HTTP + MCP API and a 3D memory you can fly through. It’s the memory that powers Zimac — now standalone, and yours.
Spreading activation. A consult races the synapses to recall.
The memory, on its own.
Zimac is a whole assistant. Mnema is the part underneath that remembers — the verified engram store it runs on — lifted out, made to stand alone, and given away free. One store on your Mac that every agent you use can read and write.
“Your tools forget you between sessions. Mnema doesn’t.”
The memory substrate
A single local store, plus the doors to reach it. It holds memories, links them into a graph, and recalls them — for whatever’s asking.
- Free. Download and run. No account, no key, no cloud.
- For any agent. Claude Code, your own scripts, anything that speaks HTTP or MCP.
- One store, shared. Every tool on your Mac draws on the same memory.
The full chief of staff
A native macOS app for engineering managers: a roster of specialists, live integrations, workspaces. It uses Mnema as its memory.
- A team of agents that triage, route, and answer in one voice.
- Plugs into GitHub, Jira, metrics — grounded in your real systems.
- See Zimac →
However your agents reach it.
Mnema opens the same store three ways at once, all on 127.0.0.1. Wire your agents to whichever door they speak — they all share one memory.
HTTP API
/v1/consult, /v1/learn, /v1/related, /v1/list on port 7077. Point any ZLEARN_URL client straight at it.
curl 127.0.0.1:7077/v1/consult -d '{"query":"..."}'
MCP server
An MCP server over stdio, so Claude Code — or any MCP-speaking LLM — calls consult / learn as native tools.
claude mcp add mnema -- mnema mcp
The Pensieve
A native window: a real-3D memory well you fly through to browse, curate, and watch recall light up the graph.
mnema # launch the app
One query lights a path.
A consult doesn’t grep — it sends a wave of spreading activation across the graph, surfacing related memories multiple hops away in sub-milliseconds, zero tokens.
Every answer comes back with an honest confidence band. A low band means it doesn’t really know — so your agent treats the hits as a hint, not a fact.
A memory you can fly through.
Open the app and your memory is a real-3D well. Every memory is a glowing mote; every connection a luminous thread. A consult sends a wave of activation racing along the synapses to light up what it recalls.
Click a mote and you plunge in to read it — then swim to whatever it’s linked to. When WebGL isn’t available it falls back to an accessible 2D list, so the store is always browsable.
A better connection, not a bigger model.
Mnema is engineered like a connectome, not a chat log. The memory is a real, navigable graph — and it learns the shape of how you and your agents think.
Engram memory log
An append-only, length-prefixed log protected by CRC32 and a hash chain. Appends are O(1) and crash-safe; it tolerates a torn write and auto-recovers from backup. Your memory survives a power cut mid-write.
Hypergraph
Memories, people, notes and links cross-link through shared topics, with near-duplicate detection. Stays navigable past 100k+ items.
Spreading activation
Recalling one memory lights up a multi-hop constellation of related context — sub-millisecond, zero tokens — split into fact versus hedged.
Synaptic plasticity
Learned per-pair weights: ties that co-recall strengthen (Hebbian) and fade over about 21 days. Mnema literally learns how you think over time.
Emergent edges
When ideas keep co-firing, Mnema mints an association nobody authored — surfaced only as a hedged “pattern noticed,” never as fact.
Optional semantic recall
Out of the box, recall is lexical + graph — fully offline, nothing leaves your Mac. Point MNEMA_EMBEDDINGS_URL at an embeddings endpoint and recall goes semantic too, when you want it.
A database you can trust with your memory.
Mnema isn’t a wrapper over SQLite — it’s a from-scratch engram store with a real verification contract. A build can’t ship unless the proofs pass.
Tests, clippy & conformance always
The full suite plus an exhaustive CRDT model checker run on every build — including the merge/sync conformance that gates any change.
Kani bounded proofs CI
Symbolic proof harnesses discharge the trickiest invariants — bounded model checking, not just examples.
TLA⁺ model check CI
The replication protocol is model-checked for strong eventual consistency, causal delivery and liveness — the hard concurrency, proven.
Durable by design
Atomic temp→fsync→rename writes, CRC checks everywhere, automatic backups with verify-and-restore.
Local-first, all the way down.
Your memory lives as plain files under ~/.mnema. There is no cloud, no account, and no server-side copy — because there is no server but your own Mac.
Binds to localhost
The API binds 127.0.0.1:7077 only. It runs open because it can — there’s no token, because nothing off your machine can reach it.
Embedded, no sidecar
The verified engine is compiled into the one binary — no separate daemon, no Docker, nothing loose on disk. Open it and it works.
Offline by default
Recall is lexical + graph with no network at all. Semantic recall is strictly opt-in — the only thing that ever leaves is a model call you turned on.
Plain files you own
Your store is files under ~/.mnema — back them up, sync them, move them between machines. Override the location with MNEMA_DATA_DIR.
CLI when you want it
mnema consult "…" and mnema learn "…" work straight from the terminal — scriptable, pipeable, no app window needed.
Headless mode
mnema serve runs just the API — on a dev box, a home server, wherever you want one shared store the rest of your tools point at.
Download, drag, done.
A native Mac app, free, no sign-up. Open it for the Pensieve, or run it headless and wire your agents to the API and MCP server.
Drag to Applications
Open Mnema.dmg and drag Mnema into /Applications. No account, no key.
Open it
Launch Mnema and the Pensieve opens on your store at ~/.mnema, with the API live on 127.0.0.1:7077.
Wire your agents
Add the MCP server to Claude Code, or point any ZLEARN_URL client at the API. They all share the one memory.
Give your agents a memory that’s yours.
One verified store on your own Mac, shared by every tool you use — free to download, private by construction, and built to outlast the session.
Download for Mac — free