# Your embeddings forget exactly like a human brain does

> Source: <https://dev.to/sentraai/your-embeddings-forget-exactly-like-a-human-brain-does-pd7>
> Published: 2026-09-01 07:44:16+00:00

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.

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:

``` python
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.

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:

``` php
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.

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.

Four consequences, in the order they will bite you:

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.

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](https://www.sentra.app/blog/geometry-of-forgetting). If you want the practical version, we wrote up [why embeddings alone are not memory](https://www.sentra.app/articles/embedding-models-and-ai-memory) and [what breaks when retrieval is treated as memory](https://www.sentra.app/articles/why-rag-fails).

*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.*