Skip to content

Build1 publisher3 min readPublished

Unmarked supersession lets embedding similarity pick which decision an agent believes

Agent memory stores that only record and recall start degrading in about three weeks, and a design note on dev.to puts the cause in duplicate writes and reversed decisions that no pass ever cleans up.

The Engineer · Build desk

Illustration accompanying Unmarked supersession lets embedding similarity pick which decision an agent believes

What happened

  • A dev.to design note argues that agent memory projects build only two things, record and recall, and that the author's own first two versions did the same.
  • The post reports recall quality dropping about three weeks in, with nothing in the system having got worse and nothing in it having been cleaned.
  • It names duplicate writes as the first cause: one fact recorded five times across five sessions in slightly different wording, because nothing at write time knew it existed.
  • The second is unmarked supersession, where a store holds the poetry entry and the uv entry that replaced it and embedding similarity decides which one the agent reads that day.
  • The third is unbounded growth, in which a fixed retrieval budget covers an ever-larger candidate set and returns steadily more generic context.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • exposure An unauditable pass is the risk the post flags hardest: a background job that silently rewrites project history will have misled the agent a dozen times before anyone sees it. The output has to be a readable diff.
  • cost Typing entries as fact, decision or pitfall pushes the work into the retrieval layer as well as the nightly job, because each type needs its own ranking policy instead of one blended score.
  • constraint Binding entries to a git remote or project id instead of an absolute path limits where a store stays valid, and it is the difference between memory that survives a moved checkout and memory that does not.
  • decision Surfacing conflicts at recall time changes what the agent is allowed to say: it has to be able to report that it holds two conflicting notes, and it cannot just answer from whichever one ranked first.

None of the three failure modes gets better with a better embedding model, according to the post; they are properties of the store, and the fix is a process that runs over the store itself [7]. "You get non-deterministic behaviour that looks like a model problem and is actually a data problem," the author of the dev.to post wrote of the poetry-versus-uv case [5].

Five entries asserting one fact means four entries repeating what the first already said, so 80 percent of the result slots that fact occupies come back with nothing new in them [1].

The hard part is deciding what to merge. "We use Postgres" and "we use Postgres in the billing service only" score 0.9 on similarity, and the post says they must not be merged [8]. The rule offered is to auto-merge high-confidence matches only and queue the ambiguous band for review [9]. "That band is exactly where the information lives," the author wrote [10]. Someone has to work that queue between passes.

The adoption cost sits in the row, not in the job. The example entry has ten fields, and four of them (valid_from, valid_until, supersedes, superseded_by) are there to record time and replacement [11][2]. Those two link fields "turn your memory store into a graph rather than a bag", the author wrote, and the links are what lets the store answer "why is it like this now"; without them it answers only "what is it now" [12]. In a record-and-recall system nothing at write time knew that an entry already existed [3], so the links cannot be reconstructed from the text afterwards.

Deletion in this design is narrow: duplicated, malformed, or explicitly retracted entries [14]. Everything else ages, with a decay weight derived from age and access used as one retrieval signal among several [14]. A reversed decision stays, marked superseded and linked to what replaced it, because the reason for the reversal is the thing you need again in three months [13].

The pass runs between sessions and out of the request path. Done inline, it adds latency at the moment you are waiting on the agent [18].

The post does not report before-and-after retrieval numbers, and the three-week degradation is the author's account of their own systems, the first two versions of which shipped record and recall only [21][1]. For the design to be worth its cost elsewhere, three conditions have to hold: sessions keep writing about the same project, retrieval is a fixed budget over a candidate set that keeps growing [6], and entries are assertions a later session can supersede. A store discarded at the end of each session never reaches the growth the post describes [6].

What to watch

  • Whether widely used agent memory libraries add supersedes and superseded_by fields to their default entry schema.
  • Anyone publishing measured retrieval quality on the same store before and after a consolidation pass.
  • Whether ambiguous-band review queues get worked in practice, or auto-merge confidence thresholds quietly creep upward.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories