Designed Forgetting in Computational Systems

• Designed forgetting is a deliberate process that integrates controlled information removal in computational systems to enhance generalization, adaptability, and privacy.
• It employs mechanisms such as decay, deletion, masking, and architectural modifications to balance selective information suppression with retained utility.
• Empirical evaluations demonstrate that selective forgetting can reduce storage overhead and mitigate risks like catastrophic forgetting while preserving performance.

Designed forgetting is the intentional incorporation of forgetting into computational systems as a controlled capability rather than an accident of optimization or storage failure. In recent work, the term spans several levels of abstraction: a sociotechnical umbrella over erasure, unlearning, and exclusion in data systems; selective attenuation or deletion in neural parameters and external memories; context-conditioned suppression of outputs at inference time; and architectural designs in which forgetting is supported directly by the model or memory substrate (Makovska et al., 24 Feb 2026, Sha et al., 2024, Laguna et al., 16 Mar 2026, Takashiro et al., 2024). Across these strands, the shared objective is to remove, bound, or de-emphasize information in ways that preserve utility, adaptability, privacy, or safety while avoiding uncontrolled catastrophic forgetting.

1. Definitions, scope, and conceptual boundaries

Designed forgetting is distinguished from both unintentional forgetting and catastrophic forgetting. The survey literature defines unintentional forgetting as incidental information loss, and catastrophic forgetting as the abrupt loss of previously learned tasks during sequential training, whereas designed forgetting is an intentional model component or procedure that removes or down-weights specific information by design and is intended to improve generalisation, adaptability, or privacy (Sha et al., 2024). In data-systems terms, Makovska et al. further argue that forgetting cannot be reduced to a single operation and should instead be treated as a sociotechnical practice differentiated by agency, temporality, reversibility, and scale (Makovska et al., 24 Feb 2026).

Within that taxonomy, erasure is the operational removal or disabling of access to data artifacts such as rows, files, indexes, caches, or logs; unlearning is a technical intervention designed to remove or bound a data point’s influence on model parameters or downstream outputs; and exclusion is upstream non-collection or omission, described as a form of forgetting by design (Makovska et al., 24 Feb 2026). This distinction is foundational because record deletion does not by itself alter learned weights, feature transformations, or predictive behavior.

Several subfields instantiate the same general idea with domain-specific emphases. In generative LLMs, graceful forgetting aims to enhance learning plasticity by selectively discarding irrelevant pre-trained knowledge that would otherwise induce negative transfer (Jiang et al., 26 May 2025). In multimodal unlearning, “benign memory forgetting” denotes targeted erasure of private knowledge while preserving general visual understanding and unrelated memory (Zeng et al., 25 Nov 2025). In LLM agents, designed forgetting is defined as intentional, policy-driven removal or de-emphasis of stored memories according to value, recency, safety, and usage feedback (Gu et al., 22 Apr 2026). In memory-augmented vision models, “unlearning by design” means that forgetting is an intrinsic architectural operation rather than a post-hoc patch (Laguna et al., 16 Mar 2026).

A recurring implication is that designed forgetting is not a single algorithmic family. It is a design objective that can be realized through decay, deletion, masking, bottlenecking, retrieval gating, adversarial balancing, or governance procedures, depending on whether the system is a database, a classifier, a generative model, a robot, or an agent memory.

2. Mechanistic taxonomy

The contemporary literature organizes designed forgetting into several recurring mechanisms. The survey literature groups forgetting methods into regularization-based, data-driven (unlearning), and architectural families, while agent-memory work refines this into passive decay-based, active deletion-based, safety-triggered, and adaptive reinforcement-based forgetting (Sha et al., 2024, Gu et al., 22 Apr 2026).

Mechanism	Operation	Representative papers
Erasure and exclusion	Remove artifacts or omit collection	(Makovska et al., 24 Feb 2026)
Parameter-space unlearning	Update weights to suppress influence	(Jiang et al., 26 May 2025, Hatua et al., 2024)
Architectural unlearning by design	Detach instance memory from core weights	(Laguna et al., 16 Mar 2026)
Representation-space forgetting	Transform latent features under an information bottleneck	(Almudévar et al., 29 Jan 2026)
External-memory decay and pruning	Decay, delete, fuse, or gate stored memories	(Wei et al., 26 Jan 2026, Gu et al., 22 Apr 2026, Bärmann et al., 13 Apr 2026, Shin et al., 10 Jul 2026)
Context-conditioned suppression	Trigger forgetting from prompt context at inference time	(Takashiro et al., 2024)
Selective adapter masking	Constrain forgetting to targeted memory regions	(Zeng et al., 25 Nov 2025)

