Skip to main content

Memory Systems Compared

OpenClaw ships with a working memory system: Markdown files in the agent workspace, a SQLite search index, and a nightly consolidation sweep called Dreaming. Most people should start there. This page explains what the built-in system does as of v2026.10.4, which bundled plugins extend it, and when a third-party system is worth the extra moving parts.

The reference is the official Memory overview. This page summarises it and adds a comparison of community projects.

Quick Decision​

Your situationStart with
Just getting startedBuilt-in memory (default, nothing to configure)
Privacy first, nothing leaves the machineBuilt-in memory with a local embedding provider (local, ollama) or keyword-only search
You want a curated knowledge base, not raw notesBundled Memory Wiki plugin
Long sessions where compaction loses detailLossless Claw (third-party plugin)
Team or hosted memory serviceMem0, Supermemory, or Honcho
Coding agents, persistent dev contextclaude-mem
Verbatim recall of everything saidMemPalace

Built-In Memory​

OpenClaw remembers by writing plain Markdown files in the agent's workspace (default ~/.openclaw/workspace). There is no hidden state: if it is not on disk, the model does not remember it. In a multi-agent setup each agent has its own workspace and its own memory.

QMD is gone

v2026.8.1 ("OpenClaw 2.0") retired the QMD memory backend. Built-in memory now owns search and recall. If you used QMD, run openclaw doctor --fix: it removes the retired QMD settings, carries forward supported extra paths and session indexing, and rebuilds the index from your Markdown files. QMD-only reranking, query expansion, and cross-agent transcript search do not carry over. See the v2026.8.1 memory notes.

How It Works​

~/.openclaw/workspace/
├── USER.md                 # Optional. Stable preferences and profile facts, written as directives
├── MEMORY.md               # Long-term memory: durable facts and decisions
├── DREAMS.md               # Optional. Dream Diary and sweep summaries for human review
└── memory/
    ├── 2026-10-17.md       # Daily notes (running context, observations)
    ├── 2026-10-18.md
    └── imports/            # Memory imported from Codex, Claude Code or Hermes
FileLoaded how
USER.mdInjected at session start, with its own small budget (fixed 4,000-character cap)
MEMORY.mdInjected at session start, within the bootstrap file budget. If it grows past the budget, the file stays intact on disk but the injected copy is truncated
memory/YYYY-MM-DD.mdNot injected on every turn. Indexed for memory_search / memory_get. Today's and yesterday's notes load on a bare /new or /reset
DREAMS.mdFor you to read; not part of the prompt

To make the agent remember something, ask it: "Remember that I prefer TypeScript." It writes the note to the right file. Before compaction summarises a long conversation, OpenClaw also runs a silent "memory flush" turn so the agent can save important context first (on by default; agents.defaults.compaction.memoryFlush.enabled: false turns it off).

Use /context list or /context detail in chat to see how much of MEMORY.md is actually reaching the model (raw versus injected size, and whether it was truncated).

Configuration​

The root memory key is strict and has only two children: citations and search. Everything else about memory either has sensible defaults or lives in the memory-core plugin config. This example keeps embeddings on the machine with the managed local GGUF model:

~/.openclaw/openclaw.json
{
  memory: {
    citations: "auto",     // "auto" | "on" | "off"
    search: {
      provider: "local",   // managed llama.cpp GGUF model, ~0.3 GB, no API key
    },
  },
}

Older keys such as memorySearch were migrated to memory.search by Doctor. All search options are in the Memory configuration reference.

Retrieval​

The agent gets two memory tools from the active memory plugin (default memory-core): memory_search (semantic plus keyword search across memory files) and memory_get (read a file or line range). A third, intent, manages event-conditioned standing intents.

When an embedding provider is available, memory_search runs two paths in parallel and merges them:

StepWhat happens
Vector searchSemantic similarity over embeddings (weight 0.7)
Keyword searchExact terms, IDs, error strings; BM25 on SQLite (weight 0.3)
Weighted mergeThe two scores are combined (not Reciprocal Rank Fusion)
Recency and importanceDated daily notes decay with a 30-day half-life; MEMORY.md and USER.md are evergreen
MMRReorders results to drop near-duplicate snippets
Embeddings are remote by default

