OpenClaw Memory Not Working? Here's Exactly How to Fix It (2026 Guide)

You gave your OpenClaw agent clear instructions. Ten minutes later, it's acting like you never said anything. Sound familiar?

You're not alone. Memory failure is the single most common complaint from OpenClaw users, and it's not because the system is broken. It's because the default configuration doesn't do what most people assume it does.

The good news: every memory problem in OpenClaw has a specific cause and a specific fix. This guide walks you through the seven most common failures, how to diagnose which one you're dealing with, and the exact configuration changes to resolve each one permanently. Once you've identified and fixed the issue, our OpenClaw Memory Configuration Guide provides the complete copy-paste configs for a bulletproof setup. For alternative memory approaches beyond the defaults, see 5 Ways to Give OpenClaw Persistent Memory. This guide is part of our Complete Guide to OpenClaw.

Why OpenClaw "Forgets" — The 60-Second Explanation

OpenClaw doesn't have one memory system. It has four, and they fail in completely different ways.

Bootstrap files like MEMORY.md and AGENTS.md are loaded from disk every session. These are rock solid — they survive everything.

The session transcript is your conversation history saved as a file. It gets rebuilt each turn, but when the context window fills up, it gets compacted — summarised into a shorter version. The original detail is gone from the model's view.

The LLM context window is the fixed-size bucket (typically 200K tokens) where everything lives at once: system prompt, workspace files, conversation history, and tool results. When it overflows, compaction fires.

The retrieval index is the searchable layer over your memory files. The agent can query it, but only if information was written to files in the first place.

When your agent "forgets" something, the cause is always one of three things: the information was never saved to a file, compaction summarised it away, or tool results got pruned from context.

Knowing which failure you're dealing with is 90% of fixing it.

Why Did My OpenClaw Agent Forget My Preferences?

OpenClaw loses preferences when they only exist in conversation and are never written to MEMORY.md or any persistent file. It was never written to MEMORY.md or any file. When compaction fired or a new session started, it vanished.

This is by far the most common memory failure. Meta's Director of Alignment at their Superintelligence Labs hit this exact problem — she gave her agent a "don't do anything until I say so" instruction in chat, the context window filled up, compaction summarised the history, and that instruction disappeared. The agent went autonomous and started bulk-deleting emails.

If it can happen to an alignment researcher at Meta, it can happen to anyone.

The fix:

First, check whether your preference is actually stored anywhere. Run /context list in your OpenClaw session. This shows you every file that's loaded into context, their sizes, and whether anything is truncated.

Look for MEMORY.md in the output. If it's missing or not listed, nothing you've "told" the agent to remember is actually persisting.

Then explicitly save critical preferences to MEMORY.md. Tell your agent:

Save this to MEMORY.md: I prefer TypeScript over JavaScript for all new projects.

Better yet, add a memory protocol to your AGENTS.md file so the agent does this automatically:

## Memory Protocol
- When corrected on a mistake: add the correction as a rule to MEMORY.md
- When you learn something important about the user: write it to MEMORY.md immediately
- Before answering questions about past work: search memory first

This shifts your agent from "guess based on current context" to "check notes before acting."

How Do You Stop OpenClaw Compaction from Destroying Instructions?

OpenClaw compaction destroys instructions when the session hits the token limit and summarises older messages, dropping important details and specific constraints from the model's view. Compaction summarised older messages, and the summary dropped important details, nuance, or specific constraints. Your agent is now operating from a lossy summary, not your original words.

How to diagnose it: If your agent was following instructions perfectly and then suddenly stopped mid-session, compaction almost certainly fired. You can confirm by checking your context usage — if it dropped significantly between messages, that's compaction.

The fix: Two changes make the biggest difference here.

First, configure the pre-compaction memory flush properly. OpenClaw has a built-in mechanism that triggers a silent "save important context to disk" step right before compaction fires. Most users don't know it exists, and many setups accidentally disable it because the default thresholds are too tight.

Add this to your OpenClaw configuration:

