The Price Changed.
Your Agents Didn’t Notice.

Run an agent fleet long enough and it stops being a memory problem and starts being a hoarding problem.

Here’s the scenario, straight from the repo. A sourcing agent scrapes a competitor’s pricing page every morning. Days 1 through 8, it writes the same fact: Pro plan, $299/month. Eight clean writes, each one reinforcing the last. Your memory is now very confident about $299.

On Day 9, the competitor bumps the price to $349. The agent scrapes it, writes it, and walks away satisfied.

Your memory pool now holds nine pricing facts: eight that say $299, one that says $349. Tomorrow your synthesis agent will write the exec brief. It calls recall. Nine results come back, all relevant, all about the same plan, ranked by similarity — and eight of them are wrong.

Which number goes in front of the executive?

RAG never forgets — and that’s the problem

A vector database is an excellent librarian and a terrible editor. It will store every fact you ever wrote and hand them all back when they match. It has no concept of superseded. The $349 is just the ninth book on a shelf with eight copies of last week’s edition.

The usual patches don’t hold:

The price didn’t change in the prompt. It changed in the world. The fix has to live where the data does — not in the instructions wrapped around it.

Memory that knows what’s still true

MemClaw treats a write as an event, not just a row. When the sourcing agent writes $349 on Day 9, MemClaw doesn’t just append it. On commit, it queues contradiction detection, recognizes that the new fact supersedes the eight $299 entries about the same plan, and flips those eight to outdated. The crystallizer then merges the whole chain into one canonical fact — provenance retained, lineage tracked via supersedes_id — so the recall surface is clean before anyone reads it.

Memories live on an 8-status lifecycle that the system advances on its own, from contradiction signals and outcome feedback. No nightly cron you maintain. No “delete the old rows” ticket.

The stale answers don’t get filtered out of the response. They get marked not current at the source — so a governed recall never asks for them in the first place.

On Day 10 the synthesis agent calls memclaw_recall with status: “active”. One result comes back: $349. It also asks for the outdated count and reports it in the brief: 8 superseded $299 memories from Days 1–8, suppressed. The fleet didn’t just get the right answer — it can show its work.

Why three agents, not one

You could hand all of this to a single do-everything agent: scrape, verify, summarize. Don’t. A lone agent that writes and then reads its own output has no external check — if it misreads a page or hallucinates a number, that error is written to memory and recalled as gospel every day after.

The repo splits the work into three, which turns separation of concerns into a property of the memory layer itself:

A bad write from Sourcing is caught by Verification before it ever reaches Synthesis. Every write carries an agent_id, so the audit trail is per-role, not per-run — “which agent wrote this, and who confirmed it?” is always answerable. Shared memory only becomes trustworthy when the agents that write it are distinct from the agents that validate it.

Run it yourself — no key required

This is the part the OSS makes easy. MemClaw’s storage layer, lifecycle engine, crystallizer, contradiction detection, and the MCP tools are all Apache 2.0. For the local deploy you don’t even need an account:

git clone https://github.com/caura-ai/caura-memclaw.git cd caura-memclaw && docker compose up -d        # MEMCLAW_API_KEY stays blank

Then clone the demo, point OpenClaw at http://localhost:8000, deploy the three agent workspaces, and run the 14-day simulation:

git clone https://github.com/caura-ai/memclaw-long-run-fleet.git python simulate.py            # or --days 1 9 10 to jump to the good part

Days 1–8 reinforce $299. Day 9 fires the contradiction. Day 10’s brief returns one number and counts the eight it suppressed. Everything runs on your machine; nothing leaves your network; the lifecycle logic is yours to read, line by line.

When you’d rather not run the cluster

Self-hosting is the real thing, and it stays yours. But MemClaw is several services — Postgres, pgvector, a graph store, an embedding pipeline, the crystallizer batch job — and at some point you’d rather spend your time on agents than on docker compose and backups. Managed MemClaw runs the identical governed core for you — same lifecycle, same contradiction detection, same MCP tools — with a generous free tier to start. Same guarantees, none of the ops. And because it’s the same open core underneath, you can move between self-hosted and managed whenever it suits you — your memory comes with you, so you’re never locked in either direction.