Decay-based mechanisms are the most explicit descendants of cognitive models. FSFM adopts Ebbinghaus-style exponential retention, $\mathrm{Retention}(t)=e^{-\lambda t}$, and extends it to memory-specific decay rates $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$ (Gu et al., 22 Apr 2026). FadeMem generalizes this with a dual-layer memory hierarchy in which short-term and long-term stores use different exponents $\beta_i$, adaptive decay rates $\lambda_i(t)$, and reinforcement upon access (Wei et al., 26 Jan 2026). Shin et al. implement a memory operating system with $M(t)=S\exp(-\lambda t)$ and retrieval gating by threshold, thereby producing a “skeleton–wallpaper” partition in which enduring traces persist and surface detail decays (Shin et al., 10 Jul 2026).

Deletion-based mechanisms are more discrete. H$^2$-EMV assigns each episodic-memory node an expiration time $\tau_n$, extends that lifetime by an LLM-estimated relevance factor $\alpha_n$, and deletes the node if it remains expired after extension (Bärmann et al., 13 Apr 2026). MUNKEY stores instance-specific memorization in an external memory bank $M=\{(k_i,v_i)\}_{i=1}^N$ and unlearns by simple set difference, $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$, avoiding weight updates altogether (Laguna et al., 16 Mar 2026).

Other mechanisms are selective rather than global. LWF ranks self-generated forgetting examples by a Fisher-weighted forgetting-confidence score and periodically unlearns only the top-scoring fraction during fine-tuning (Jiang et al., 26 May 2025). SMFA first isolates a Memory Forgetting Adapter and then masks only those forgetting updates that conflict with a retaining anchor and dominate in magnitude, so that unrelated visual understanding is preserved (Zeng et al., 25 Nov 2025). Representation Unlearning fixes the encoder and learns a low-dimensional transform $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$0 that maximizes mutual information with retained data while suppressing information about forgotten data (Almudévar et al., 29 Jan 2026).

3. Mathematical formulations

A central formal distinction in the literature is between deleting artifacts and deleting influence. Makovska et al. state the standard criterion for approximate unlearning as

$$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$1

or, in probabilistic models,

$$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$2

where $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$3 is the output of an unlearning procedure and $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$4 is the retrain-from-scratch reference (Makovska et al., 24 Feb 2026). This formalism makes explicit that credible forgetting is relative to a gold-standard model that never saw the removed datum.

Fisher-based approaches model forgetting as targeted deviation from a downstream optimum. In LWF, the diagonal Fisher Information Matrix on the learning task,

$$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$5

weights parameter importance, and the forgetting-confidence score for a self-generated example $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$6 is

$$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$7

Examples with high $$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$8 are treated as stronger candidates for unlearning because their one-step update moves parameters farther from the learning-task optimum (Jiang et al., 26 May 2025).

Memory-decay systems instead formalize forgetting in time. H$$\mathrm{Retention}_i(t)=e^{-\lambda_i t}\times g(\mathrm{frequency},\mathrm{relevance},\dots)$$9-EMV sets initial expiration as

$\beta_i$0

queries an LLM for a relevance multiplier $\beta_i$1, then extends $\beta_i$2 and deletes the node if it remains expired (Bärmann et al., 13 Apr 2026). FadeMem uses

$\beta_i$3

with $\beta_i$4 for long-term memory and $\beta_i$5 for short-term memory, while importance

$\beta_i$6

governs promotion and demotion across layers (Wei et al., 26 Jan 2026). Tran et al. cast in-context inference itself as a discounted Bayesian update,

$\beta_i$7

with exponential weights $\beta_i$8, thereby interpreting forgetting as a functional memory process rather than a defect (Tran et al., 28 Dec 2025).

