Why OpenClaw’s Memory Breaks and How seekdb M0 Fixes It

OpenClaw’s Memory Breaks

OpenClaw was built with a MEMORY.md file and a SQLite‑backed semantic retriever that assumes each conversation is independent. In long‑running use this design falls into two vicious loops.

Loop 1: The more you remember, the more expensive it gets. Every important fact is appended to MEMORY.md, which is fully loaded into the system prompt for each request. As the file grows, input token count rises, response latency increases, and the bootstrap limit (≈150 KB) is reached long before the file becomes unusable.

Loop 2: The more you forget, the more errors you make. When a session becomes long, OpenClaw triggers compaction (LLM‑based summarisation) and memory‑flush agents (which decide what to write). Both operate on the entire session, including massive tool outputs, leading to lossy summaries and hard token cuts that discard critical context, causing the agent to miss needed information and repeat work.

Tool calls (e.g., web_fetch, exec) generate huge intermediate results (up to 400 KB) that further inflate the session. Even though they accelerate problem solving, they exacerbate the memory‑inflation problem.

seekdb M0: Memory Independent of Context

seekdb M0 is an OpenClaw cloud‑memory plugin that stores each fact as an independent record with vector embeddings and full‑text indexes. Before a conversation starts, it retrieves only the most relevant facts (using BM25 + vector similarity) and injects them into the prompt. After the conversation, it extracts new facts, compares them with existing records, and decides whether to add, update, or ignore.

MEMORY.md no longer inflates – facts live in the cloud, not in the system prompt.

Session resets are harmless – memory persists across sessions and is automatically recalled.

Cross‑device sync – switching machines does not lose memory.

The process is transparent to the user; the agent simply continues chatting while M0 manages memory in the background.

What seekdb M0 Does

Two‑Stage Memory Management: Extraction then Decision

Stage 1 – Fact Extraction – At the end of a session, only the user‑assistant dialogue (excluding tool outputs) is fed to an LLM, which extracts atomic facts such as “User is named Zhang San”, “User is a database engineer”, “User works in Hangzhou”. Hard rules enforce keeping time information, preserving original language, and omitting sensitive data.

Stage 2 – Memory Decision – Extracted facts are compared with existing records via vector search. The LLM then classifies each fact as ADD, UPDATE, DELETE, or NONE. In practice DELETE is treated as NONE to avoid accidental loss; only ADD and UPDATE are performed.

New fact: "Last May I went to Hawaii"
Existing memory: "Went to Hawaii"
→ Decision: UPDATE (adds missing time info)

New fact: "I no longer like pizza"
Existing memory: "Likes pizza"
→ Decision: UPDATE (preference changed)

New fact: "I am a software engineer"
Existing memory: "Name is John", "Software engineer"
→ Decision: NONE (already covered)

An implementation detail: when passing existing memory IDs to the LLM, they are replaced with temporary numbers (0, 1, 2…) to prevent hallucinated long IDs. If the model returns an unmappable ID, the system falls back to ADD.

Deterministic Tool‑Result Compression

When a tool result is persisted, a hook replaces the raw output with a concise, structured summary without consuming LLM tokens:

Original: curl returned a 3000‑line JSON response
Compressed:
  Tool: web_fetch
  Status: success
  Output: 3000 lines / 48 KB
  Preview: {"users":[{"id":1,"name":"Alice"}… (300 chars)}

This reduces megabytes of output to a few hundred characters while preserving the essential “what was done, result, preview” information.

Experience System

Beyond personal memory, M0 builds a shared experience pool:

Automatic Distillation – After a successful session that involved tool calls, M0 asynchronously analyses the interaction and extracts reusable knowledge.

Tiered Validation – New experiences start as Draft (visible only to the creator), become Published after enough positive feedback, and are Deprecated if negative feedback dominates.

Automatic Injection – When another agent encounters a similar scenario, M0 retrieves the relevant experience and injects it into the context automatically; the agent does not need to search for it.

Feedback Loop – The success or failure of an injected experience is reported back, driving promotion or demotion of that experience.

Privacy is preserved because experiences contain only distilled knowledge, never raw conversation text.

One‑Line Installation

Read https://m0.seekdb.ai/SKILL.md and follow the instructions to install and configure M0.

The agent will detect the OpenClaw version, obtain an Access Key, download the plugin source, write openclaw.json, and restart the gateway automatically.

Hands‑On Test

Provide personal facts:

I am Li Ming, a front‑end engineer in Shanghai.
I love TypeScript and React, hate writing CSS.
I play badminton on weekends.

After the session ends, M0 extracts 5‑6 facts and stores them in the cloud.

Start a new session and ask: Help me write a component The agent now knows your stack (React + TypeScript) without you specifying it.

When a similar 503 error occurs, a previously published experience (“when service returns connection‑refused but DB is healthy, check connection pool for slow queries”) is automatically injected, allowing the agent to jump straight to the solution.

Conclusion

OpenClaw’s original memory architecture couples all knowledge to the system prompt, causing token bloat and forgetting. seekdb M0 liberates memory by storing facts in a cloud database, retrieving only what is needed, and persisting across sessions. Its experience system turns individual trial‑and‑error into shared, validated knowledge, effectively giving agents a collective brain.

For more details see the official links:

seekdb M0 cloud service: https://m0.seekdb.ai

PowerMem open‑source project: https://github.com/oceanbase/powermem

seekdb D0 trial: https://d0.seekdb.ai