If you have built agent memory on a vector store, you have probably watched recall quietly degrade as the store grows, and assumed you needed better embeddings or a bigger index.
We spent several months measuring that decay, and the result was not what we expected: LLM memory systems forget with the same mathematics as human memory, reproducing numbers from some of the most replicated experiments in clinical psychology. No tuning required to get there.
The dimensional lie
Start with the finding everything else follows from. Take an embedding model that advertises 384 or 1,024 dimensions and measure where the variance actually lives:
import numpy as np
# X: (n_samples, n_dims) matrix of embeddings from any pretrained model
X = X - X.mean(axis=0)
eigenvalues = np.linalg.svd(X, compute_uv=False) ** 2
p = eigenvalues / eigenvalues.sum()
# participation ratio: how many dimensions are doing real work
effective_dims = 1.0 / np.sum(p ** 2)
print(f"nominal: {X.shape[1]}, effective: {effective_dims:.1f}")
Run that on a model advertising 384 to 1,024 dimensions and you get an effective dimensionality around 16. Learned representations concentrate their variance into roughly 3 to 10% of their nominal dimensions.
That is not a defect of one model. It is a property of learned representations, and it is why compression works at all. It is also why memory built on those representations behaves like a crowded room rather than a filing cabinet: with 16 effective dimensions, every new memory lands close to existing ones, and closeness is interference.
Forgetting is competition, not decay
The Ebbinghaus forgetting curve is usually taught as memory fading over time. Our measurements say the mechanism is different: memories compete, and competition looks like decay.
The test is simple. Measure the forgetting exponent normally, then remove the competing memories and measure again:
with competitors present -> power-law forgetting, exponent ~ human curve
competitors removed -> exponent drops ~50x
Fifty-fold. Time barely matters; neighbours matter enormously. Which means the practical lever on agent memory recall is not retention windows or TTLs, it is reducing how many near-identical items compete for the same region of embedding space.
If your retrieval quality fell off a cliff after you tripled the corpus, this is why. You did not lose information, you added competitors.
False memories, for free
The part that genuinely surprised us. The classic false-memory experiment (a lure word that was never presented gets "recalled" because it is semantically central to the list) reproduces on raw cosine similarity over unmodified pre-trained embeddings:
| Measurement | Rate |
|---|---|
| Human false-memory rate, classic studies | ~0.55 |
| Raw cosine similarity, no tuning | 0.583 |
Zero parameter fitting. Nobody engineered this. Semantic similarity alone manufactures confident recollections of things that were never stored, at approximately the human rate.
Read that back as an engineering statement: a vector store will hand your agent a plausible fact that was never written down, and it will look exactly like a real retrieval. No confidence score distinguishes them, because from the geometry's point of view there is nothing to distinguish.
What this means if you are building agent memory
Four consequences, in the order they will bite you:
- Similarity is not truth. Nearest-neighbour search returns what is close, and closeness is a proxy for relevance that degrades as the corpus grows. It was never a proxy for correctness.
- Scaling the index makes recall worse, not better. More documents means more competitors in a 16-dimensional space. This is the opposite of the intuition that a bigger memory is a better memory.
- Recency heuristics are patches, not fixes. Sorting by timestamp helps because it breaks ties, not because the system understands that something was superseded.
- You cannot fix this with a better embedding model. The concentration of variance is a property of learned representations generally. A model with more nominal dimensions still concentrates them.
The architectural conclusion we drew, and the reason we build what we build: if similarity cannot tell you what is true, the system has to record truth explicitly, at write time, with structure that geometry does not provide.
{
"statement": "Acme's latency fix slipped to Q3",
"valid_from": "2026-04-03",
"valid_to": null,
"supersedes": "fact_8812",
"source": "meeting:2026-04-03#turn-58",
"visible_to": ["role:account-team"]
}
Three fields there do work that no embedding can do. valid_from and valid_to make time explicit rather than inferred. supersedes records that a previous belief was replaced, so the old one can be retired instead of competing forever. source makes the claim checkable.
None of that is a better vector. It is a different data model, and it exists precisely because the geometry has the failure modes above.
Try it on your own store
The participation-ratio snippet above runs on any embedding matrix in about three lines. If your effective dimensionality comes back in the teens while you are paying for 1,024, you now know why your recall curve looks like a psychology textbook.
Full methodology, the compression results behind the 3 to 10% figure, and the rest of the experiments are in the original writeup. If you want the practical version, we wrote up why embeddings alone are not memory and what breaks when retrieval is treated as memory.
This research came out of building Sentra, a company brain for teams and AI agents. We went looking for a compression result and found a psychology paper instead.
Top comments (0)