Architectural unlearning introduces yet another formal pattern: move instance-specific information out of the core parameters. In MUNKEY, the memory bank $\beta_i$9 stores frozen keys $\lambda_i(t)$0 and learnable exemplar tokens $\lambda_i(t)$1; forgetting is exactly the removal of the corresponding key–value entry (Laguna et al., 16 Mar 2026). Representation Unlearning replaces weight modification with the objective

$\lambda_i(t)$2

implemented by learning a transformation $\lambda_i(t)$3 in latent space while keeping the backbone encoder fixed (Almudévar et al., 29 Jan 2026). These formulations differ operationally, but each makes forgetting an explicit design variable.

4. System architectures and algorithmic recipes

In generative language modeling, LWF is a fine-tuning framework built around self-knowledge elicitation, Fisher scoring, and periodic unlearning. The procedure is: fine-tune the base model on learning data to obtain $\lambda_i(t)$4; compute diagonal Fisher on the learning data; generate self-knowledge from forgetting-task prompts; compute $\lambda_i(t)$5 for each generated example; sort by descending $\lambda_i(t)$6; select the top $\lambda_i(t)$7; and interleave ordinary fine-tuning batches with periodic gradient-ascent unlearning on one selected example every $\lambda_i(t)$8 steps (Jiang et al., 26 May 2025). The framework is notable because it avoids architecture-incompatible unlearning machinery and uses only reversed-sign loss for the unlearning step.

In robotic episodic memory, H$\lambda_i(t)$9-EMV organizes experience into a rooted tree $M(t)=S\exp(-\lambda t)$0 with scene graphs at level 1, event summaries at level 2, goal summaries at level 3, and recursive LLM-driven summaries above that. Each node stores a natural-language summary, child pointers, a parent pointer, and a time span. Designed forgetting operates top-down over this hierarchy: when a node expires, an LLM estimates relevance conditioned on current natural-language rules $M(t)=S\exp(-\lambda t)$1; the node’s lifetime is extended or the node is replaced by a “forgotten” placeholder; and user feedback that reveals missing details is converted into revised forgetting rules $M(t)=S\exp(-\lambda t)$2 by another LLM prompt (Bärmann et al., 13 Apr 2026).

Agent-memory systems broaden the design space. FSFM specifies an UltraSafeMemoryManager over a vector store with an ImportanceScoringEngine and a SelectiveForgettingMechanism; memories are scored by content quality, business value, temporal recency, and safety penalty, then subjected to passive decay, active deletion, safety-triggered removal, and capacity pruning (Gu et al., 22 Apr 2026). FadeMem instead combines continuous decay with LLM-guided conflict resolution and memory fusion: similar memories are classified as compatible, contradictory, subsumes, or subsumed; contradictory older memories are suppressed by temporal competitive decay; and clusters of related memories are merged into a single fused memory if factual preservation exceeds a threshold (Wei et al., 26 Jan 2026). Shin et al. place similar retention logic in a Lifelong Selective Memory operating system on top of a hyperbolic base model, where each trace is assigned learned salience $M(t)=S\exp(-\lambda t)$3 and decay rate $M(t)=S\exp(-\lambda t)$4, and recurrently retrieved traces are periodically consolidated more deeply in the manifold (Shin et al., 10 Jul 2026).

In designed-forget architectures for classifiers and multimodal models, forgetting is localized structurally. Forgetting Neural Networks insert forgetting layers whose per-neuron attenuation factors $M(t)=S\exp(-\lambda t)$5 scale activations during the unlearning phase; the paper studies rank forget rate, ordered forget rate, top-30 forget rate, and random forget rate (Hatua et al., 2024). MUNKEY couples a ViT-Tiny backbone to an external memory bank of fixed keys and learnable exemplar tokens, trains with stochastic pathway dropout so the model cannot ignore either the image or token pathway, and thereby supports direct zero-shot forgetting through key deletion (Laguna et al., 16 Mar 2026). SMFA confines multimodal forgetting to adapter space: a refusal-oriented fine-tuning phase produces the Memory Forgetting Adapter, a second few-shot retain-set fine-tuning phase yields a retaining anchor, and a dual-criterion binary mask removes only those adapter entries whose forgetting gradient conflicts with preservation and dominates in relative magnitude (Zeng et al., 25 Nov 2025).

