The Problem

The Problem

Most RAG systems answer a human's question over a document corpus. RE-call targets a different setting: a long-running agent retrieving over memory it wrote itself.

That difference is not cosmetic. It changes which failures matter, and it changes what a good answer looks like.

Why an agent's own memory is different

A document corpus is mostly additive and stable. A technical manual does not contradict itself; when it is revised, the old edition is withdrawn.

An agent's memory is neither. It accumulates decisions that get reversed, hypotheses that get falsified, incidents that get resolved, and thresholds that get re-tuned. Nothing withdraws the old entry — it is still there, still well-written, still on-topic. And critically:

The memory recording a decision and the memory reversing it are about the same subject, so they are near-neighbours in embedding space. Whichever one happens to be phrased closer to the query wins. That is frequently the stale one.

This is not a ranking bug that a better embedder fixes. Similarity is answering the question it was asked — which memory looks most like the query — correctly. The question that needs answering is a different one: should this memory still be believed. No amount of similarity computes that, because the evidence for it is not in the text.

The three failure modes

1. Re-litigation

The agent re-proposes an idea it already tried and rejected, because nothing surfaced the prior decision at the moment of proposing. The cost is not just wasted work — it is silent drift away from conclusions that were reached properly the first time, with no record that the drift happened.

The guard is architectural rather than algorithmic: the agent must consult memory before it acts, and a surfaced closed decision must be able to stop it. See examples/self_recall_agent.py for the pattern in about thirty lines.

2. Confidently building on a memory that is no longer true

The failure this project is named for. A decision is reversed; the memo recording the original decision remains the closest match; retrieval serves it; the agent proceeds on a constraint that no longer exists.

The fix cannot be inferred from the documents, because both look valid in isolation. Supersession is a relation between two memories, and a relation has to be captured by someone who knows it holds — the author of the replacement, at write time. RE-call reads that relation out of frontmatter and acts on it at retrieval time. See The-Trust-Layer.

The obvious alternative — trust the newest relevant hit — was tested rather than assumed, and steelmanned before being rejected. It does not work, for a reason that survives every variant: recency and authority are different properties, and a memo can be newer than the memory it contradicts without being the one that replaced it. → Evidence-Map

3. Hallucinating over a gap

The memory genuinely has no answer, retrieval returns its best five anyway, and the agent treats them as evidence. Every retrieval system has a top-k; almost none have a way to say the top-k is worthless.

RE-call's answer is an explicit abstention with a stated reason, driven by a threshold that is calibrated per embedder rather than fixed — because a fixed cosine threshold demonstrably does not transfer between embedding models, each of which places its scores in a different regime. → The-Trust-Layer

Abstention has a second, harder class inside it: the near-miss — a memory semantically adjacent to the query that does not answer it. Its similarity clears any threshold by construction, so no threshold can catch it. That needs a separate judgment about entailment, which ships as an opt-in stage.

What this implies about the design

Three properties follow from the above, and most of the codebase is downstream of them:

• Every hit must carry a judgment, not just a score. A caller that receives ranked text has no way to distinguish "this is current" from "this was true in March". So the return type is a hit plus a verdict, a calibrated confidence, its provenance, and its validity window.

• The system must be able to return nothing. An engine that always answers is an engine that is confidently wrong on every unanswerable question. Abstention is a first-class outcome, not an error.

• Validity is authored, never guessed. Where the system cannot know, it says so rather than inferring — including when a supersession edge is ambiguous, where it fails closed instead of picking a plausible target. The tooling that tries to recover undeclared edges after the fact ships explicitly as a reviewing aid, because measurement showed it could safely declare none of them on its own.

---

Next: The-Trust-Layer for how the judgment is made · Architecture for where each piece lives · Evidence-Map for what was measured and what was withdrawn.

Longer-form narrative of the same problem, with the design story: docs/WRITEUP.md. Where the corpus came from: docs/CASE_STUDY.md.