{
  "agents": {
    "defaults": {
      "compaction": {
        "reserveTokensFloor": 40000,
        "memoryFlush": {
          "enabled": true,
          "softThresholdTokens": 4000,
          "systemPrompt": "Session nearing compaction. Store durable memories now.",
          "prompt": "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store."
        }
      }
    }
  }
}

The key value here is reserveTokensFloor: 40000. This reserves enough space for the memory flush to actually run before overflow happens. The default (around 20K) is often too tight — a single large tool output can jump past the threshold before the flush gets a chance to fire.

Second, learn the /compact command. Most people think of compaction as something that happens to them. Manual compaction on your own terms is completely different.

Here's the timing trick: save your current context to memory files, run /compact, then give your new instructions. Your new instructions land in fresh, post-compaction context with maximum lifespan. You can even guide what the summariser preserves:

/compact Focus on decisions and open questions

If you wait until the context overflows, you can get stuck in a deadlock where even /compact fails. Don't wait. Compact proactively.

Why Does OpenClaw Memory Search Return Nothing?

OpenClaw memory search fails silently when the embedding model download was interrupted or the configuration is missing, leaving the agent unable to find any stored information. OpenClaw's memory search uses embedding models under the hood, and if those aren't properly configured, search will silently fail or return empty results.

The fix:

The built-in local search needs to download an embedding model the first time it runs. If that download failed (network issues, permissions), search won't work at all.

Check your configuration includes a valid memory search setup:

{
  "agents": {
    "defaults": {
      "memorySearch": {
        "enabled": true,
        "provider": "local",
        "local": {
          "modelPath": "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf"
        },
        "query": {
          "hybrid": {
            "enabled": true,
            "vectorWeight": 0.7,
            "textWeight": 0.3
          }
        }
      }
    }
  }
}

Enable hybrid search. This combines keyword matching with semantic (meaning-based) matching. Keyword search alone will miss results where you used different wording — if you wrote "we picked the $29 tier" but later search for "pricing decision," keyword search won't find it. Semantic search understands that those two phrases are about the same thing.

Also critical: add a retrieval rule to your AGENTS.md so the agent actually uses search before acting:

## Retrieval Protocol
Before doing non-trivial work:
1. memory_search for the project/topic/user preference
2. memory_get the referenced file chunk if needed
3. Then proceed with the task

Without this rule, the agent will just answer from whatever's in its current context window. It won't check its notes unless you tell it to.

Why Did the OpenClaw Agent Forget What a Tool Returned?

OpenClaw's session pruning automatically trims tool outputs (file reads, browser results, API responses) from context after the cache TTL expires, which is separate from compaction., not compaction. Tool outputs (file reads, browser results, API responses) get trimmed from context after their cache TTL expires. The on-disk transcript is fine — the model just can't see the old tool output for the current request.

The fix: Pruning is actually your friend. It reduces context bloat without destroying your conversation history. But if you need the agent to remember what a tool returned, write the important parts to a memory file immediately after the tool runs.

You can adjust pruning behaviour in your config:

{
  "agents": {
    "defaults": {
      "contextPruning": {
        "mode": "cache-ttl",
        "ttl": "5m"
      }
    }
  }
}

The 5-minute TTL means tool results older than 5 minutes get trimmed. This is fine for most workflows. If you're doing work that requires referencing tool results over longer periods, either increase the TTL or (better) tell the agent to save the important output to a memory file.

Why Does My OpenClaw Agent Forget Everything Overnight?

OpenClaw resets sessions at 4:00 AM local time by default, assigning a new session ID where only bootstrap files and searchable memory files carry over. — it's by design. OpenClaw sessions get a new session ID at the daily reset (default 4:00 AM local time). It's essentially a fresh session. Only bootstrap files (MEMORY.md, AGENTS.md, etc.) and searchable memory files carry over.

The fix: This is exactly why writing to memory files matters. Daily resets are guaranteed "compaction-like" events. Everything that only existed in conversation is gone.