A separate line moves forgetting to inference. In-context knowledge unlearning fine-tunes an LLM so that the presence of prompt-side unlearning tokens <<UNL>>u<</UNL>> causes the answer to be the special token “forgot” for target knowledge while retaining normal answers for unrelated queries (Takashiro et al., 2024). This is designed forgetting at test time rather than during parameter or memory update. A plausible implication is that designed forgetting can be implemented either as a persistent state change or as a reversible control signal, depending on the deployment requirement.

5. Evaluation protocols and empirical findings

Empirical work evaluates designed forgetting along at least four axes: forgetting effectiveness, retained utility, efficiency or storage savings, and residual leakage. The exact metrics vary by domain. LWF reports answer accuracy on domain-specific QA tasks including gsm8k, QASC, SST-5, dental, and psychol; H$M(t)=S\exp(-\lambda t)$6-EMV uses QA accuracy, tree-size $M(t)=S\exp(-\lambda t)$7, and query-time token count $M(t)=S\exp(-\lambda t)$8; FSFM measures storage usage, latency, throughput, signal-to-noise ratio, and dangerous or sensitive retention; MUNKEY reports Test Accuracy, Retain Accuracy, Forget Accuracy, Membership Inference Attack AUROC, and Average Gap; and Representation Unlearning reports Forget Accuracy, Retain Accuracy, $M(t)=S\exp(-\lambda t)$9CE, MIA AUC, speed-up versus retraining, and GPU memory footprint (Jiang et al., 26 May 2025, Bärmann et al., 13 Apr 2026, Gu et al., 22 Apr 2026, Laguna et al., 16 Mar 2026, Almudévar et al., 29 Jan 2026).

Several concrete results establish that selective forgetting can improve downstream behavior rather than merely reduce memory. On Llama3.2-1B, LWF with mixed forgetting of all non-target tasks yields average relative improvements of $^2$0 on gsm8k, $^2$1 on QASC, $^2$2 on SST-5, $^2$3 on dental, and $^2$4 on psychol; high-$^2$5 filtering outperforms low-$^2$6 filtering, and periodic unlearning outperforms both “ahead” and “random” schedules (Jiang et al., 26 May 2025). On TEACh with 5-episode histories, H$^2$7-EMV reports memory-size reduction of approximately $^2$8 $^2$9 nodes$\tau_n$0, query-time compute reduction of approximately $\tau_n$1 $\tau_n$2, maintained first-round QA accuracy $\tau_n$3, and second-round QA accuracy $\tau_n$4, described as a $\tau_n$5 relative gain due to learned relevance (Bärmann et al., 13 Apr 2026). FSFM reports storage usage at $\tau_n$6 capacity versus $\tau_n$7 for baseline, average latency $\tau_n$8 s versus $\tau_n$9 s, throughput $\alpha_n$0 versus $\alpha_n$1 q/min, dangerous retention $\alpha_n$2, sensitive retention $\alpha_n$3, a $\alpha_n$4 net gain in content quality, and $\alpha_n$5 improvement in effective access efficiency (Gu et al., 22 Apr 2026).

Architectural designs also show strong unlearning behavior. MUNKEY, evaluated on CIFAR-10, CIFAR-100, Tiny ImageNet, PathMNIST, BloodMNIST, and DermaMNIST, achieves the lowest Average Gap across both $\alpha_n$6 and $\alpha_n$7 forget rates, with MIA values typically very close to $\alpha_n$8 on $\alpha_n$9, unlearning runtime of approximately $M=\{(k_i,v_i)\}_{i=1}^N$0 s, and one-time training overhead of only approximately $M=\{(k_i,v_i)\}_{i=1}^N$1 per epoch relative to a vanilla ViT (Laguna et al., 16 Mar 2026). Representation Unlearning on TinyImageNet reports speed-ups of approximately $M=\{(k_i,v_i)\}_{i=1}^N$2 in the standard regime and $M=\{(k_i,v_i)\}_{i=1}^N$3 in the zero-shot regime, with peak GPU memory of approximately $M=\{(k_i,v_i)\}_{i=1}^N$4 MB and $M=\{(k_i,v_i)\}_{i=1}^N$5 MB versus approximately $M=\{(k_i,v_i)\}_{i=1}^N$6 MB for retraining (Almudévar et al., 29 Jan 2026). In multimodal privacy removal, SMFA is reported to reduce text-memory ROUGE-L on the forget set close to zero at a $M=\{(k_i,v_i)\}_{i=1}^N$7 forget ratio on LLaVA-OneVision while preserving over $M=\{(k_i,v_i)\}_{i=1}^N$8 of ROUGE-L on the retain set and retaining at least $M=\{(k_i,v_i)\}_{i=1}^N$9 of original image-understanding scores (Zeng et al., 25 Nov 2025).

