Six well-established mechanisms decide when data may be discarded. They look unrelated and they are the same rule.

Every one works by fixing the set of future observers or future queries — a root set, a membership, a watermark, a signature. When that set is closed, discard is decidable. When it is open, discard is a heuristic wearing a configuration knob.

An agent memory has an open query set by construction. That is what it is for. So "when may an agent forget" is not decidable by any of these means, and the conclusion is not therefore never forget. It is that forgetting must be a declared policy with a named decider, which is exactly what Cassandra's gc_grace_seconds, Kafka's delete.retention.ms, and the streaming model's allowed lateness each are: a window during which readers are protected, after which the system is permitted to discard. Three different systems, one knob, always with an owner.

A ranking weight declares nothing and names no one.

Lin and Reiter (Lin and Reiter 1994) establish that forgetting a predicate yields the strongest consequence of the theory in the reduced signature, and that this residue is always expressible as an existential second-order sentence but not always first-order expressible. Forgetting genuinely loses expressive power. It is irreversible by definition.

A half-life is reversible. Set it to zero and everything returns, unchanged, because nothing left. Whatever properties forgetting is supposed to buy — bounded cost, generalization, an answer to an erasure request — a reversible weight buys none of them. It is deprioritized retention, which is a real thing and a different thing.

The distinction already has a name in an operational system. Accumulo's AgeOffFilter is configured per scope: at scan scope the data is filtered from results but remains in the files; at minor and major compaction scope the rewritten files omit it and the space is reclaimed. Accumulo treats these as distinct states and gives them different names. Ranking decay is scan-scope age off with the compaction scope never configured.

The strongest defence of decay-as-weight is that it is a good model of human memory, and it is. Bjork and Bjork's New Theory of Disuse (Bjork and Bjork 1992) separates storage strength, which does not decrease, from retrieval strength, which decays with disuse. Anderson and Schooler (Anderson and Schooler 1991) show the forgetting curve mirrors the environmental need-odds — the probability an item will be required, given the frequency and recency of past use — and operationalize it as an activation equation.

An append-only store with a decay weight is literally this: retrieval strength falling while storage strength is pinned at maximum. On its own chosen ground the design is defensible.

Two things travel with the theory, and neither was taken.

In Bjork and Bjork, loss of retrieval strength is not the end state. It is the input to consolidation: effortful retrieval of a weakened trace is what increases storage strength, which is why the whole account is usually taught alongside desirable difficulties. A system with no consolidation step has copied the decay and dropped the payoff.

And the activation account pairs its equation with a retrieval threshold — a hard cutoff below which an item is simply not retrieved. That threshold is what bounds cost. Take the curve, omit the threshold, and the candidate set grows without limit while the ranker fights a worsening signal-to-noise problem.

The biological literature is stronger still: transience is actively regulated, not passive fade, and the persistence-transience interaction is what supports generalization in non-stationary environments (Richards and Frankland 2017). Forgetting is a mechanism with machinery, not the absence of one.

Verified directly for this note, 2026-09-04.

Datomic is the reference implementation of accretion-only storage. It ships :db/excise as a deliberate escape hatch, and the documentation frames it for privacy and retention liability rather than error correction, with real limits: schema and bootstrap datoms cannot be excised, :db/fulltext is unsupported, full removal is not guaranteed for :db/noHistory attributes, and the effect is asynchronous, landing in the first indexing job after the transaction (“Excision –- Datomic Documentation,” n.d.).

Datomic Cloud ships no excision at all. The vendor forum states it is not available and that options are still being evaluated; the recommended path is encryption with key destruction, or keeping personal data outside Datomic entirely. The flagship immutable database built an erasure primitive reluctantly, and then shipped a product tier without one.

The second datapoint is what the accounting metaphor actually says. "Accountants don't use erasers" is the standard defence of append-only, and it is true: a correction is a new entry. But accountants also close the books — periodically, at a declared boundary, into a balance, with the detail archived. That is a sanctioned forgetting protocol with an owner and a schedule, and it is the half of the metaphor that gets left out.

Modelling in two time axes (Kulkarni and Michels 2012) separates valid time, when a fact held in the world, from transaction time, when the system believed it. The asymmetry is the point: valid time is correctable, transaction time is append-only by definition, because a mutable transaction axis destroys the audit. A store with one time axis cannot distinguish I was wrong then from the world changed, and a decay weight collapses both into old.

