A semantic memory system can retrieve the perfect-looking sentence at exactly the wrong time.
The sentence feels like context. The model treats it like evidence. Suddenly an old observation is steering a new decision as if it were canon. The agent didn't decide to trust it — the retrieval pipeline shipped it into the prompt with no provenance, and the model did what models do with text that arrives in the prompt: it acted on it.
This is the partner argument to Canon is not memory. Canon is the reviewed layer. The layer underneath it is allowed to surface candidates, not declare facts. The mistake the whole post is about is letting the candidates leak across that line.
Similarity is not truth
The lived failure mode is dumb and reliable: you ask the agent about authentication patterns in the repo. The semantic store retrieves a paragraph from a six-month-old design doc that described the previous auth scheme. The paragraph is well-written. It's specific. It uses the same vocabulary the current repo uses. It's also stale, and nothing in the retrieval pipeline tells the model that.
So the model writes code against the old pattern, the tests fail, and you go figure out where the wrong context came from. By the time you trace it back, the agent has already pushed a patch that nobody asked for.
The semantic search wasn't broken. It did exactly what it was built to do: find nearby text. The mistake was treating "nearby" as "authoritative." This is the entire genre of failure that Hindsight is trying to name when it explicitly separates world facts, experience facts, observations, and mental models into distinct epistemic categories. Mash them into one bucket called "memory" and the system has no way to know that a retrieved observation is weaker evidence than a reviewed world fact.
Exact details make the same point from the other direction. Say the user tells the agent: preview servers for this repo use port 9473. Ten turns later, the conversation summary has become "discussed preview server setup" and the number is gone.
A vector search might find the old message if the query says "preview server port." It might not if the query says "what port should I curl before opening the browser?" BM25 helps because 9473 is an exact token. A reranker helps because it can push the real hit above some unrelated port-looking junk. Useful, yes. Authority, no.
The better retrieval stack is hybrid: embeddings for meaning, keyword search for rigid identifiers, reranking for relevance. But even the good version still returns candidates. The question after retrieval is not "did the database find something?" It is "what is this thing, where did it come from, how old is it, and is it allowed to steer the next action?"
Retrieval gives the agent material to inspect. Belief still needs evidence.
Memory needs a lifecycle, not just storage
The other thing semantic memory tends to skip is decay. The implicit assumption is that more memory is better memory — every observation gets stored, every retrieval is equally weighted, and the index just keeps growing. That ages badly.
Hippo's framing is the one I keep coming back to: the secret to good memory is not remembering more, it's knowing what to forget. Half-life decay on observations. Retrieval strengthens what gets used. Sleep consolidation merges related memories. Errors and failed approaches stick longer than neutral observations because the cost of forgetting them is higher (you repeat the same mistake). Conflicts get flagged instead of silently overwritten.
None of this requires Hippo specifically. The point is the primitives: decay, reinforcement, consolidation, conflict tracking. A retrieval system without these is a slow database that pretends to be cognition.
Also: not every layer should age the same way. Canon shouldn't decay — a reviewed claim doesn't get less true because nobody asked about it for a quarter. Relationship preferences age slowly. Tool traces age fast. The retrieval layer needs to know which kind of thing it's storing, or it'll either forget what should be stable or hoard what should expire.
Retrieval should carry provenance
If a memory influences an answer, the system should be able to show its work. Not as a UX nicety — as the only way to debug a wrong answer that the model is now confident about.
A useful retrieval result looks like: here is the candidate, here is the source it came from, here is when it was written, here is how often it's been retrieved, here is what it's contradicted by. The agent gets the candidate and the metadata. The model can then weight it, or punt it back as "this is from a six-month-old doc, want me to verify it's still true before acting?"
A concrete contrast:
- Good memory path: agent says "this repo prefers small modules," cites the architecture doc, a recent accepted PR, and a review comment from last month.
- Bad memory path: agent says "this repo prefers small modules," cites nothing because the claim came from an opaque embedding hit, and the engineer reviewing the PR has to go re-derive the rule from scratch to know whether it's still true.
The bad path is faster to ship. It also produces a system that nobody can audit when it's wrong.
Reflection without provenance is hallucination at rest. The same rule applies one layer up: retrieval without provenance is the system shipping its old guesses as new context, and pretending they're memory.
Where this argument doesn't reach
A few clarifications before this gets misread as an anti-retrieval post:
- Recall is genuinely useful. Humans use it the same way — surface a vaguely-relevant memory, then go check whether it still applies. The architectural mistake is letting recall be the answer instead of seeding the answer.
- Opacity is fine for the index. Opacity is not fine for the surface the agent reads from. The retrieved item needs structure even when the underlying store doesn't.
- TEMPR and similar retrieval techniques are real improvements. They don't change the governance question. A better retriever is still a retriever.
- "Semantic memory" as a term is fine; the point is precision. A lot of what gets labelled semantic memory is a mix of recall, working memory, and ungated synthesis. Naming them separately is the prerequisite for treating them differently.
Outcomes
- A vector hit is a lead, not a fact. Treat the retrieval pipeline as a candidate-generator with a confidence score, not an oracle.
- Lifecycle is the architectural contribution: decay, reinforcement, consolidation, conflict. Without these, retrieval ages into noise.
- Retrieval should carry provenance. If the agent can't tell you where a claim came from, neither can you when it goes wrong.
- The next post pulls user/role/preference state out of this same bucket because it ages differently and matters differently.