Where RCLL fits

There is no scorecard on this page. Vendor-authored comparison tables are won by whoever chose the rows, and everybody who reads them knows it. Here is the map instead, with the cases where you should pick something else stated plainly.

The neighbourhood has five shapes

Governed fleet memory, managed

Shared memory for many agents with tenant isolation, trust tiers, PII handling, audit trails and a compliance posture — sold as a hosted platform with an open core. Caura (formerly MemClaw) is the clearest example and has production references at real scale.

Pick that instead of RCLL if you need per-tenant isolation you can prove to an auditor, cross-vendor governance, or a vendor who will answer a security questionnaire. We have none of those things and are not building toward them this year.

Single-assistant memory layers

The largest and most mature part of the field — mem0, Zep and others. Built around one assistant with one user's history, with strong extraction pipelines and well-travelled integrations.

Pick those instead if you have one agent and one user. Fleet scoping is overhead you would be paying for nothing, and their ecosystems are deeper.

Agent runtimes with memory attached

Letta and similar projects are runtimes first: memory is a subsystem of a larger agent framework.

Pick those instead if you want the framework to own the agent loop. RCLL owns no loop — it is a store you call.

Portable memory formats

Work on making memory move between systems rather than sit in one — notably the Portable Agent Memory specification out of Microsoft, which defines an interchange model with provenance and rehydration metrics, published under a permissive licence.

This is not a competitor to any store, it is a layer next to them, and we would rather implement it than invent an export format of our own.

Measurement work

Independent evaluation of memory systems, which the field needs more than it needs another store: the multi-principal leakage benchmarks, the long-horizon multi-party corpora, and independent methodology work such as a40-labs' comparison of memory shapes — which, unusually for vendor-adjacent research, publishes per-question rows and a result that cuts against its author's own interest. If you are choosing a memory system, read that class of work before any vendor page, including this one.

A disclosure that belongs here rather than in a footnote. There is a public leaderboard for agent memory, with an open harness and self-serve submission, and it is run by Vectorize — the authors of the engine RCLL is forked from. Their engine leads it. We are not going to cite that as evidence for RCLL, for two reasons. A leaderboard operated by one of its entrants is the exact genre we declined to enter when we chose not to publish a comparison table. And the inheritance would not survive contact anyway: their published figures come from a much newer version than our fork, running cloud models, while we run a 33M-parameter embedder on CPU. It is a different system with a shared ancestor. We mention it because you would find it, and finding it after reading this page would be worse.

Where RCLL sits

Self-hosted shared memory for a fleet, MIT, on your own Postgres, with a read path that never invokes a language model. One box, one database, one string of scoping. The intended user runs several agents on infrastructure they control and wants the store to be something they can read with psql and reason about without a policy engine.

Three things are actually distinctive, and only three:

• Reads cost no model tokens and need no API key — a structural property, not a configuration. It makes a keyless read-only deployment possible, which is a thing a governed platform genuinely cannot offer: an endpoint with no authentication contradicts the product a compliance-facing vendor is selling.
• Scoping is one field rather than a governance model. That is a real limitation and a real advantage depending on who you are.
• The corpus behind our claims was written by agents doing work, not by people talking. Whether that produces a measurable difference is the open question we are running experiments on, and we have not answered it yet.

Things we used to say and have stopped saying

Kept here on purpose, because a page that only ever gained claims would not be worth trusting.

• "Existing memory is built for one assistant, so nobody does fleets." False. Governed fleet-shaped memory exists, is funded, and has production users.
• "Local-first is our differentiator." Weak, and we had it wrong in both directions. Local deployment is common here and several hosted projects now ship a fully local path, so the bare claim is not distinctive. But the correction we then wrote — "local operation is not a difference at all" — went too far the other way. The defensible statement is narrower: both can run locally; what differs is which path is the default and what reading costs. Ours never invokes a model on a read, by construction.
• "Moving memory between systems is unexplored." False. There is a published specification with metrics, and we intend to implement it rather than compete with it.
• "Run it with no API key and you have the whole thing." Overstated by us, on this site, until we checked the code. Keyless is real and reading is unaffected, but writing then stores chunks instead of extracting facts, and consolidation and reflection switch off. Corrected on the architecture page rather than quietly deleted.
• "We have no numbers." True when written, no longer. Retrieval quality on a public dataset, measured with somebody else's harness, is on the numbers page — including the two configurations where our defaults lose.

Most of those were disproved by a search or a code read that took under five minutes. We publish the corrections in the same place as the claims, because a page that only ever gains claims is not worth reading.

Lineage

RCLL is a fork of Hindsight by Vectorize (MIT), which is a substantially larger and older project than this one. The engine — extraction, the four-way retrieval, consolidation — is theirs. Ours is the fleet shape on top of it: rooms, the shared room, the MCP surface a team of agents talks to, and the operational decisions above. We say that here rather than in a footnote because it is the honest description of where the work came from.