AI Cannot Forget or Forgive

Tejas Sud's argument is that "forgive and forget" names two different things people treat as one. Forgetting happens to you; it's a property of the substrate. Forgiveness is something you do; it's a skill built on top. A machine has neither, and the reason is engineering, not metaphor. It cannot forget because nothing in it was built to decay, and it cannot forgive because no architecture anyone ships has an operation that does what forgiveness does.

Four places AI keeps your past

Sud separates the memory people lump together into four systems, each of which fails to fade differently.

The weights hold training data smeared across billions of parameters. Once something is in, we don't know how to get it out — machine unlearning, removing the influence of specific training data without full retraining, is unsolved at scale. You can delete the database row; you can't delete the gradient it left. This is the mechanical reason the right to be forgotten keeps colliding with machine learning: the law assumes forgetting is a delete, and the substrate has no delete.

The context window forgets like a light switch, not a dimmer. Inside the window attention treats every token as equally reachable, with no softening for age; then the session ends and everything is gone at once. Two states, eidetic or void — and humans live in the space between them, which is where most social machinery sits.

The retrieval store is the sharp part. Embeddings don't blur and cosine similarity has no time axis, so a memory from three years ago comes back at the same fidelity as one from yesterday, with no felt sense of "long ago." In vector space the whole past is co-present, one nearest-neighbor lookup away.

The logs — snapshots, replicas, backups — make even deliberate forgetting a distributed-systems problem of tombstones, retention windows, and backups that outlive the delete you thought you ran.

The forgetting neural nets do have is the wrong kind

Networks forget constantly, just badly. Catastrophic forgetting (McCloskey and Cohen, 1989) means training on a new task tends to overwrite the old one wholesale — perfect retention right up to a sudden total loss, no decay curve. And within a single context, "Lost in the Middle" (Liu et al., 2023) shows models recall facts at the start and end of a long context far better than the same fact buried in the middle. Nobody designed that dead zone; it lands wherever attention happens to be weak. So the real situation isn't a machine that remembers everything — it's one that either remembers perfectly or loses everything, with almost nothing in between. That in-between is exactly what human memory is, the thing agent-memory-decay tries to reintroduce deliberately.

Forgetting is adaptive, and reconsolidation is the missing op

Human forgetting isn't decay for its own sake. Richards and Frankland (2017), The Persistence and Transience of Memory, argue it's an active process that exists to help you generalize: a brain that kept every detail at full resolution would overfit its own past, so letting specifics fade promotes the gist to something reusable. Forgetting is compression with a purpose — the same intuition behind the Ebbinghaus curve and the half-life models in agent-memory-decay.

Underneath it is a mechanism machines lack. Recalling a memory doesn't read it, it reopens it: the memory becomes briefly labile and is re-stored, changed. Reconsolidation (Nader, Schafe, and LeDoux, 2000) makes human memory read-modify-write, so every recall is a small edit. Machine memory is read-only — retrieval returns the vector untouched no matter how many times you pull it or what you now know. This is why the emotional charge of a human memory fades on a separate track from its content: you can recall that something hurt without re-feeling it. A vector store has no way to separate those, because the record and its charge are the same immutable object. This is a different failure from the one memory-conflict-detection addresses — that's about two records disagreeing; this is about a single record that can never be re-weighted or drained.

The operation nobody built

Sud's payoff: define forgiveness precisely enough for an engineer and you get "keep the record at full fidelity, stop letting it drive behavior, while the option to let it drive behavior is still fully available." Retain, re-weight, and choose not to act on it when you easily could. Nothing in the toolbox does this. Machine unlearning is a forced delete (amnesia, not forgiveness — you destroyed the record). TTLs and decay schedules are eviction on a timer. RLHF and fine-tuning set a blanket disposition over everything at once, with no per-memory grace. The closest anyone gets is muzzling a system so it never raises the incident, which isn't forgiveness either — forgiveness only means something when resentment was genuinely available and you didn't take it. A store that behaves identically whether it remembers or not can't even express the choice.

Why the gap exists

The reason is cost. Biological memory is metabolically expensive, so brains are under constant pressure to prune, compress, and let go — scarcity is the teacher. Carrying a grievance is expensive too, so both kinds of grace evolved under a budget. Machines have no such budget: storage is effectively free, a held memory and a held grudge both cost nothing, so there's no pressure toward release ever. Sud's forward-looking claim is that if machines ever get the in-between — graceful decay, separable emotional charge, memory you can hold without being run by it — it won't come from a bigger context window or a better values document. It will come from making memory and grievance cost something. The framing echoes titit-local-ai and the broader point that current systems optimize for cheap, cacheable, reproducible inference, which is precisely what statefulness would trade away.

From the discussion

The author, replying on Hacker News, sharpened one point: graceful forgetting needs persistent, evolving state at inference, which is in direct tension with LLMs that are deliberately stateless across calls. The KV cache is ephemeral scaffolding, not a memory that ages, and trading statelessness away would cost the cacheability, parallelism, and reproducibility that make inference cheap. Cross-session "reference chat history" (ChatGPT reportedly pulls something like the last 40 conversations, weighted by recency and relevance) is the first real stab at inference-time statefulness — but it's additive, not decaying. The answer to "the model should remember you" turned out to be stuffing more of the past in at full fidelity, which is the opposite of how human memory works.