OpenClaw uses OpenAI embeddings by default, so note content is sent to an embedding API unless you choose otherwise. For local-only operation set memory.search.provider to "local", "ollama" or "lmstudio", or to "none" for keyword-only (FTS) search with no embeddings at all. Other supported providers: Gemini, Voyage, Mistral, Bedrock, DeepInfra, GitHub Copilot, and any OpenAI-compatible endpoint (openai-compatible). See Memory search.

If you name a provider explicitly and it fails (bad key, network down), memory_search reports memory as unavailable rather than silently falling back to keywords. Leaving the provider unset, or using "local", falls back to keyword ranking instead.

Dreaming (memory-core plugin)​

Dreaming is the background consolidation sweep in the bundled memory-core plugin. It promotes strong short-term signals from daily notes and interactive sessions into MEMORY.md. It has been enabled by default since v2026.8.1; you do not need to configure anything.

Each sweep runs three phases, in this order:

PhaseWhat happensWrites MEMORY.md?
LightSorts and stages recent short-term material, dedupes signalsNo
REMBuilds theme and reflection summaries from recent tracesNo
DeepScores candidates and promotes the ones that pass every thresholdYes

Deep ranking uses six weighted signals: relevance 0.30, frequency 0.24, query diversity 0.15, recency 0.15, consolidation 0.10, conceptual richness 0.06. Candidates must also pass the minScore, minRecallCount and minUniqueQueries gates. Untrusted and system-derived candidates (tool output, web content, non-owner turns) never reach the promotion path. Phase summaries go to DREAMS.md for review.

The sweep runs once a day at 03:00 by default. To change the schedule:

~/.openclaw/openclaw.json
{
  plugins: {
    entries: {
      "memory-core": {
        config: {
          dreaming: {
            enabled: true,
            timezone: "America/Los_Angeles",
            frequency: "0 3 * * *",   // cron expression; this is the default
          },
        },
      },
    },
  },
}

To opt out, set dreaming: { enabled: false }, or send /dreaming off in chat (owner only; /dreaming status shows the current state). There is one sweep and one frequency for the whole Gateway, not one per agent. In a fleet with agents.ownership: "explicit", choose which agent owns the sweep with openclaw config set agents.defaults.systemAgent.agentId <agent-id>. Dreaming also depends on the scheduler: with cron.enabled: false (or OPENCLAW_SKIP_CRON=1) it defers creating or updating its sweep job. Details in Dreaming.

Bundled memory plugins​

These ship with OpenClaw and are maintained upstream:

PluginWhat it adds
memory-core (default)Built-in search, recall, Dreaming. See Builtin memory engine
memory-wikiCompiles durable memory into a wiki vault with claims, evidence, freshness tracking and wiki_* tools. Sits beside memory-core, does not replace it. Memory Wiki
memory-lancedbLanceDB-backed memory with auto-recall and auto-capture; supports local Ollama embeddings. Memory LanceDB
active-memoryA memory sub-agent for interactive chats. Active memory
HonchoCross-session memory with user modelling (plugin install). Honcho memory

Inspecting, importing and forgetting​

