Memory Curse: Mechanisms and Mitigations

• Memory Curse is a phenomenon where increasing memory usage degrades performance, stability, or reliability across machine learning, software, and systems.
• It arises from various mechanisms such as extended temporal dependencies, stale memory retrieval in agents, and literal representational overhead in software.
• Mitigation strategies include stable reparameterization, memory sanitization, structured abstraction, and explicit runtime memory governance to counter adverse effects.

“Memory curse” is a domain-dependent term for counterintuitive degradations associated with memory, recall, or memory-bearing representations. In machine learning, it denotes settings in which longer target memory makes approximation harder and training slower, or in which expanded recall destabilizes inference or cooperation. In computer systems, it denotes anomalies in which additional memory frames, larger caches, or unmanaged retained state worsen performance or reliability. Across these literatures, the term does not name a single theorem; rather, it designates a recurring pattern in which more memory, more persistent history, or more literal memory representation ceases to be monotone beneficial and instead becomes a source of instability, inefficiency, or brittleness (Li et al., 2020).

1. Domain-specific meanings

The phrase has acquired several technically distinct meanings.

Domain	What counts as “memory”	Counterintuitive effect
Temporal learning	Long-range dependence in targets or disturbances	Approximation and optimization degrade as memory length grows (Li et al., 2020, Wang et al., 2023, Lauand et al., 2023)
LLMs and agents	Parametric fact storage, dialogue history, retrieved episodic memories	Reversal fails, cooperation erodes, or stale memories mislead behavior (Wang et al., 2 Apr 2025, Liu et al., 8 May 2026, Simsek, 13 Apr 2026)
Software analysis	Raw code tokens, especially variable names	Generalization worsens and memory usage inflates (Groppe et al., 2024)
Systems	Page frames, caches, heap state, collectible objects	More memory can increase faults or create GC pathologies (Fornai et al., 2010, Nunez et al., 2016, Sotoudeh, 15 Apr 2025, Briggs et al., 2015)

This heterogeneity matters. In recurrent learning, the term refers to the interaction between long-memory targets and stable approximation. In agent systems, it concerns what retrieved history does to reasoning and policy. In operating systems, it names anomalies where larger memory allocations worsen observed behavior. The shared motif is not identical mechanism but adverse scaling with retained state.

2. Long-memory targets in recurrent and state-space models

In “On the Curse of Memory in Recurrent Neural Networks: Approximation and Optimization Analysis” the setting is continuous-time linear RNNs learning temporal input-output relationships generated by linear relationships, understood mathematically as a sequence of linear functionals. The paper proves a universal approximation theorem for such linear functionals, characterizes the approximation rate and its relation with memory, and analyzes training dynamics. Its central conclusion is that when there is long term memory in the target, it takes a large number of neurons to approximate it, the training process suffers from slow downs, and both effects become exponentially more pronounced with memory; this is the phenomenon called the “curse of memory” (Li et al., 2020).

“StableSSM: Alleviating the Curse of Memory in State-space Models through Stable Reparameterization” reformulates the issue for SSMs. For a target causal, bounded, continuous, regular, time-homogeneous functional sequence $H=\{H_t\}$, the memory function is defined by

$$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$

with $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$. The target has decaying memory if $M(H)(t)\to 0$, and exponential decaying memory if there exists $\beta>0$ such that $e^{\beta t}M(H)(t)\to 0$. The paper’s main negative result, Theorem 3.3, states that if a target has a $B_0$-stable approximation by SSMs with uniformly bounded weights, then its memory must decay exponentially; vanilla SSMs therefore “cannot stably approximate targets with polynomial decaying memory.” The mechanism is that approximating long-memory targets forces recurrent eigenvalues toward the stability boundary, making approximation unstable and optimization brittle. The paper introduces stable reparameterizations such as $f(w)=-e^w$ and $f(w)=-\log(1+e^w)$, proves in Theorem 3.5 that stable reparameterization restores stable approximation for bounded, causal, continuous, regular, time-homogeneous linear functionals, and derives an optimization bound of the form $G_f(w)\lesssim C_{H,\hat H}\,|f'(w)|/|f(w)|^2$ in continuous time. It further proposes a rational parameterization $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$0, with discrete analogue $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$1, to obtain a more uniform gradient-over-weight ratio (Wang et al., 2023).

A related but distinct usage appears in stochastic approximation with Markovian disturbance. “The Curse of Memory in Stochastic Approximation” shows that the favorable i.i.d. picture changes qualitatively when the disturbance process is geometrically ergodic Markovian. For fixed step size $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$2, the paper identifies a generally non-zero target bias and shows that Polyak-Ruppert averaging leaves an $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$3 correction in the asymptotic covariance. In the linear case,

