Mneme

Mneme is memory that survives the session.

It gives agents memory that persists, compounds, and can be trusted.

Mneme is a memory quality layer for OpenClaw. It does not replace OpenClaw memory. It repairs, audits, and improves it.

Goal

Make an agent's memory work, then make it better.

Mneme starts with Six.

For v1, that means starting with one agent — Six — and fixing the basic failure modes first:

• broken recall
• stale or missing indexes
• important facts trapped in daily notes
• duplicate or conflicting memory
• memory that exists, but is hard to use

What Mneme does

Mneme v1 does four things:

1. Restore recall

   • detect broken memory config
   • detect missing embedding backends
   • detect stale or missing indexes
   • verify that memory search actually works

2. Recover important memory

   • read MEMORY.md
   • read daily memory files
   • extract durable facts worth keeping

3. Compile memory into usable structure

   • people
   • projects
   • systems
   • decisions
   • incidents
   • timeline
   • todos (planned, not implemented yet)

4. Audit memory quality

   • duplicates
   • contradictions
   • stale facts
   • facts trapped in daily notes that should be promoted

What Mneme is not

Mneme v1 is not:

• a new vector database
• a replacement for OpenClaw builtin, QMD, or Honcho memory
• cross-agent shared memory yet
• silent autonomous rewriting of memory
• a vague "AI memory" claim with no provenance

Why this exists

OpenClaw already has real memory primitives: Markdown memory files, indexing, hybrid search, QMD, and Honcho.

So Mneme should not try to replace the official memory system. It should make that system more reliable and more usable.

The first job is simple:

"I checked, but memory search is unavailable right now."

That is the kind of failure Mneme exists to catch and fix.

fix recall, recover durable knowledge, and keep memory healthy over time.

V1 plan

1. Restore recall

Get memory search healthy and verified.

2. Recover durable memory

Promote important facts out of existing notes.

3. Compile memory

Turn scattered notes into usable indexes.

4. Keep memory healthy

Surface stale, duplicate, and conflicting facts.

Success

Mneme v1 is successful if:

• Six can answer prior-context questions reliably
• answers come from memory, not bluffing
• important facts survive session resets
• memory becomes easier to inspect and maintain
• broken recall is caught before the user notices

First tool

Mneme now includes its first live check:

• scripts/mneme_memory_check.py — verify memory config, index health, embeddings readiness, and live recall
• scripts/mneme_ingest_memory.py — ingest OpenClaw memory files into raw Mneme evidence JSONL
• scripts/mneme_compile_memory.py — generate a first-pass compiled memory pack from OpenClaw-style notes
• scripts/mneme_secret_scrub.py — scan memory files for likely secrets and redact obvious raw tokens/passwords
• scripts/mneme_memory_drift.py — detect likely contradictions, duplicates, and stale facts in memory files
• scripts/mneme_run.py — run the Mneme maintenance flow in one command
• scripts/mneme_retrieve.py — lexical-first retrieval with inspectable citations
• scripts/mneme.py — single operator CLI wrapper over the Mneme scripts
• scripts/mneme_llm_compile.py — prepare/validate LLM-assisted compile passes against raw evidence
• scripts/mneme_materialize_candidates.py — turn validated LLM candidate entries into compiled outputs
• scripts/mneme_llm_roundtrip.py — run the end-to-end LLM-assisted compile loop for one category
• scripts/mneme_merge_pack.py — merge reviewed category outputs into one compiled pack
• scripts/mneme_runtime_orchestrate.py — prepare/apply the runtime agent-dispatch seam for Mneme compile runs
• scripts/mneme_runtime_batch.py — prepare/apply multi-category runtime compile runs

Repo hygiene

Treat these as transient local artifacts by default:

• raw/
• compiled/

If you need sample data in the repo, keep it tiny and sanitized under examples/ instead of committing private memory evidence.

Tests

Run the smoke tests with:

python3 -m unittest discover -s tests -p 'test_*.py'

These cover three boring-but-important paths:

• ingest a tiny fixture workspace
• compile fixture raw evidence into outputs
• prepare a runtime task for the people category

Docs

• Mneme v1 Spec
• Evidence model
• OpenClaw memory references
• Ingest
• Milestone 1 checklist
• Memory check
• Compiler
• Compiler format
• Secret scrub
• Memory drift
• Retrieval
• Shared memory promotion rules
• Operator CLI
• Runner
• LLM compiler
• Candidate materialization
• LLM roundtrip
• Agent-connected workflow
• Build memory with agents
• Runtime orchestration
• Runtime batch flow
• Continuation guide
• Automation
• Roadmap
• Brand copy