Why vector databases forget

A vector database is a brilliant way to find things that are similar. It is a terrible way to decide what is true. For an agent that has to remember a person across months of conversation, that distinction is the whole game.

Similarity has no opinion about contradiction

Picture a simple sequence. On Monday a user tells your assistant, “make the accent color red.” On Thursday they change their mind: “actually, make it blue.” Two sentences, both about the same preference, and only one of them is now true.

Drop both into a vector store and you have stored two embeddings that are nearly identical— they sit a hair apart in the same neighborhood. At query time, “what accent color does the user want?” pulls back both, ranked by cosine similarity. Your agent is now holding two contradictory facts with no way to know which one wins.

You can patch around it. Add timestamps and prefer the newest. Add metadata filters. Write a reranker that tries to detect superseded facts. Each patch is a small reimplementation of something a database should give you natively: a notion of identity and update.

Memory is a graph, not a bag of vectors

The fix is to stop treating a memory as a free-floating string and start treating it as a typed node with identity. A preference is an entity. When new information arrives about that entity, the question isn’t “is this similar to something?” — it’s “does this create a new memory, or updatean existing one?”

In Memuron, every write passes through the Guardian — an async pipeline that retrieves the candidate memories a new fact might touch, then asks an LLM to make exactly that decision. Create, update, or link.

{
  "action": "update",
  "target": "mem_8f21c",
  "reason": "supersedes prior accent preference",
  "before": "prefers accent color red",
  "after": "prefers accent color blue"
}

The result is a single, coherent memory — not two competing rows. The old value isn’t silently overwritten either; because the store underneath is append-only, the update is a new event in a ledger. You keep the full history for audit and replay, while reads always project the current truth.

What you get when truth is first-class

Once memories have identity, a lot of hard things become easy. Recall stays consistent across sessions because there is one canonical answer per fact. Conflicting updates resolve instead of accumulating. And because nodes can link, retrieval can traverse from a fact to its source document instead of returning a flat list of nearest neighbors.

Vectors are still in the loop — Memuron blends semantic and keyword signals with reciprocal rank fusion for retrieval. But similarity is a search tool, not a storage model. The moment you ask software to remember a person, you need something that can change its mind.