ScallopBot / OpenClaw memory

OpenClaw memory vs ScallopBot memory

Both assistants keep long-term memory and both consolidate it in the background. OpenClaw’s “dreaming” promotes the notes you keep recalling into a curated MEMORY.md. ScallopBot rewrites memory itself: it fuses duplicates, links related memories, and forgets what stopped being useful. This page explains how ScallopBot’s memory works, and how to use it from other tools over MCP.

The difference

Promotion vs consolidation

OpenClaw scores what you keep recalling and promotes the strongest items from daily notes into MEMORY.md; existing entries stay as written and nothing is pruned. ScallopBot runs a nightly sleep-style cycle that merges, links and decays memories, then retrieves with BM25 + embeddings, an optional LLM rerank, and a score gate. The full feature comparison covers the rest, including the rows OpenClaw wins.

How it works

Bio-inspired memory lifecycle

Memory is not a write-once store with a similarity search bolted on. It runs a four-stage lifecycle modelled on how sleep processes memory in a brain — encode, consolidate, associate, prune. The schedules, thresholds and diagrams are on the memory architecture page.

Encode
A conversation turn is read for durable facts. Chatter is dropped; what is worth keeping is written with its date attached, so time-based questions have something to match against later.
Consolidate (NREM)
A nightly dream cycle replays fading and mid-strength memories, fuses duplicates, and strengthens what keeps recurring — the same job slow-wave sleep does. Several notes about one story end up as one coherent memory instead of a pile of near-duplicates.
Associate (REM)
A second, looser pass links memories that are not obviously related, building the cross-session associations a single-shot retriever would never surface.
Prune
Decay ticks age out what stopped being useful. Memory that only ever grows is memory that only ever gets noisier to search.

Hybrid retrieval

Recall runs BM25 keyword matching and dense embedding search together, then optionally reranks the merged candidates with an LLM before anything reaches the context window. Keyword search catches the exact name or identifier an embedding blurs; the embedding catches the paraphrase BM25 misses. The rerank is optional — turn it off and you trade a little accuracy for a cheaper, faster path.

Results are score-gated rather than top-k truncated. If nothing clears the bar, nothing is injected, so on a question with no stored answer the system declines instead of confabulating from weak matches.

Temporal queries

Memories carry their dates into the embedding rather than sitting beside a timestamp column. A regex-based detector spots when a question is time-scoped — “last month”, “before the review”, “what changed since” — and routes it through time-aware retrieval instead of plain similarity.

MCP-native, in both directions

ScallopBot is an MCP client: a bundled skill lets it consume any MCP server you already run, so those tools are available to the assistant alongside its own.

It also exposes its memory over MCP. The bundled MCP server publishes three tools that any MCP client can call — Claude Code, or anything else that speaks the protocol:

memory_store
Write a durable fact into the memory database.
memory_recall
Hybrid BM25 + embedding search over stored memory.
memory_temporal
Time-scoped query — what was true, and when.

It runs straight out of the build — node dist/mcp-server/index.js with SCALLOPBOT_DB pointed at your memory database. To register it with Claude Code:

claude mcp add scallopbot --env SCALLOPBOT_DB=/path/to/memories.db -- node /path/to/scallopbot/dist/mcp-server/index.js

There is no npm package yet, so both paths point at your own clone of the repo.

FAQ

Common questions

Does it work with OpenClaw skills?

Yes. Every capability in ScallopBot — bash, browser, file I/O, git, Docker, PDF, web search, memory — is a self-contained skill written in the OpenClaw SKILL.md format. Skills declare their own requirements (binaries, env vars, OS) and are gated at load time.

That means community skills built for OpenClaw install and run, including ones pulled from ClawHub with a single CLI command. Memory search is itself one of these skills, so it composes with the rest rather than sitting beside them.

How is OpenClaw's memory different?

OpenClaw's “dreaming” (on by default) runs a light, REM and deep sweep that scores what you keep recalling and promotes the strongest notes from daily files into MEMORY.md. It is a promotion step: existing entries are kept as written, and nothing is forgotten. Search ranking applies a recency decay, but notes are not archived or pruned.

ScallopBot's consolidation rewrites memory instead: NREM fusion merges duplicates and clusters fragments into new summaries, REM builds typed associations recall can follow later, and a utility-based decay soft-archives then prunes what stopped being useful.

Can Claude Code use it over MCP?

Yes. ScallopBot ships an MCP server that exposes its memory as three tools — memory_store, memory_recall and memory_temporal — so Claude Code, or any other MCP client, can write to and query the same memory the assistant uses.

Register it with: claude mcp add scallopbot --env SCALLOPBOT_DB=/path/to/memories.db -- node /path/to/scallopbot/dist/mcp-server/index.js. There is no npm package yet, so the paths point at your own clone.

It works in the other direction too: a bundled skill makes ScallopBot an MCP client, so any MCP server you already run is available to the assistant.

Is there a benchmark?

The current published comparison is a tool-calling benchmark rather than a memory one: 36 tasks run 3 times each by ScallopBot, Prime Agent, OpenClaw and Hermes Agent on the same model, scored on outcomes only. ScallopBot tied Prime Agent for the top score (98.1%), with OpenClaw at 97.2%. The full results are on the homepage.

→ Full feature comparison vs OpenClaw · What it costs to run · Tool-calling benchmark · Source on GitHub