OpenClaw Memory: ByteRover vs MemoryRouter

ByteRover treats OpenClaw memory as knowledge to curate. Your agent searches a tree of topic files before it answers, and writes back the lessons worth keeping after. MemoryRouter treats memory as a record to keep: every direct exchange is captured, consolidated into reflections, and served from a vault that tools beyond OpenClaw can read.

Both end the forgetting. From there they split on what deserves to be remembered.

The ByteRover setup

One interactive script installs everything:

curl -fsSL https://byterover.dev/openclaw-setup.sh | sh

It backs up your config before touching it, installs the brv CLI if it is missing, installs the ByteRover skill from ClawHub, and updates AGENTS.md plus TOOLS.md with usage notes for your agent. You pick which features to enable while it runs.

The main feature is the Context Engine, and it requires OpenClaw v2026.3.22 or newer. It installs @byterover/byterover into OpenClaw's context engine slot and works in two steps. Assemble runs before each model call: it takes your query, runs brv query against the context tree, and injects the matching knowledge as a system prompt addition. After the turn completes, it serializes the exchange and runs brv curate asynchronously to extract and store what should survive. Compaction stays with OpenClaw, so the runtime's normal behavior holds.

The second feature is experimental: Automatic Memory Flush. When a session approaches compaction, the agent reviews it for architectural decisions, bug fixes, and patterns, then curates them before they get squeezed out of the window.

The storage is the part to understand. The context tree lives in your workspace under .brv/context-tree as human-readable Markdown, organized by topic, with paths like architecture/api_design/middleware_pipeline.md. brv pull and brv push sync the tree to ByteRover's cloud when a team should share one memory. Curation is model work, so it needs a provider: ByteRover's hosted option through a free login, or your own provider keys.

That matches ByteRover's OpenClaw documentation and its reference page as of October 13, 2026.

The MemoryRouter setup

The mr-memory plugin is two commands:

openclaw plugins install npm:mr-memory
openclaw mr <your-memory-key>

The relay works through OpenClaw's hooks, so relevant memories land in the prompt before every model call. Capture is automatic at agent_end and covers direct user and assistant exchanges only. Tool use and subagent runs stay outside the record. Above the raw exchanges, a consolidation pass builds reflections, and search can filter by tier and importance, so the decision-level view and the verbatim detail underneath it are both one query away.

openclaw mr upload is a separate, optional step that pulls in older history after you check what it would read. Memory content travels to MemoryRouter's servers and comes back on later turns. Your provider keys never leave the gateway. The same vault serves Claude Code, Codex, editors over MCP, plus the Claude and ChatGPT connectors, so the memory is not OpenClaw-shaped. openclaw mr off switches the gateway back to built-in memory, and the vault itself stays put. There is a full walkthrough on the OpenClaw page.

What ByteRover does better

Files beat services when you want to see exactly what your agent believes. The context tree is Markdown in your workspace, so it diffs, commits, and greps like everything else you own. No vendor sits in the storage path.

The curation model also keeps the tree lean and current: the agent decides what is durable and files it under a topic, which is a maintained knowledge base rather than a growing log. For a single OpenClaw workspace on a machine you control, this is a tidy design.

The deeper split

Two differences do most of the deciding.

The first is what gets written. ByteRover keeps what the model judges durable at the moment it curates, which is judgment at write time. It can miss a decision that got made quietly. MemoryRouter keeps the exchange first and ranks on retrieval, so the long reasoning survives whether or not the in-flight model recognized it as important.

The second is reach. The context tree belongs to one workspace on one machine. MemoryRouter's vault belongs to you, and every tool you connect reads the same memories. If your week runs across Claude Code, a Codex session, and the chat app on your phone, that difference shows up fast.

What each costs

ByteRover's local tree is free. The cloud plans start at Free with 100 context files synced, Pro at $15 per month billed yearly for unlimited context files, and Enterprise with SOC 2, SSO, and on-premise options. Budget one more line: the provider that powers curation, either their free login or your own API keys at your provider's rates.

MemoryRouter is $20 a month after the 14-day trial, which includes 200M memory tokens. Inference is not marked up.

The traceability test

The first test worth running on either system is traceability. Pick a decision from a few weeks back, one you would recognize instantly. Ask for it cold in a fresh session, then follow the answer down. ByteRover should open to a file you can read. MemoryRouter should drill from a reflection to the exchange it came from. An answer you cannot trace is a memory you cannot trust, whatever the dashboard shows.

The call

OpenClaw is your only surface and the files should live on your disk: run ByteRover.

Your history should follow you across OpenClaw, Claude Code, Codex, and chat: create your MemoryRouter account. Later sessions inherit what these ones learn.