🍎 macOS support is here — got a Mac and 15 minutes? Join the beta →
Mnemo Cortex — circuit-eye logo card

Mnemo Cortex

It's not just memory — it's cognitive coprocessing.

Now with
Dreaming Mnemo

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
GitHub stars
Prefer art over donations? Every sale at Rocky's Gallery funds this project →
"Mnemo-Cortex turns AI from a tool into a system that remembers, learns, and improves."
Claude Code
Fluid memory with deep recall.
60-second install. Two hook scripts.
startup hook · writeback hook · zero config
Install for Claude Code
💻
Claude Desktop
Opus 4.6 with fluid detailed memories.
Drop-in bridge. Always remembers.
recall · search · save
Install MCP Bridge
Hermes Agent
Persistent memory for Nous Research's Hermes.
One-shot installer. 12 tools auto-discovered.
stdio MCP · 555ms cold start · works with FrankenClaw
Install for Hermes
🦞
OpenClaw MCP v2
Give your ClawdBot a brain.
Privacy-first — cross-agent sharing off by default.
share switch · session toggle · per-agent privacy
Install OpenClaw MCP
Install
Fresh checkout to running server in five steps
$ 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
Linuxnative
Windowsnative — no WSL
macOSbeta — testers wanted

Python 3.11+ · Ollama recommended, or any API provider · On a Mac? Read the macOS install guide and join the beta.

Also works with
🦙 Any Local LLM

Run any local model. Add Mnemo for memory. No cloud, no subscription, no API keys.

LM Studionative MCP
AnythingLLMAutomatic mode
Open WebUInative MCP
llama.cppnative MCP
Ollamavia MCPHost
LobeChatMCP plugin
Janextensions

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.

Setup Guides →

Shared Memory Spine

Multiple agents. Separate execution environments. One unified memory system.

AI stops resetting. Knowledge compounds. Systems evolve instead of restart.

Without Mnemo
  • "AI session"
  • Forgets everything
  • Starts from zero
With Mnemo
  • AI operator that grows
  • Remembers everything
  • Builds on yesterday

Semantic Recall

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.

Semantic Search
Ask a natural language question. Get the most relevant memories ranked by meaning.
Claw-Recall (FTS5)
When meaning isn't enough — exact-match search for terms, names, filenames, error messages.
The Thesaurus Loop — in development
Every recall commits to one phrasing. If a memory was filed under different words than you searched for, the match is weak or misses — assumption misalignment between how you ask and how it was stored. The Thesaurus Loop fans a query into several alternative phrasings and lets the best match win. The trick is escalation: it only fires when a search comes back empty or weak, so good searches stay exactly as fast as they are today and the expansion pass costs nothing until it's actually worth it.

Cross-Agent Cognition

Rocky executes. Claude Code builds. Opie architects.

All of them: read each other. Learn from each other. Evolve together.

A team of AI that shares experience.
Isolated writes · Privacy-controlled reads · One memory spine
  Rocky           CC            Opie
  Hermes          Claude Code   Claude Desktop
       |               |               |
       v               v               v
  memory/rocky/   memory/cc/    memory/opie/
       \              |              /
        \             |             /
         -------> MNEMO CORTEX <------
                  SQLite + FTS5
                  port 50001

Dreams Across Agents

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.

Zep and Letta store memory per agent.
Mnemo synthesizes across all of them overnight.
That's a different category.
  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.

WikAI — The Compiled Knowledge Base

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.

The wiki is never edited directly.
Mnemo is the source of truth.
If a page is wrong, fix the source data and recompile. WikAI is always regenerable.
  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.

Disco-Bus — Delivery-Confirmed Messaging

Multi-agent message bus with full delivery confirmation. Originally lived inside Mnemo Cortex; now ships as its own product.

See Disco-Bus →

Developer's Passport — Safe Behavioral-Claim Ingestion

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.

The user is always the gate.
5 MCP tools, a review queue, 32 content detectors, 4 provenance buckets, git-tracked audit. Current eval: 53.0% accuracy / 0.458 macro-F1 against a 200-entry labeled corpus. Beta.

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-plan — Project Pad for Your Agents

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.

You write it. They read it.
No new MCP tools. No daemon. No schema. Markdown in Git. Point your bridge's 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.

Template repo on GitHub →

Three Layers, One Source of Truth

Mnemo Cortex is no longer a memory store. It's a memory architecture.

Mnemo Cortex
Source of truth. Raw facts, sessions, key events. Multi-agent, query-time. The librarian's filing cabinet.
WikAI
Compiled view. Auto-generated from Mnemo. Cross-referenced, browsable. Write-time. The study guide.
Brain Files
Live working memory. Current state, identity, active context per agent. Ephemeral. The sticky notes on your desk.
When they disagree, Mnemo wins.
WikAI is always regenerable from Mnemo. Brain files are ephemeral.

We did not invent this

We adopted the best ideas in the air, credited them openly, and built on top.