openclaw memory status            # index and provider status (--deep probes the embedding provider)
openclaw memory search "meeting notes"
openclaw memory index --force     # full reindex
openclaw memory forget --agent main --session <id-or-key> --dry-run   # preview what would be deleted
  • Import. In the Control UI, Settings → Import Memory copies Markdown memory from Codex (~/.codex/memories), Claude Code (~/.claude/projects/*/memory) or Hermes into memory/imports/ in the chosen agent's workspace. Imported files are searchable but are not merged into MEMORY.md.
  • Provenance and forgetting. memory forget removes memories derived from selected sessions or participants and stops them being re-ingested. It deletes immediately unless you pass --dry-run, and it does not delete the original transcripts or copies outside the memory stores. An admission policy can keep chosen sources out of memory in the first place. See Memory provenance and deletion.

When Built-In Is Enough​

  • One user, one or a few agents
  • You want to read and edit memory as plain files, and keep them in Git
  • You are happy with a nightly consolidation sweep
  • You can choose a local embedding provider if privacy matters

Memory records context; it does not enforce policy. Use approvals and sandboxing for hard limits on what the agent can do (Security Hardening).

Community Memory Systems​

None of these is maintained by the OpenClaw project. Star counts and last-push dates are from the GitHub API as of 2026-10-18. Performance figures quoted in project READMEs are vendor claims; test with your own data before relying on them.

Comparison Matrix​

SystemStarsLast pushTypeHow it connects
Mem067,3722026-10Managed / self-hosted memory layerSDK / API
memU14,5532026-10Proactive memory frameworkCommunity OpenClaw plugin
OpenViking40,2182026-10Context database (L0/L1/L2 tiers)Integration guide
MemPalace59,6222026-10Verbatim conversation storageSDK
Supermemory31,2722026-10Fact-extraction memory engineMCP / API
Lossless Claw4,9082026-10DAG summarization, replaces compactionOpenClaw plugin
LanceDB-Pro4,4522026-10LanceDB memory pluginOpenClaw plugin
Hindsight50,9972026-10Agent memory frameworkSDK
claude-mem101,5032026-10Context compression for coding agentsMCP / OpenClaw installer
MemoV1942026-02 (dormant)Git-like traceable memoryMCP
PowerContext1,3372026-10Context service (formerly PowerMem)Server / API
Cognee32,4642026-10Knowledge graph memoryMCP / SDK
Letta25,1752026-09Stateful agent frameworkSDK
GBrain30,9702026-10Agent "brain": knowledge pages, ingestion, scheduled consolidationClawHub bundle plugin / MCP
agentmemory29,6402026-10Persistent memory server for coding agentsNative OpenClaw plugin (connector) / MCP

Mem0​

General-purpose memory layer storing memories across vector, key-value and graph backends.

  • Repo: mem0ai/mem0
  • Integration: Python/TypeScript SDK and API; hosted platform or self-hosted
  • Fit: teams that want a managed service with analytics and support. Mem0 is not OpenClaw-specific: you connect it yourself, through a custom plugin, skill or MCP server.

memU​

Proactive memory for always-on agents, organised in three layers (Resource → Item → Category).

OpenViking​

Context database from Volcengine, a general agent context store with tiered loading (L0 abstract, L1 overview, L2 full detail). It is not OpenClaw-specific, but publishes an OpenClaw integration guide.

MemPalace​

Verbatim conversation storage. It keeps whole conversations instead of compressed facts, so recall is high but storage grows quickly.

caution

MemPalace's published benchmark numbers were disputed after launch. Evaluate it on your own workload.

Supermemory​

Memory engine that extracts and stores facts rather than document chunks, with handling for updates, contradictions and expiry.

Lossless Claw​

DAG-based context management plugin for OpenClaw. It replaces the built-in sliding-window compaction: every message is kept in lcm.db, older chunks are summarised into DAG nodes, and the agent gets lcm_grep, lcm_describe and lcm_expand tools to recover detail.

  • Repo: Martian-Engineering/lossless-claw. Install with openclaw plugins install as described in its README.
  • Fit: long-running agents where compaction loses information you need later

LanceDB-Pro​

Third-party LanceDB memory plugin for OpenClaw that stores preferences, decisions and project context and auto-recalls them. Compare it with the bundled memory-lancedb plugin before choosing.

Hindsight​

Agent memory framework built around separate networks for world facts, agent experiences, entity summaries and evolving beliefs, with Retain / Recall / Reflect operations.

claude-mem​

Context compression for coding agents. It captures observations after tool calls and loads only the relevant ones in later sessions.

  • Repo: thedotmack/claude-mem
  • Integration: MCP server; works with Claude Code, Codex, Gemini, and OpenClaw. For OpenClaw the README offers a curl … | bash installer. Read the script before you run it.

MemoV​

Git-like traceable memory for coding agents: snapshots, diffs and rollback for prompts, context and code, kept outside your normal .git.

  • Repo: memovai/memov. Dormant: no push since 2026-02-05.
  • Integration: MCP server

PowerContext (formerly PowerMem)​

Open-source context service from OceanBase that keeps decisions, constraints, evidence and progress outside any single conversation, so later sessions, agents or people can pick up from the current state. The project was renamed from PowerMem; the old URL redirects.

  • Repo: oceanbase/powercontext
  • Integration: server or embedded library; the repo includes an OpenClaw integration guide
  • Fit: multi-agent setups that need shared, governed context

Cognee​

Graph-native memory: a knowledge graph combined with vector and relational storage, with entity, relationship and provenance tracking.

Letta​

Stateful agent framework (formerly MemGPT) that manages memory as discrete blocks moved between context and long-term storage.

  • Repo: letta-ai/letta
  • Integration: SDK, plus a desktop development environment

GBrain​

An opinionated agent "brain" by Garry Tan: a store of pages about people, companies and ideas that the agent fills from meetings, email and other sources, with scheduled jobs that enrich and consolidate it overnight. The README describes it as the memory behind the author's own OpenClaw and Hermes deployments, and is candid that the always-on server setup is the costly path (an 8 GB+ server plus model tokens).

  • Repo: garrytan/gbrain, MIT, created 2026-04-05; latest release v0.60.299.0 on 2026-10-18 (GitHub API)
  • Integration: per its README, a ClawHub bundle plugin (the repo ships openclaw.plugin.json) or an MCP server registered with OpenClaw; see its OpenClaw guide. clawdocs has not tested it.
  • Fit: users who want the agent to build a large, curated knowledge base, not just recall past chats

agentmemory​

A local memory server for AI coding agents (Claude Code, Codex, Copilot CLI, Cursor, Hermes, OpenClaw and any MCP client) that captures sessions and recalls them later.

  • Repo: rohitg00/agentmemory, Apache-2.0, created 2026-02-25; latest release v0.9.30 on 2026-10-06 (GitHub API)
  • Integration: per its README, a connector installs a native OpenClaw plugin and skills, takes the memory slot and enables conversation access; replacing another memory plugin needs --force. MCP tools are opt-in. See its OpenClaw setup. clawdocs has not tested it.
  • Fit: people who use several coding agents and want one memory shared between them

Integration Methods​

MethodSetupExamples
Bundled pluginLowest: ships with OpenClawmemory-core, memory-wiki, memory-lancedb, active-memory
Third-party OpenClaw pluginLow: openclaw plugins install, then configureLossless Claw, LanceDB-Pro, memU engine
MCP serverMedium: run as a sidecar processclaude-mem, MemoV, Cognee, Supermemory
SDK / APIHigher: build your own integrationMem0, MemPalace, Hindsight, Letta, OpenViking, PowerContext

A plugin runs inside the Gateway process with the Gateway's permissions, so treat a third-party memory plugin like any other plugin: read the code, pin the version, and check Skill and plugin verification. An MCP server runs separately and any MCP client can use it. An SDK gives the most control and the most code to maintain.

Decision Framework​

By Privacy Requirements​

RequirementOptions
Nothing leaves my machineBuilt-in with local/ollama/lmstudio embeddings or provider: "none", Lossless Claw (with a local summarisation model), MemoV, Cognee in local mode
Self-hosted service is fineMem0 (self-hosted), PowerContext, OpenViking
Managed cloud is fineMem0 Platform, Supermemory, Honcho

Remember that whatever memory is loaded into a prompt is sent to your model provider.

Getting Started​

Use the built-in memory and change nothing; Dreaming is already on. The one setting worth deciding early is the embedding provider: the default sends note text to OpenAI, so pick a local provider if memory must stay on the machine (see Configuration). Check it with openclaw memory status.

Add something else only when built-in recall misses notes you know exist (try openclaw memory search and a better embedding provider first), compaction loses detail you need, or several agents or people need shared or structured memory. Most community systems run beside memory-core rather than replacing it, so trial one as an MCP server for a week before committing.

See Also​