The compliance consequence is worse than it first looks. The machine-unlearning literature establishes that deleting a source record does not delete its influence on derived artifacts. An agent memory that embeds, summarizes, and consolidates is a derivative-generating machine. "We do not delete" is therefore not a policy; it is a liability that grows in proportion to how much useful abstraction the system has performed.

Eviction is forgetting with a budget, and it is the oldest place the question was made rigorous.

The invariant is the inclusion property (Mattson et al. 1970): for a stack algorithm, the contents of a smaller cache are always a subset of a larger one. Two consequences follow, and the second is the interesting one. Miss ratio becomes a monotone function of cache size — a claim a test can falsify. And because the ordering is a total order over a single stack, one pass over a trace yields the miss ratio for every cache size at once. The invariant is not decoration; it is what makes exhaustive evaluation affordable.

The oracle is Belady's MIN (Belady 1966), which evicts whatever is next needed furthest in the future. It cannot be implemented, because it requires the future, and that is the point: it fixes the best attainable number on a given trace, so any policy can be scored as a ratio against it. The field measures ignorance of the future directly, as a gap.

So cache replacement has both halves. A structural property that makes testing cheap, and a bound that makes a score mean something.

Cormode and colleagues draw a distinction that lands directly on the design under discussion (Cormode et al. 2009). The usual formulation of time decay is backward: an item's weight is a function of its age, measured back from now. Their objection is practical — age changes continuously, so every stored weight changes at every instant, which they call too unwieldy for scalable implementation. Their alternative is forward decay, measured forward from a fixed landmark, which subsumes exponential decay and landmark windows while keeping the stored value stable.

The testing consequence is not stated in the paper and is worth naming. Under backward decay no expected value is stable, so there is no assertion a regression test can make: run the same query twice and the correct answer has changed, without any input changing. Under forward decay the stored quantity is fixed at write time and the decay is applied at read, so a test can pin an expected number.

A half-life over an item's age is backward decay by this taxonomy. It is the formulation the streaming literature moved away from, and the reason it gave is that you cannot build reliably on a quantity that is different every time you look at it.

This is the one field where a memory-decay model is empirically scored at scale. The open spaced-repetition benchmark (“Benchmark of Spaced Repetition Algorithms,” n.d.) evaluates scheduling algorithms over 9,999 collections and roughly 350 million reviews, on log loss and a binned RMSE, against open datasets anyone can re-run.

What is being tested is a prediction: given this item's history, what is the probability the person recalls it now? That is falsifiable per review, which is what makes the benchmark possible at all. The model carries state — stability and difficulty per item — and the metric asks whether that state predicted behaviour, not whether the ranking looked reasonable.

The contrast is exact. An agent memory's decay weight makes no prediction about anything observable, so there is nothing to score it against. It is a preference expressed as arithmetic.

Since the corpus's memory work is organised around it, it is worth saying what JITIR does not supply here. Rhodes' contribution (Rhodes 2000) is proactive retrieval on local context at low interruption cost, evaluated through user studies — and the finding is about utility versus relevance, that people retrieve and use more information than they otherwise would, not that a decay function was correct.

That is a genuine result about a different question. There is no decay model under test, no invariant asserted, and no oracle. Anyone reaching for JITIR as prior art for forgetting will find proactivity instead.

Every field that takes decay seriously has at least one of the two, and the strongest has both. The invariant is what makes testing cheap enough to do exhaustively; the oracle is what stops a green result from being an opinion.

Agent memory has neither, and the two absences are the same absence viewed twice. Without a structural property there is nothing to check but examples; without a prediction there is nothing an example can be wrong about. That is why "decay is implemented as a ranking weight" reads as a design note rather than a claim: no experiment could contradict it.

The cheapest thing to borrow is the first row. Monotonicity is a property that costs almost nothing to state and immediately falsifies a whole class of mistakes — and it took the storage-hierarchy people one paper in 1970 to notice that stating it also made the evaluation tractable.

The W3C provenance data model (“Prov-Dm: The Prov Data Model” 2013) is a Recommendation, and its central relation is wasAttributedTo(id; e, ag) — binding a thing to a responsible agent. Both the entity and the agent argument are mandatory. The minimal conformant claim record is four things: an identifier, an attributed agent, a generating activity with a time, and what it was derived from.

A schema carrying content and a timestamp satisfies a degenerate wasGeneratedBy and nothing else. It cannot instantiate the model's central relation, because it has nowhere to put the agent.