$$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$4

and the correction may be massive if mean dynamics are not well conditioned. In a representative example with $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$5, the factor $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$6 appears in the bias representation, making the memory effect explicit as $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$7 (Lauand et al., 2023).

3. Parametric, retrieved, and governed memory in LLMs and agents

In transformer studies, “memory curse” has been used to describe failures of knowledge storage and reuse. “Is the Reversal Curse a Binding Problem?” argues that the Reversal Curse is a manifestation of the long-standing binding problem, and places it within a broader “memory curse” view of transformer-based LLMs: models may memorize facts, but do so in a brittle, role-specific, and poorly integrated way. The paper attributes this to inconsistency of concept representations and entanglement of concept representations. In the entanglement analysis, concept updates mix through shared projection parameters, with cross-contamination controlled by $$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$8. The paper reports that a JEPA-based design can break the Reversal Curse without specialized data augmentation or non-causal masking, and that memory layers with ultra-wide sparse top-$$M(H)(t):=\sup_{|x|_{\infty}\le 1}\frac{|H_t(u^x)|}{|x|_{\infty}+1},$$9 softmax activations further improve disentanglement and reversal generalization (Wang et al., 2 Apr 2025).

A more explicit use of the phrase appears in repeated-game agents. “The Memory Curse: How Expanded Recall Erodes Cooperative Intent in LLM Agents” studies 7 LLMs across 4 repeated social dilemmas over 500 rounds and reports that expanding accessible history degrades cooperation in 18 of 28 model-game settings. The paper analyzes 378,000 reasoning traces and associates the degradation with eroding forward-looking intent rather than rising paranoia. It then shows that memory sanitization, which holds prompt length fixed while replacing visible history with synthetic cooperative records, restores cooperation substantially, and that ablating explicit Chain-of-Thought often reduces the collapse. The empirical pattern is therefore content-driven rather than a mere long-context-length effect (Liu et al., 8 May 2026).

The governance perspective treats the problem as one of deciding when memory should be trusted, suppressed, or deprecated. “When to Forget: A Memory Governance Primitive” proposes Memory Worth (MW), a two-counter per-memory statistic

$u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$0

where $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$1 and $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$2 are weighted counts of successful and failed retrieval episodes. Under stationarity, exploration, bounded outcomes, minimum weight, and outcome stationarity given retrieval, MW converges almost surely to

$u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$3

The paper is explicit that this is associational, not causal. Empirically, after 10,000 episodes in a controlled synthetic environment, the Spearman rank-correlation between MW and true utilities reaches $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$4 across 20 seeds, compared to $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$5 for systems that never update their assessments. In a retrieval-realistic micro-experiment, stale memories cross a low-value threshold and end at MW $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$6, whereas specialist memories remain high-value at MW $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$7 across 3,000 episodes (Simsek, 13 Apr 2026).

4. Variable names, representation size, and the software-analysis usage

In software vulnerability prediction, the term is used for a representational pathology rather than temporal dependence. “Variables are a Curse in Software Vulnerability Prediction” argues that concrete variable names induce an infinite number of text representations for the same functionality. Existing graph-based models that encode raw code fragments are therefore driven toward identifier-specific surface forms instead of intrinsic functionality, and they suffer a large memory burden because node features must be padded to the maximum token length in the dataset. The paper introduces name dependence edges, an abstract syntax graph (ASG), and a 3-property encoding based on class, name, and type. Four graph variants are evaluated: AST, AST+, ASG, and ASG+, with 3propASG and 3propASG+ compared to codeAST and codeAST+. Reported F1 scores improve from 30.20 to 44.97 on Chromium+Debian, from 57.01 to 62.30 on FFmpeg+Quemu, and from 75.57 to 79.86 on VDISC, with similar gains for the “+” variants. The memory result is sharper: 3-property encoding fits in 8 GB memory, whereas code-based encoding needs up to 560 GB, and the reduction factor is reported as up to 30,000×. For three Chromium+Debian samples, the required memory changes from 59 GB to 5.3 MB, from 152 GB to 8.4 MB, and from 468 GB to 14.5 MB (Groppe et al., 2024).

This usage broadens the term beyond temporal history. Here the “curse” is the fact that literal representational memory—retaining arbitrary variable names as features—creates both semantic variability and extreme storage overhead. The proposed remedy is not longer-range modeling but canonicalization plus explicit graph structure.

5. Operating systems, caching, and garbage-collection anomalies

The classical operating-systems usage is Belady’s anomaly. “FIFO anomaly is unbounded” studies demand paging under FIFO and shows that page-fault anomaly ratios are not bounded by 2. The paper formalizes the anomaly by

$u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$8

