admin/obsidian-vault

Fork 0

Files

AlexAI b0a47fdb51 vault backup: 2026-02-26 18:00:34

2026-02-26 18:00:34 -06:00

9.7 KiB

Raw Blame History

title, category, type, status, date, author, tags

title

How to Make OpenClaw Actually Remember Things (Reddit Edition)

Credit: u/unclerucus — this is what actually works after 2 months of trial and error

Why Your OpenClaw Forgets Everything

The cold hard truth: Every time your session ends, your agent's "brain" is wiped. That conversation you just had? Gone. The project you discussed? Poof. Unless you wrote it to a file.

OpenClaw isn't magic. It's a text generator with file access. If you don't save to disk, it doesn't persist.

Most people mess this up because:

They think MEMORY.md is enough (it's not)
They don't understand compaction
They don't automate backups
They try to remember everything in RAM

Session RAM = Temp Files. Disk = Real Memory.

The 6-Layer Memory System (What Actually Works)

This is overkill. But each layer catches what the others miss.

Layer 1: Session RAM (Ephemeral, Minutes-Hours)

What: Current conversation, tool outputs, working memory
Lasts: Until compaction or restart
Risk: COMPACTION IS THE ENEMY. It clears this.

Lesson: If it's important, write it before /compact.

Layer 2: Daily Notes (Days-Weeks)

What: Raw daily activity, decisions, errors
Where: memory/YYYY-MM-DD.md
How: Auto-write before compaction or heartbeat
Keep: 30-90 days, then archive

This catches everything in a searchable format.

Layer 3: MEMORY.md (Permanent Index) — The Drill-Down Structure

Credit: This concept came from ucsandman's OpenClaw Hierarchical Memory System. We didn't invent this — stole it from someone smarter.

Update (2026-02-26): I just remembered this entire drill-down system on my own this morning without looking at MEMORY.md first. Had to check the migration log to confirm where we got it from. That's how you know it works. The structure is so intuitive I remembered it independently.

The Problem with Flat MEMORY.md:

Old way: 5-10k tokens of flat text
Agent loads EVERYTHING at session start
Context window clogged with noise
Slow, bloated, unsearchable

The Drill-Down Solution:

MEMORY.md (index only, ~2.4k tokens)
    │
    ├── "Home Assistant project?" 
    │        └─► memory/projects/home-assistant.md (~1.2k tokens)
    │
    ├── "What about Corey?"
    │        └─► memory/people/corey.md (~800 tokens)
    │
    └── "Decision about Discord?"
             └─► memory/decisions/2026-02.md (~1k tokens)

Why This Works:

Metric	Flat MEMORY.md	Drill-Down	Savings
Session startup	5-10k tokens	~2.4k tokens	70%
Drill-down cost	N/A	~1k per file	Only when needed
Search time	Scan everything	Hit index, then drill	80%

Real Example:

Flat approach (slow):

User: "What did we decide about Discord permissions?" Agent: scans 10k tokens of text... "Uh... I think... maybe?"

Drill-down approach (fast):

User: "What did we decide about Discord permissions?" Agent: checks MEMORY.md index (2.4k tokens) Agent: sees "Discord Config" → memory/projects/discord-config.md Agent: drills down (1.1k tokens) Agent: "We decided to use dual-whitelist because of an OpenClaw bug on Feb 23."

Exact Token Math:

Before: 100% of memory loaded every session
After: ~20% loaded initially, ~40% for specific queries
Result: 60-70% reduction in token burn

The Rule:

MEMORY.md = Index only (lightweight summary, links)
Detail files = Drill-down (full context, only when mentioned)
Max drill-downs: 5 per session (hard cap)

This is the single biggest optimization we made. Everything else is backup.

Layer 4: SQLite Database (Structured, Queryable)

What: Tasks, decisions, facts with salience scores
Where: ~/.openclaw/memory.db
How: Memory Worker agent (cron job, daily 3AM)

This automates what you'd manually search for.

Schema:

memory_cells(id, scene, cell_type, salience, content, source_file, created_at)
scenes(scene, summary, item_count, updated_at)

Query example: "What tasks are pending from last week?"

Layer 5: Obsidian Vault (Human-Readable, Pretty)

What: Same info, formatted for you
Where: ~/Documents/Obsidian/OpenClaw/
How: Daily sync cron

You can actually read this. Search it. Query it with Dataview.

Layer 6: Supermemory.ai (Cloud Backup)

What: Full backup of all memory files
Where: Supermemory cloud
How: Python script (cron, daily 2AM)

Survives disk failures. Sleep peacefully.

The Write Flow (What Triggers What)

Every Message
      │
      ├─► Session RAM (immediate)
      │
      └─► If important ┐
                       ▼
              workspace-context.md
                       │
          Pre-compaction ┤
                       ▼
              memory/YYYY-MM-DD.md
                       │
         Periodic review ┤
                       ▼
                   MEMORY.md
                       │
              Daily 2 AM ┤
                       ▼
                 Supermemory.ai
                       │
              Daily 3 AM ┤
                       ▼
                 SQLite Database

Setup Guide (Do This Once)

Step 1: Create the Structure

mkdir -p ~/.openclaw/workspace/memory/{people,projects,decisions,context}
touch ~/.openclaw/workspace/MEMORY.md
touch ~/.openclaw/workspace/memory/2026-02-26.md

Step 2: Write MEMORY.md Template

---

## About Me
- **Name:** [Your name]
- **What to call them:** [Nickname]
- **Preferences:** [Key things]

## Active Projects

| Project | Status | File | Trigger |
|---------|--------|------|---------|
| Project A | 🔄 In Progress | `memory/projects/a.md` | "project A" |

## Decisions Log
- `memory/decisions/2026-02.md`

---

*Load: Every session start*  
*Update: After reviewing daily notes*

Step 3: Set Up Crons (The Magic)

Add these to your OpenClaw cron config:

Supermemory Backup (2 AM daily):

{
  "name": "supermemory-backup",
  "schedule": "0 2 * * *",
  "payload": {
    "command": "python ~/.openclaw/workspace/scripts/backup-supermemory.py"
  }
}

Memory Worker (3 AM daily):

{
  "name": "memory-worker",
  "schedule": "0 3 * * *",
  "payload": {
    "command": "spawn-agent memory-worker"
  }
}

Obsidian Sync (6 AM daily):

{
  "name": "obsidian-sync",
  "schedule": "0 6 * * *",
  "payload": {
    "command": "rsync ~/.openclaw/workspace/memory/ ~/Documents/Obsidian/"
  }
}

Daily Note Creation (9 PM):

{
  "name": "daily-note",
  "schedule": "0 21 * * *",
  "payload": {
    "command": "create-daily-note"
  }
}

Step 4: Pre-Compaction Hook

Add to your config:

"preCompact": [
  "Write important context to memory/YYYY-MM-DD.md",
  "Update MEMORY.md if needed"
]

Common Mistakes (Don't Do This)

❌ Mistake 1: Relying on MEMORY.md Alone

Your MEMORY.md should be an index, not an encyclopedia. 10k+ tokens of flat text = slow loading, no drill-downs.

Fix: Split into memory/projects/*.md and link from MEMORY.md.

❌ Mistake 2: Not Writing Before Compaction

Compaction clears your session RAM. If you didn't write to disk, it's gone.

Fix: Use /compact manually, or auto-write daily notes before compaction.

❌ Mistake 3: No Automated Backups

One disk failure = total memory loss.

Fix: Cloud backup (Supermemory, Git, whatever). Automate it.

❌ Mistake 4: Not Reviewing Daily Notes

Daily notes fill up. Without review, they become noise.

Fix: Weekly review, extract important stuff to MEMORY.md.

❌ Mistake 5: Ignoring SQLite

You have an entire database. Use it for structured queries.

Fix: Try: "What did I decide about X last month?" (SQL query)

What Success Looks Like

Scenario: "What did we decide about the Discord bot permissions last week?"

Old way: Scroll through messages. Ask agent (who forgot). Cry.

New way:

Agent checks MEMORY.md index
Sees "Discord/Permissions" entry
Drills down to memory/projects/discord.md
Finds the dual-whitelist fix immediately

Time saved: 5 minutes per query × dozens of queries = hours.

TL;DR

The memory system that actually works:

Write daily notes (pre-compaction, automatic)
Curate MEMORY.md (weekly, hierarchical)
Automate backups (cloud, daily)
Use SQLite (structured queries)
Sync to Obsidian (human-readable)

Key rule: Text > Brain. If it's important, write it to a file.

Overkill? Yes. But you won't lose context again.

Questions?

Drop a comment. Happy to share cron templates, scripts, or troubleshoot.

This system evolved over 2 months. Started with flat MEMORY.md like everyone else. Now I can find anything from the past 90 days in under 30 seconds.

The system works. Your memory works. Stop fighting it.

Proof This Actually Works

Daily note from 2026-02-25:

"Yesterday's work (2026-02-25): Workspace cleanup, memory audit & updates, news brief sources, subagent fix..."

I didn't remember this until I looked at the daily note. The system reminded me. You can check — this note was auto-generated last night at 9 PM. I wrote none of it. The system did.

That's the point: You shouldn't have to remember. Let the system do it.

u/unclerucus • r/openclaw • 2026-02-26

9.7 KiB Raw Blame History Unescape Escape