Models are the fastest-depreciating asset in software. The knowledge you build on top of them is the slowest. Someone has to build the layer in between — the substrate where context persists, evolves, federates, and reacts across every vendor, every model, every generation. That layer is REM.
Every day, billions of conversations happen with language models. Every day, that context evaporates. A coder explains the architecture of their system for the thirtieth time. A researcher re-derives a conclusion they already wrote last month. A sales rep re-learns a customer's preference. A founder re-explains their thesis to a brand-new assistant. None of it sticks. None of it compounds.
The models got better. The memory got worse. Context windows doubled, then doubled again — and every one of them resets the instant a session ends. Native memory features shipped — but each is locked to a single vendor, siloed per-app, non-portable, and routinely wiped with model upgrades. Vector databases spread — but a vector store is not memory any more than a library card is knowledge.
The result is a civilization-scale forgetting machine. The more we use these systems, the more work we do that never compounds. This is not a small problem. This is the most expensive bug in the history of software.
Most memory companies build a key-value store behind a chat UI and call it done. Drop a string in. Pull a string out. If it works, great. If it doesn't, add more RAG. The architecture assumes the hard part is retrieval. It isn't. Retrieval is a solved problem with enough compute. The hard part is what happens to the memory after it's stored.
We rejected the idea that memory should be passive. That it should wait for a query. That it should be single-vendor, single-model, single-session, single-user. That it should die when the session dies. That it should stay frozen in whatever shape it was first written.
We also rejected the idea that memory should be a product. Products are features. Features get bundled. Features get commoditized. Features die when the platform underneath them changes. What we needed was a substrate — something that outlives the current generation of models and becomes the layer everything else plugs into.
REM is infrastructure for knowledge that outlives any specific model. Four things make it substrate rather than product.
Persistence. Memories are stored in a portable format that doesn't depend on any vendor. Self-hostable via a single docker image. Model-agnostic writes and reads. Encrypted at rest. GDPR forget built in. Export to JSON, SQLite, or anything else at any time.
Evolution. The Dream Engine runs nine consolidation strategies on your knowledge nightly. This is the piece nobody else has. Memory isn't static — it gets refined, compressed, associated, validated, and projected forward while you sleep.
Federation. One knowledge substrate, many agents. Namespaces with RBAC. MCP and A2A support native. Every agent in an organization shares a context without context bleed. A coding agent and a deployment agent and a customer-support agent all read from the same graph, each with scoped visibility.
Reactivity. Memory is live infrastructure. HMAC-signed webhooks fire on every state change. WebSocket streams for real-time. Inbound webhook inbox on every API key. Memory reacts to the world instead of waiting to be asked.
Every decision we make is filtered through these. They are the thing that stays when everything else changes.
The 2010s built the compute layer. The early 2020s built the model layer. The rest of this decade will be defined by the layer between models and people — the layer where knowledge lives, compounds, and persists across generations of intelligence. That layer is memory. Not memory as a feature. Memory as infrastructure — at the same tier as storage, networking, and identity.
The winners will not be the people who shipped the biggest context window, or the flashiest RAG pipeline, or the prettiest chat app. The winners will be the ones who build the layer that every future agent, every future model, every future application treats as ambient — the way every web app today assumes TCP/IP is just there.
That is the bet. That is why REM exists. Every AI you use will be replaced. Your intelligence shouldn't have to be.
Free tier. Self-host. No vendor lock.