and defines the anomaly ratio $u^x(t)=x\,\mathbf{1}_{\{t\ge 0\}}$9. It recalls the classical reference string $M(H)(t)\to 0$0, for which FIFO incurs 9 faults with 3 frames and 10 faults with 4 frames, then proves that for any large number $M(H)(t)\to 0$1 there exist $M(H)(t)\to 0$2, $M(H)(t)\to 0$3, and $M(H)(t)\to 0$4 such that the ratio exceeds $M(H)(t)\to 0$5. In this literature, the memory curse is the fact that giving a program more frames can make FIFO page replacement perform worse, not better (Fornai et al., 2010).

Managed runtimes exhibit an allied problem in software caches. “Prioritized Garbage Collection: Explicit GC Support for Software Caches” argues that larger caches reduce misses but also increase live heap size, raise GC cost, and can cause memory pressure or out-of-memory failures. The paper introduces priority references grouped into PrioSpaces, with a target memory bound and a policy that clears references lowest priority first until the total footprint fits within the bound. It uses this interface to build a space-aware LRU cache, Sache, as a drop-in replacement for Guava-like caches. The adaptive policy sets cache capacity to $M(H)(t)\to 0$6, where $M(H)(t)\to 0$7 is heap size, $M(H)(t)\to 0$8 live size outside the cache, and $M(H)(t)\to 0$9 a reserve. The paper reports that, using a Sache, it is almost impossible for an application to experience a memory leak, memory pressure, or an out-of-memory crash caused by software caching (Nunez et al., 2016).

Garbage collection itself has a formal impossibility version of the curse. “Pathological Cases for a Class of Reachability-Based Garbage Collectors” proves that no correct garbage collector implementing a realistic mutator-observer interface can guarantee both constant-length pause times and prompt reclamation of unreachable memory in full generality. The lower bound is

$\beta>0$0

where $\beta>0$1 is worst-case pause time and $\beta>0$2 worst-case collection delay. Operationally, a pathological program can force the runtime either to introduce a long GC pause or to reject an allocation even though space is available but not yet reclaimed (Sotoudeh, 15 Apr 2025).

A more constructive runtime response appears in “Cold Object Identification in the Java Virtual Machine.” The paper studies long-lived but rarely referenced heap objects, termed cold objects, and proposes a stack-based framework that samples mutator stacks, pins selected regions, records activity maps, and moves cold objects into designated cold regions so they may be preferentially paged out. Across SPECjvm2008 benchmarks, the stack-based method incurs about 4% average performance degradation. Against an Access Barrier baseline, FalseInactivity is reported as 1.62% for Derby and 0.32% for compiler.compiler, indicating that stack sampling can identify cold objects with relatively low misclassification (Briggs et al., 2015).

6. Recurring mechanisms and mitigation strategies

Across the literature, several recurring remedies appear. One class changes parameterization so that long memory does not force models toward a stability boundary. StableSSM attributes the curse to recurrent weights converging to the stability boundary and uses stable reparameterizations—exponential, softplus, and a rational map—to improve both approximation robustness and optimization stability (Wang et al., 2023).

A second class changes what is remembered rather than how much is remembered. In repeated-game LLM agents, memory sanitization restores cooperation while prompt length remains fixed, indicating that the trigger is memory content, not length alone (Liu et al., 8 May 2026). In agent memory governance, MW supplies an operational signal for suppressing or deprecating stale memories rather than treating all retained memories as equally trustworthy (Simsek, 13 Apr 2026).

A third class replaces literal memory with structured abstraction. In vulnerability prediction, name dependence edges, ASGs, and 3-property encoding remove arbitrary variable-name variability while preserving functionality-relevant relations, simultaneously improving F1 and sharply reducing memory consumption (Groppe et al., 2024). A plausible implication is that some memory curses are not caused by insufficient capacity, but by storing the wrong invariants.

A fourth class imposes explicit runtime policy on retained state. PrioSpaces make cache eviction depend on priority and footprint rather than uncontrolled heap growth (Nunez et al., 2016); cold-region collection separates seldom referenced objects from the hot working set (Briggs et al., 2015); and the GC lower-bound literature clarifies which tradeoffs cannot be eliminated by policy alone (Sotoudeh, 15 Apr 2025). In operating systems, the FIFO anomaly shows that policy choice can dominate raw memory size (Fornai et al., 2010).

Taken together, these results suggest a common lesson: memory is not intrinsically beneficial. Its effect depends on representation, stability, retrieval, and governance. Longer temporal dependence can make approximation exponentially harder; larger visible history can shift reasoning toward defensive path dependence; and larger retained state in systems can worsen paging, GC, or cache behavior. The term “memory curse” therefore names a recurrent scientific theme: memory helps only when the mechanism that stores, exposes, and updates it is itself well structured.