Embedding-based agent memory forgets like human memory, Sentra measurements claim

Months of internal measurements by Sentra, published as a post on dev.to, arrive at an uncomfortable conclusion for anyone building LLM agent memory on a vector store: the recall degradation you see as the store grows is not an embedding-quality problem. It behaves, the company claims, according to the same mathematics that governs human forgetting, including false memories at roughly the rate reported in classic psychology experiments, and the match appears without any tuning.

A few dimensions do the work

The starting measurement is a participation-ratio calculation: centre an embedding matrix, take the singular values, and count how many dimensions actually carry the variance. On pretrained models advertising 384 or 1,024 dimensions, Sentra says the effective count lands around 16, with learned representations concentrating variance into roughly 3 to 10 percent of their nominal dimensions.

The company frames this as a general property of learned representations, and the flip side of why compression works at all, rather than a flaw in any single model. The practical effect is that a supposedly high-dimensional index behaves like a small one: every new memory is deposited near existing memories, and that proximity turns into interference.

Interference, not time

The usual account of the Ebbinghaus forgetting curve is that memories fade with time. Sentra's measurements point elsewhere. With competing memories present, forgetting followed a power law with an exponent close to the human curve; when competitors were removed, the exponent dropped roughly fifty-fold. On that reading, time barely matters and neighbours dominate.

If that holds, it moves the lever. Retention windows and TTLs do little; what matters is reducing how many near-identical items contend for the same region of embedding space. It also explains a pattern many teams will recognise from practice: retrieval quality falling off a cliff after the corpus triples, not because information was lost but because competitors were added.

False recall without engineering

The most striking claim concerns false memories. In the classic lure-word experiment from psychology, a word that was never shown gets 'remembered' because it sits at the semantic centre of a studied list. Sentra reports that raw cosine similarity over unmodified pretrained embeddings produces this effect at a rate of 0.583, against roughly 0.55 in the classic human studies, with no parameters fitted.

Translated into engineering terms: a vector store can hand an agent a plausible fact that was never written down, and it looks exactly like a legitimate retrieval. No confidence score separates the two, because from the geometry's point of view there is nothing to separate.

What to change

The post draws four conclusions, in the order it expects them to bite. Nearest-neighbour similarity was never a proxy for correctness, only a relevance proxy that weakens as the corpus grows. A larger index makes recall worse rather than better, since it adds competitors to an effectively low-dimensional space. Recency sorting helps only by breaking ties, not by encoding that a fact was superseded. And swapping in a better embedding model will not fix it, because variance concentration is common to learned representations generally.

Sentra's architectural answer is to stop asking geometry to carry truth. Facts get explicit structure at write time: validity windows so time is recorded rather than inferred, a supersedes pointer so an outdated belief can be retired instead of competing forever, and a source reference that makes the claim checkable.

One caveat deserves weight. The measurements are self-published by a company building a product in exactly this space, described in the post as a company brain for teams and AI agents, and the full methodology sits in a separate writeup rather than the post itself. The numbers should be read as one team's internal results awaiting independent confirmation. The participation-ratio check, however, is a few lines of NumPy and runs on any embedding matrix, so the central claim is cheap to test against your own store.

Why it matters

If the interference account is right, a large share of current agent-memory engineering, from bigger indexes to fancier embeddings to timestamp tie-breakers, treats symptoms rather than the mechanism. The proposed remedies, such as competitor reduction and explicit temporal validity plus supersession metadata, are testable without new infrastructure. The post also sharpens a distinction the industry keeps blurring: retrieval finds what is similar, but similarity was never memory, and it was never truth.