Inference-time forgetting shows a different trade-off profile. On TOFU and Age, in-context knowledge unlearning with LoRA fine-tuning achieves up to $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$0 Forget and $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$1 Retain in-domain for Llama2-13B on TOFU, while out-of-domain retention can drop sharply, for example to $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$2 on TOFU world facts for the same model (Takashiro et al., 2024). FNNs on MNIST and Fashion-MNIST reach approximately $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$3–$M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$4 test accuracy with MIA score in $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$5 for the best variant, and BCL in continual learning reaches $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$6, $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$7, and $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$8 retained accuracy on split-MNIST and permuted-MNIST settings, with larger gains on split-CIFAR100 when the full game-theoretic mechanism is used (Hatua et al., 2024, Raghavan et al., 2021).

6. Misconceptions, governance, and open problems

A common misconception is that deletion of records is equivalent to forgetting. The data-systems literature explicitly rejects that equivalence: erasure acts on stored representations, whereas unlearning must propagate deletion through learned parameters and downstream behavior (Makovska et al., 24 Feb 2026). A second misconception is that successful suppression at output level necessarily implies internal erasure. The “pretend to forget” analysis in in-context knowledge unlearning shows the opposite: for forget samples, intermediate layers still place highest probability on the true answer, and only the last layer switches to output “forgot” (Takashiro et al., 2024).

The literature also documents collateral risks. LWF reports “superficial forgetting,” where format mismatches such as free-form versus multiple-choice QA can collapse output style if those examples are selected as forgetting data; it also notes approximately one extra epoch of overhead because computing $M_u=M\setminus\{(k_i,v_i)\mid i\in D_f\}$9 requires one backward pass per self-generated sample (Jiang et al., 26 May 2025). SMFA is motivated by the observation that naive unlearning can severely degrade general visual understanding, especially on challenging ophthalmic images (Zeng et al., 25 Nov 2025). MUNKEY trades iterative unlearning cost for storage of one exemplar token per training sample, and Representation Unlearning depends on Gaussian approximations and Neural-Collapse proxies that may fail outside the demonstrated regime (Laguna et al., 16 Mar 2026, Almudévar et al., 29 Jan 2026).

Governance concerns are not peripheral. Makovska et al. argue that designed forgetting should be evaluated not only by compliance or utility retention but also by transparency, accountability, and epistemic justice (Makovska et al., 24 Feb 2026). Their proposed design principles include forgetting-by-design from day 1, layered mechanisms combining exclusion, erasure, and unlearning, semantic dependency awareness, participatory decision-making, evaluative metrics beyond accuracy, reversibility and auditability where lawful and safe, and scalable infrastructure such as sharding and incremental retraining. They also emphasize that forgetting can simultaneously protect rights and enable silencing.

Open research directions are similarly consistent across papers. LWF calls for stronger metrics of knowledge conflict, reduced overhead through approximate Fisher or subspace methods, and theoretical analysis of inter-task interference (Jiang et al., 26 May 2025). Agent-memory systems point to reinforcement-learning-based policy optimization, cross-modal forgetting, meta-learning of forgetting policies, and integration with differential privacy or federated protocols (Gu et al., 22 Apr 2026). Multimodal unlearning suggests extension to continual or online unlearning and theoretical analysis of high-dimensional masking criteria (Zeng et al., 25 Nov 2025). Representation-space and architectural methods raise the question of how far forgetting can be shifted away from parameter updates without sacrificing verifiability (Almudévar et al., 29 Jan 2026, Laguna et al., 16 Mar 2026).

Taken together, these results position designed forgetting as a general systems principle: forgetting is engineered, parameterized, measured, and governed. The central challenge is no longer whether systems can forget, but how selectively, efficiently, verifiably, and justly they should do so.