Why agent memory needs its own storage engine
Agents are starting to live for a long time. A coding agent works on the same repository for months. A support agent remembers every conversation with a customer. Soon, a personal agent will hold years of someone’s life: their jobs, homes, health, people.
Almost all of that memory is stored the same way: application code layered on top of Postgres, a vector database and sometimes a graph database. That works for a demo. It starts to break when memory lives long enough to matter.
Three things today’s memory stacks can’t do
1. Branch. Agents increasingly explore: try three fixes in parallel, search a tree of plans, let sub-agents learn different things from the same starting point. Each path needs its own memory, and the losing paths must not leak into the winner. A recent study from Columbia (BranchBench) ran a 1,000-step tree-search workload against today’s branchable databases. Neon hit its branch limit after 33 steps. Dolt managed 170 steps before a two-hour timeout. Their conclusion: no current system supports thousands of cheap branches without sacrificing normal query performance.
2. Rewind. “What did the agent know when it made that decision?” is the first question in every debugging session and every audit. With three separate stores and no shared clock, there’s no consistent answer. Vector databases usually keep no history at all.
3. Forget, provably. When a user says “forget everything about X”, the fact itself is easy to delete. The summaries, embeddings and extracted facts derived from it are not, because nothing records where they came from. For personal agents and regulated industries, “probably deleted” isn’t good enough.
None of these can be bolted on from above. They need to be properties of the storage engine.
What Vorl is
Vorl is an embedded, open-source memory engine for agents:
- One append-only log of everything the agent experiences.
- Indexes derived from that log (key-value, vector, full-text, facts), all sharing one sequence number, so one snapshot is consistent across every index.
- O(1) branching: a fork is a new manifest pointing at shared immutable files. No data copied.
- Time-travel: read any branch as of any point in its history.
- Lineage: every derived item points to its sources, so deletion can cascade and be enforced when files are rewritten.
It’s a library first: one directory on disk, like SQLite. Later, the same format on S3, Azure Blob or GCS, running in your own cloud.
Why an LSM tree fits
LSM trees write immutable sorted files and merge them in the background. Immutability is what makes branching cheap: a branch is a list of shared files plus its own new writes. Sequence numbers on every version are what make time-travel cheap. Compaction is where old versions, discarded branches and forgotten facts are physically removed. The data structure already has the right shape; it needs to be built for agents.
How I’m building it
Storage engines are easy to get almost right. So Vorl starts with the tests, not the engine:
- A reference model: the simplest possible implementation of the semantics, used as the oracle.
- A deterministic simulator: an in-memory filesystem that crashes, tears writes and injects I/O errors, all driven by a seed. Every failure prints a seed that reproduces it exactly.
- The engine is correct when it can’t be told apart from the model across millions of simulated runs.
That scaffold exists as of today. The first milestone is the storage core: a versioned key-value engine with O(1) branching and time-travel reads. The target is 10,000 live branches, forks under a millisecond regardless of data size, and the full 1,000-step tree search completing in minutes.
Building in public
Every Friday I’ll post what shipped, one number, what broke and what’s next. The code is Apache-2.0 on GitHub, and the design doc is open for critique.
If you’re building agents that run for a long time and memory is getting in your way, I’d like to hear what breaks for you.
Siddharth, Boolescale