The history sharpens this. The Open Provenance Model (Moreau and others 2011) had the same hole: its only agent edge is wasControlledBy, whose target is a process, so OPM core could not attribute an artifact to an agent at all. Attribution arrived later as a profile. PROV promoting wasAttributedTo to core is the provenance community having already found and fixed exactly this gap, in

Note also where PROV puts time. On generation, never on attribution. Recency is a property of the act. It was never a substitute for the actor.

Given two contradictory claims, an append-only store with decay surfaces whichever the ranker prefers, inside a top-k cut. That is a choice, and belief revision already names it.

AGM (Alchourrón, Gärdenfors, and Makinson 1985) defines contraction as selecting among maximal subsets that do not entail the retracted sentence. Recency ranking is a contraction operator whose selection function is a timestamp comparison. Two facts about that are worth stating plainly: AGM is explicitly single-agent — no agent index appears in the postulates — so applying it across two people is a category error rather than a tuning choice; and its response to a contradiction is to give one side up, which is precisely the behaviour append-only storage was supposed to avoid.

Distributed systems reached the same conclusion forty years ago and built the alternative. Version vectors (Parker and others 1983) detect mutual inconsistency at read rather than silently picking. Dynamo (DeCandia and others 2007) returns causally concurrent siblings and defers reconciliation to the layer that knows what the values mean, on the grounds that the storage layer does not. A multi-value register and a last-write-wins register are the same data type with different merge functions; the store already chose, and chose the lossy one.

Most of the belief literature gives vocabulary rather than machinery. Epistemic logic can express that A knows X while B knows not-X, and offers nothing to build. Belief merging takes attributed inputs and returns one consistent base, discarding the attribution in the process. Argumentation frameworks deliberately abstract away everything about an argument including who advanced it.

The assumption-based truth maintenance system (de Kleer 1986) is the exception. Make "A asserted it" and "B asserted it" assumptions; reify the two claims as separate nodes; assert the contradiction. Each node's label is then the set of minimal consistent environments supporting it — which is to say, its contributor set — and the conflicting pair is recorded as a nogood. Both claims persist. Nothing is retracted. The contradiction is local, and every downstream derivation inherits the attribution automatically.

Three caveats, so this is not oversold. Contexts are consistent by construction, so both claims are retained globally rather than believed jointly. Attribution is not an ATMS primitive; it is what you get when the modeller makes the assertion an assumption, after which the machinery carries it faithfully. And there is no negation — the contradiction must be asserted by hand.

The obvious fix is an author column plus signatures. That is a real improvement and it stops short of the property people assume it delivers.

A transparency log gives inclusion proofs and consistency proofs: any entry's membership is provable against a published head, and today's tree provably contains yesterday's as a prefix. Both are cheap and cryptographic. The distinguishing property is non-equivocation — that the log does not show different views to different clients — and RFC 9162 concedes in its own security considerations that the auditing mechanisms can be circumvented by a log presenting inconsistent views (Laurie, Messeri, and Stradling 2021). The proposed remedy, gossip between clients, expired as an Internet-Draft in 2018 and never became an RFC. Non-equivocation is a deployment assumption, not a cryptographic guarantee.

The concrete anchor is git. Signed commits give per-write attribution and integrity, and a malicious server can still present inconsistent repository states to different developers (Torres-Arias et al. 2016). So a memory store with unserialized cross-machine writes is already in a split-view condition by construction, and adding signatures buys git's guarantee: real, and not sufficient.

The audit for any proposed fix is four questions. Can a third party prove inclusion? Is consistency across time provable? Is there a gossip channel? Is anyone actually monitoring? Systems that stop at the first get integrity, not transparency.

Two 2026 papers name this failure mode directly, and using the field's vocabulary is cheaper than minting one: asynchronous provenance reuse for the write-time/read-time decoupling that makes shared memory a distinct problem from retrieval augmentation, and provenance collapse for the loss of writer identity itself. The second comes from work that reconstructs derivation chains with correct writer identity in production, which makes it an existence proof rather than a proposal.

The structural diagnosis is older. A shared store with no per-chunk attribution reproduces the confused deputy (Hardy 1988): retrieved text inherits the reader's privileges rather than the writer's, because the deputy holds authority without knowing why it has it. Hardy's remedy — bind authority to the designation rather than the deputy — is the argument for per-chunk provenance, made in 1988.