Not storage. Not memory. Not logs.
Continuity of intelligence across agents, time, and tasks.
Other memory systems are filing cabinets. Mnemo's memory works while you sleep.
It's not just memory — it's cognitive coprocessing.
Dreaming Mnemo shares dreams across agents.
Not storage. Not memory. Not logs.
Continuity of intelligence across agents, time, and tasks.
Other memory systems are filing cabinets. Mnemo's memory works while you sleep.
"You just talk naturally. Stuff gets saved and processed. It's there when you need it."
— Guy Hutchins, creator$ git clone https://github.com/GuyMannDude/mnemo-cortex.git && cd mnemo-cortex $ python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate $ pip install -e . $ mnemo-cortex init # config wizard — pick your models $ mnemo-cortex start # server up on port 50001
Python 3.11+ · Ollama recommended, or any API provider · On a Mac? Read the macOS install guide and join the beta.
Run any local model. Add Mnemo for memory. No cloud, no subscription, no API keys.
9 tools out of the box — semantic memory + Developer's Passport. Auto-detects optional brain-lane and wiki dirs and adds up to 8 more tools when present. No flags. No switches. If the dir is on disk, the tool registers.
Zapier charges $20–50/month for AI tool connections. Mnemo on your local LLM: $0/mo, fully private, runs on hardware you already own.
Multiple agents. Separate execution environments. One unified memory system.
AI stops resetting. Knowledge compounds. Systems evolve instead of restart.
Not keyword lookup. Not file search. Meaning-based retrieval.
"What worked on April's ads last week?"
Returns: winning creatives, audience signals, decisions. Not just logs — insight extraction.
Rocky executes. Claude Code builds. Opie architects.
All of them: read each other. Learn from each other. Evolve together.
Rocky CC Opie Hermes Claude Code Claude Desktop | | | v v v memory/rocky/ memory/cc/ memory/opie/ \ | / \ | / -------> MNEMO CORTEX <------ SQLite + FTS5 port 50001
Every night at 3 AM, Mnemo reads every agent's memories from the day. An LLM synthesizes them into a single brief: what was built, what was decided, what's blocked, what each agent should know about the others' work.
Every agent wakes up caught up. No manual relay. No "hey, tell Rocky what CC did." It just happens.
3:15 AM — IGOR-2 mnemo-dream.py 1. Harvest all agent memories since last dream 2. Send to LLM for cross-agent synthesis 3. Write dream brief back to Mnemo Next morning, each agent boots: Rocky CC Opie reads dream reads dream reads dream knows what knows what knows what everyone did everyone did everyone did
Cost: one cheap LLM call per night. The dream brief is searchable like any other memory — agents can recall dreams from weeks ago. Cross-agent awareness that compounds over time.
Mnemo holds the facts. WikAI is the study guide compiled from those facts — 3,000+ markdown pages organized into projects, entities, concepts, and sources. Three MCP tools: wiki_search, wiki_read, wiki_index.
The wiki is regenerated every night by mnemo-wiki-compile.py. The compiler clusters recent memories by topic, then asks an LLM to rewrite each affected page integrating the new information — without bloating it. Cross-references are validated against the live page set, so no hallucinated wikilinks. Every page carries a provenance footer listing the Mnemo session IDs that fed it, so any claim is auditable.
3:30 AM — IGOR-2 (15 min after Dreaming) mnemo-wiki-compile.py 1. Harvest recent memories from Mnemo + AgentB writebacks 2. Cluster by topic in Python (no LLM routing) 3. Per-topic: gemini-2.5-flash rewrites the page 4. Validate cross-refs against the live page set 5. Write with .md.prev rollback, regenerate INDEX.md Per-page failures isolated: ⚠️ to #alerts, run continues
Inspired by Andrej Karpathy's LLM Wiki pattern and Nate B Jones's analysis of write-time vs query-time memory. Mnemo is the librarian. WikAI is the study guide. Neither Zep nor Letta offer this.
Multi-agent message bus with full delivery confirmation. Originally lived inside Mnemo Cortex; now ships as its own product.
A reference-grade safety layer for developers building agent systems. Captures how a user works — tone, density, formality, workflow choices — so agents can adapt to them instead of forcing the user to adapt.
Observations become candidates. Candidates get reviewed. Only stable claims promote into the user's profile. Nothing auto-lands.
Five MCP tools: passport_get_user_context, passport_observe_behavior, passport_list_pending_observations, passport_promote_observation, passport_forget_or_override. Reference integration via stdio MCP. The hosted HTTP wrapper for browser-based AIs (claude.ai custom connectors, etc.) is a future release — today's release is for developers who wire MCP subprocesses into their own agent stacks.
Mnemo Cortex captures conversation memory automatically — what agents said, what happened, what was decided. mnemo-plan is the opposite: the stuff you write and curate. Project specs. Active task lists. Decision logs. Architecture docs. Anything an agent needs to know before a conversation starts.
It's a folder of markdown files in Git. Any LLM that can call the Mnemo MCP tools read_brain_file / write_brain_file / list_brain_files can read and edit them. Not Claude-specific.
BRAIN_DIR at it and your agents have project context the moment they start a session.The starter template ships with project.md, active.md, stack.md, decisions.md, plus optional people.md and incidents.md. Each file has comments explaining what goes there. Fork it, fill it in, restart your agent.
The split: Mnemo Cortex = automatic conversation memory. mnemo-plan = manual project pad. Both ride the same MCP bridge; they auto-enable based on whether BRAIN_DIR is set on disk.
Mnemo Cortex is no longer a memory store. It's a memory architecture.
We adopted the best ideas in the air, credited them openly, and built on top.
SETUP-PROMPT.md.Mnemo Cortex is not a wrapper, a bridge, or a plugin for someone else's memory cloud. It's the whole system — storage, recall, and overnight maintenance, running on hardware you own.
Most memory products make you choose: one shared store for everything. Mnemo lets you architect for your actual privacy and separation needs.
Most systems: summarize = discard detail.
Mnemo-Cortex: compress memory, keep traceability.
Go from high-level summary down to the exact moment. ~80% compression. Full fidelity preserved.
SQLite. Local compute. Any LLM for compaction — Ollama for $0, or any API provider you choose.
Over time, Mnemo-Cortex builds: what worked, what failed, what changed. Without re-training.
This is what current AI tools are missing.
They don't blend. They specialize. That's closer to a real company team than a chatbot.
During Claude Fable 5's brief availability, we pointed it at the memory layer it runs on and asked it to make it better. The result shipped as Mnemo's v4.1 "Fable pass."
Mnemo-Cortex stores: ad performance, creative wins, audience behavior, product trends.
Over time, it becomes: a brain for the business. Not a tool.
That's a different category.
You didn't just build something useful. You built infrastructure. And infrastructure is where the leverage is, the lock-in is, the money is.
OpenClaw 2026.4.10 shipped a native Active Memory plugin. Some people have asked whether it replaces Mnemo Cortex. Short answer: no — they solve different problems.
Here's the difference, based on testing both on our Sparky sandbox agent.
| Active Memory (native) | Mnemo Cortex (MCP) | |
|---|---|---|
| Scope | Single agent | Cross-agent (multi-agent bus) |
| Store | Local workspace files + FTS | Centralized SQLite + embeddings |
| Persistence | Per-agent, per-workspace | Survives resets, sessions, machine moves |
| Cross-session | Within one agent's workspace | Any agent, any machine |
| Integration | Independent store | Independent store |
Built in Half Moon Bay, California by Guy Hutchins and a team of AI agents running on the memory system you're looking at.
AI agents without memory repeat expensive work. Every session starts from zero — re-reading files, re-analyzing context, re-discovering what worked yesterday. That's your API bill paying for the same thinking twice.
Mnemo Cortex remembers what worked, what failed, and what changed. Your agents stop recomputing and start building on yesterday's knowledge. Fewer tokens burned. Fewer expensive model calls wasted on context recovery.
Mnemo Cortex makes every call count — it gives your smart models full context on the first try, so there are no expensive retry loops and no tokens wasted rediscovering what the agent already knew. Your agents stop paying to re-learn yesterday.
Mnemo Cortex is free and open source. If it's useful to you, help keep it going.