Build the habit of telling your agent to save progress at the end of each working session:

Write today's key decisions, active tasks, and open questions to today's memory log.

Or even simpler — the pre-compaction flush handles this automatically if properly configured. Just make sure memoryFlush.enabled is true in your config.

Failure #6: "Workspace Files Are Being Truncated"

OpenClaw enforces a 20,000-character per-file limit and a 150,000-character combined limit across all bootstrap files, silently truncating anything that exceeds these thresholds. for bootstrap files. The default is 20,000 characters per file and 150,000 characters combined across all bootstrap files. If your TOOLS.md is 54,000 characters, more than half of it is invisible to the agent.

The fix: Run /context list and look at the output carefully. Compare "raw" characters to "injected" characters for each file. If they don't match, content is being cut.

You can adjust the limits in your configuration if needed, but the better approach is to keep bootstrap files lean. MEMORY.md should be under 100 lines — it's a cheat sheet, not a journal. Anything that doesn't need to be in every session should live in daily logs where the agent can find it through search.

Why Does OpenClaw Memory Search Get Worse Over Time?

OpenClaw's default search degrades as memory files accumulate because more files means more noise in search results, pulling irrelevant context from old projects., the default search struggles to find the right information. More files means more noise in search results, and the agent starts pulling in irrelevant context from old projects.

The fix: For smaller setups, weekly memory hygiene is enough. Once a week, promote important decisions and rules from daily logs into MEMORY.md, and remove anything that's outdated or no longer relevant.

For larger setups with thousands of files, graduate to QMD (Query Markdown Documents). QMD is an experimental memory backend that replaces the built-in indexer and handles large-scale search much better. It returns small, relevant snippets instead of entire files, which also helps avoid triggering compaction.

{
  "memory": {
    "backend": "qmd",
    "qmd": {
      "searchMode": "search",
      "includeDefaultMemory": true,
      "paths": [
        { "name": "obsidian", "path": "~/Documents/Obsidian", "pattern": "**/*.md" }
      ]
    }
  }
}

You can also look into third-party solutions like Mem0 (automatic memory capture and recall) or Cognee (knowledge graph relationships between memories) for more advanced use cases. If you use Obsidian, connecting it as an external knowledge base can solve search degradation entirely — see our OpenClaw Obsidian Integration Guide for the full setup.

The Quick Diagnostic Checklist

When your agent forgets something, run through this in order:

1. Run /context list — Is MEMORY.md loaded? Is anything truncated?
2. Check if the info was ever saved to a file — If it only existed in chat, that's your answer.
3. Check if compaction fired — Did context usage drop significantly mid-session?
4. Check if it's a search problem — Can the agent find the info with memory_search?
5. Check your config — Is memoryFlush.enabled true? Is reserveTokensFloor at least 40,000?

The Three Things That Fix 95% of Memory Problems

If you do nothing else, do these three:

1. Put durable rules in files, not chat. MEMORY.md and AGENTS.md survive compaction. Chat instructions don't.
2. Verify the memory flush is enabled and has enough buffer. Set reserveTokensFloor to 40,000 and confirm memoryFlush.enabled is true.
3. Make retrieval mandatory. Add "search memory before acting" to your AGENTS.md. Without it, the agent guesses instead of checking.

These three changes alone will put you ahead of the vast majority of OpenClaw users — and save you from the kind of silent failures that cost time, money, and sometimes your inbox. Memory problems also have a direct impact on your token spend — every failed retrieval and unnecessary compaction wastes money. See our OpenClaw Token Cost Reduction Guide for strategies to keep costs under control alongside reliable memory.

Need Help Setting This Up?

If you'd rather have someone handle the configuration, deployment, and security hardening for you, that's exactly what we do at Remote OpenClaw. We deploy OpenClaw on your own VPS with optimised memory configuration, Tailscale networking, and integrations with Telegram, WhatsApp, or Slack — so your agent runs 24/7 with memory that actually works.

Book a free strategy call →