Andrej Karpathy
LLM Wiki pattern (April 2026, 41,000+ bookmarks). Inspired WikAI's compile-don't-rederive design and the "idea file as publishing format" pattern in SETUP-PROMPT.md.
Nate B Jones
OpenBrain + "Your AI Does the Hard Work Then Deletes It". Inspired our three-layer architecture: structured store + compiled wiki + ephemeral brain files. Substack.
Google A2A Protocol
A2A spec. Disco-Bus speaks A2A's data shapes today; transport is the v2 roadmap.

Standalone by Design

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.

sqlite-vec Recall
Semantic search over local vector embeddings. Meaning-based retrieval with no API call and no per-query cost.
Facts Table
Hard truths stored as structured facts, separate from conversational memory — so the important stuff doesn't drown in the chatter.
Dreamer Compaction
Overnight, the Dreamer distills the day's raw memories into briefs every agent reads at boot. Memory that maintains itself.
Per-Agent Lanes
Each agent writes to its own lane. Isolated writes, no cross-contamination, clean provenance on every memory.
Cross-Agent Recall
Agents read each other's lanes when you allow it. Agent A can know what Agent B learned — privacy-controlled.
Cross-Platform
The server runs natively on Linux, macOS, and Windows — no WSL. As of v4.4.1, cross-platform file locking lets it start and serve recall on native Windows Python.
Auto-Capture
Session activity flows into memory automatically. Manual saves are for the decisions; ambient capture handles the rest.
135+ stars on GitHub and counting.
Open source · SQLite under the hood · Your data never leaves your machine

Deploy Your Way

Most memory products make you choose: one shared store for everything. Mnemo lets you architect for your actual privacy and separation needs.

🌐
Shared
One Mnemo instance for all agents. Cross-agent search and dreaming. Full team awareness. Best for internal teams where every agent should see everything.
🔒
Isolated
Separate Mnemo per agent or per customer. Zero bleed between tenants. Perfect for customer-facing bots where visitor A must never see visitor B's history.
🔧
Hybrid
Shared Mnemo for internal agents + isolated instances for customer-facing bots. Cross-agent dreaming for the team, strict privacy for customers. This is what we run.
Privacy isn't a setting. It's a topology decision. Mnemo gives you the architecture to make it.

Memory with Lineage

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.

Auditable AI thinking.
DAG-based lineage · Every summary traces to source

No API burn. No per-query cost. No cloud dependency.

SQLite. Local compute. Any LLM for compaction — Ollama for $0, or any API provider you choose.

Scaling
Memory grows without costs growing.
Autonomy
Your data stays on your hardware.
Margins
The cost of remembering is $0.

AI that gets better every week

Over time, Mnemo-Cortex builds: what worked, what failed, what changed. Without re-training.

This is what current AI tools are missing.

Rocky
Execution brain. Gets better at testing, customer service, creative work.
CC
Builder brain. Gets better at wiring, debugging, deploying.
Opie
Strategy brain. Gets better at architecture, planning, positioning.

They don't blend. They specialize. That's closer to a real company team than a chatbot.

Upgraded by Claude Fable 5

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."

Composite recall ranking
The fix that pulled real signal back to the top of every search — blending similarity, recency, category, and access instead of raw vector score alone.
The Analyst
Distills raw session logs into clean, high-signal Tier-1 notes — so recall surfaces decisions, not transcript noise.
Secret redaction at ingest
Every byte entering the store passes a redaction choke point first — API keys never reach a remote classifier.
Tier hygiene
Deleted memories stay deleted; the two-tier recall path stops stale rows resurrecting from cache.
A frontier model auditing the memory it thinks with.
Fable 5 reasoned and reviewed the whole codebase; an Opus model reviewed, hardened, and shipped each change — in a single window before Fable went dark.

Business Intelligence Engine

Mnemo-Cortex stores: ad performance, creative wins, audience behavior, product trends.

Over time, it becomes: a brain for the business. Not a tool.

Week Over Week
What worked. What failed. What the customer wants. No re-onboarding. No lost context.
Month Over Month
Patterns emerge. Strategy compounds. Your AI advisor remembers the whole story.

What makes this different

Everyone Else
  • "AI memory"
  • "Chat history"
  • "RAG system"
Mnemo-Cortex
  • Persistent
  • Multi-agent
  • Semantic, evolving cognition

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.

Live stats — last 14 days

322
GitHub Clones
159
Unique Cloners
3
Integration Paths
3
Active Agents
~80%
Compression
6+ wks
Continuous Recall

What you get

AI that doesn't forget.
AI that learns over time.
AI that works as a team.
AI that gets better every week.
Get it on GitHub

Mnemo Cortex vs OpenClaw Active Memory

They're Not the Same Thing.

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
OpenClaw's Active Memory
Intra-session, same-agent, fast local recall. Your agent's personal scratchpad. Great for recent context within a single workspace.
Mnemo Cortex
Cross-agent memory bus. When Agent A needs to know what Agent B learned. When memory must survive session resets, machine moves, or agent restarts.
We run both. OpenClaw's Active Memory handles per-agent recent context. Mnemo handles everything that crosses agents or needs durable archival. They stack; they don't compete.

Project Sparks

Built in Half Moon Bay, California by Guy Hutchins and a team of AI agents running on the memory system you're looking at.

The Project Sparks story →

Smart memory saves real money

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.

Support the project

Mnemo Cortex is free and open source. If it's useful to you, help keep it going.