2026-06-26 · Architecture
Memory is a place, not a log
A model forgets. Between one call and the next the context window is wiped and refilled — whatever it knew about you sat on a desk, and the desk is cleared every morning. The common fix is a bigger desk: a longer context window. A bigger desk is still cleared every morning. More room to forget in is not memory.
Memory is the part that survives the wipe. Rent the model; the ground under it should compound — the record of what already happened, every decision and every correction. A model improves by version. A memory improves by use.
Where that record lives decides whether it works. A flat log is the wrong shape: append-only, read by scanning, with no sense of where anything belongs. Humans never used a log. They used places — to hold a list, you walk it through rooms, because location is how recall works. Put a fact somewhere and the somewhere becomes the handle.
Hindsight is that, shipped. A bank is the building. Memories sit in rooms by topic, halls by kind, and layers — priority tiers from a raw note up to a standing rule, the hierarchical memory an agent pages through the way an operating system pages RAM. Bridges tie a memory in one bank to the ones that explain it, across agents. The address isn't metadata bolted on; it's how the memory is reached — the same content-addressing the liquid database runs on, aimed at an agent's own past.
The raw notes are patches. One scrap, no structure; a thousand of them bury you. So closets compress them — reflection reads the patches and compacts them up a layer, scrap → decision → rule, the way a memory stream condenses lived detail into something worth keeping. The quilt isn't designed first. It accumulates, and the pattern is found after.
None of this needs a custom client. An agent reaches its own memory over MCP — the same open protocol the database answers on. The whole surface is five calls:
memory_retain(text, layer=L0..L3, room, hall) # write a fact at a priority tier
memory_recall(query, room, hall, max_layer) # room-scoped semantic read
memory_reflect(query) # synthesize across stored facts
memory_compress(room, hall, min_sources) # closets: fold patches up a layer
memory_bridge(src, dst, relation) # tunnels: link memories across banks
The arguments are the architecture: layer is the priority tier, room and hall are the address, compress builds the closets, bridge digs the tunnels. Any model that speaks MCP speaks to the building — no SDK, no lock, the memory layer reachable the same way the data layer is.
That's the whole tie to the liquid database. A schema that follows the world, pointed at an agent's experience, is a memory that follows what happened instead of forcing it into fields. The mempalace is the liquid database turned inward — same principle, different room. Open, MIT, under holetron.