AdaptiveMem Systems: Definition, Applications, and Solutions

• AdaptiveMem is memory systems that dynamically respond to workload, tasks, user, and environmental conditions to optimize information retention, retrieval, and management. This includes applications such as reinforcement learning, continual learning, adaptive replay, and manycore systems, where memory management adapts to improve efficiency and effectiveness of tasks without static or predefined rules.
• Central mechanisms of AdaptiveMem involve utility estimation, selective admission, and eviction, state-dependent retrieval, consolidation of data, and feedback-driven revision of memory contents.
• Examples of AdaptiveMem include systems like AMC, which learns probabilistic token gates and uses crystallization of memory, AdaMemento, which combines paths of successful trajectories with reflection networks, and ARM which combines retrieval, forgetting, eviction, and adaptive retrieval strategies with a stochastic decay model to enhance the retention of important memories however relying on utility proxies.

AdaptiveMem is a general term for memory systems that dynamically determine what information to retain, retrieve, transform, consolidate, revise, or discard in response to workload, task, model, user, or environmental conditions. It does not denote a single standardized algorithm. The term encompasses decentralized memory management for manycore systems, adaptive replay for continual learning, adaptive experience memory for reinforcement learning, dynamic retention for Transformer representations, selective memory for retrieval-augmented generation, policy-controlled memory for LLM agents, and cross-model or multi-agent memory coordination. Across these settings, AdaptiveMem contrasts with static storage or fixed retrieval by treating memory as a controlled, feedback-dependent process.

1. Conceptual scope and historical development

AdaptiveMem systems address a common problem: the historically available information is larger than the amount that can be accessed, processed, retained, or presented efficiently at every decision. Adaptivity may therefore operate at several distinct levels.

At the systems level, adaptive memory determines physical placement, partitioning, routing, caching, and deployment under changing computational and network conditions. Self-aware Memory (SaM), introduced for manycore systems, distributes memory-management functionality among autonomous components and continuously optimizes locality rather than relying on a centralized manager (Mattes et al., 2014). SEDMA extends this principle across computation, communication, and deployment through a dual-memory architecture containing long-term performance patterns and short-term workload statistics (Li et al., 9 Jan 2026).

At the learning level, adaptive memory determines which historical data should be processed or preserved. Adaptive memory replay treats replay selection as a non-stationary multi-armed-bandit problem when historical data are abundant but gradient computation is limited (Smith et al., 2024). Adaptive Memory Realignment instead modifies a bounded replay buffer when recurring classes undergo concept drift, selectively replacing stale samples with current examples (Ashrafee et al., 3 Jul 2025).

At the representation level, adaptive memory controls which internal representations survive through a computation graph. Adaptive Retention learns probabilistic token gates under a memory budget and applies deterministic top-$M$ selection at inference, progressively shortening Transformer sequences with depth (Rafiuddin et al., 9 Oct 2025). Adaptive Memory Momentum applies the same broad principle to optimizer state by dynamically choosing how much historical gradient direction to retain (Topollai et al., 6 Oct 2025).

At the agent level, AdaptiveMem governs external memories used by reinforcement-learning agents, language agents, and multi-agent systems. AdaMemento combines successful trajectories, failed prediction experiences, intrinsic motivation, and confidence-gated exploitation (Yan et al., 2024). AdaMEM separates offline long-term trajectory memory from online short-term strategy memory (Zhang et al., 4 Jun 2026). AdMem combines semantic, episodic, and procedural memory with actor, memory, and critic agents (Wang et al., 5 Jun 2026). Other systems learn admission policies, memory graphs, model-conditioned read/write transformations, or bandit policies for memory operations (Zhang et al., 4 Mar 2026, Yang et al., 5 Jun 2026, Tan et al., 7 Jun 2026, Chen et al., 19 Jun 2026, Jiang et al., 15 Jul 2026).

The common abstraction is:

$$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$

The meaning of “memory” varies substantially: physical pages, replay examples, optimizer directions, token representations, vector embeddings, trajectories, procedural cards, policy rules, or model-specific textual contexts.

2. Core mechanisms

AdaptiveMem implementations differ in detail but repeatedly employ a small set of mechanisms.

Utility estimation assigns a value to a memory item or operation. Utility may depend on locality, forgetting, TD error, novelty, downstream value, retrieval frequency, semantic relevance, confidence, recency, content type, task needs, or model compatibility. In AMC, transition utility combines TD error, novelty, and downstream value:

$U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$

with default weights $w_1=0.5$, $w_2=0.3$, and $w_3=0.2$ (Khanda et al., 2 Apr 2026). A-MAC combines future utility, factual confidence, semantic novelty, temporal recency, and content type prior in a learned admission score (Zhang et al., 4 Mar 2026). AdaMem uses role-specific policies to determine which conversational information is worth writing at all (Chen et al., 19 Jun 2026).

Selective admission and eviction prevent memory growth from becoming equivalent to indiscriminate accumulation. A-MAC treats admission as a thresholded classification problem:

$$\operatorname{Admit}(m)= \begin{cases} 1,&\mathcal{S}(m)\geq\theta,\ 0,&\text{otherwise}. \end{cases}$$

ConMem admits structured memory cards only when consistency and quality criteria are satisfied, then merges near-duplicates and prunes low-value entries (Tan et al., 7 Jun 2026). ARM consolidates frequently retrieved vector entries and applies multiplicative decay to stale unremembered entries (Bursa, 4 Jan 2026). AMC evicts low-utility transitions from its Liquid phase while protecting highly crystallized experiences unless interference persists (Khanda et al., 2 Apr 2026).

State-dependent retrieval replaces fixed top-$k$ access with decisions conditioned on task phase, memory state, current model, or user role. MemCon chooses among shallow retrieval, deep retrieval, plan injection, re-retrieval, consolidation, forgetting, and no operation using a contextual UCB policy (Jiang et al., 15 Jul 2026). Adaptive RAG Memory modifies the persistence of external vectors according to retrieval history rather than changing the generator (Bursa, 4 Jan 2026). AdaMEM retrieves from long-term trajectories using the current state, then synthesizes a transient or persistent strategy for action generation (Zhang et al., 4 Jun 2026).

Consolidation converts transient information into more stable representations. In AdaMemento, successful trajectories are abstracted into a prediction network and failed actions train a reflection network (Yan et al., 2024). AMC models consolidation continuously through a crystallization state $c_i(t)\in[0,1]$, with Liquid, Glass, and Crystal phases (Khanda et al., 2 Apr 2026). AdMem uses a short-term task-local memory whose useful information is summarized into persistent semantic, episodic, and procedural stores (Wang et al., 5 Jun 2026).

Feedback and revision distinguish adaptive memory from static archives. Feedback may be task success, QA correctness, retrieval frequency, reward, uncertainty, interference, model compatibility, or environmental performance. AdaMem patches its role-specific extraction policy after weekly QA failures and rolls back patches that do not improve historical validation (Chen et al., 19 Jun 2026). RoMem uses performance-gap rewards to train model-conditioned write and read operators (Yang et al., 5 Jun 2026). SEDMA updates long-term patterns and short-term workload statistics after operations complete (Li et al., 9 Jan 2026).

3. Principal architectural families

Distributed memory management

SaM divides the memory system into autonomous memory units and core-side management components. Memory units maintain physical memory, allocation, ownership, mapping, access rights, and neighborhood state. Core-side components receive requests, perform access checks, translate virtual addresses, and hide distributed physical placement from software (Mattes et al., 2014).

Its optimization process extends the autonomic-computing MAPE cycle with decentralized consensus:

1. local monitoring and neighbor exchange;
2. associative-counter analysis;
3. local optimization proposal;
4. distributed validation and voting;
5. migration and metadata update.

The evaluated policy is locality optimization, which moves memory pages or regions toward the cores using them. The paper reports that suitable monitoring periods, neighborhood sizes, and counter thresholds can amortize decentralized monitoring and migration overhead. Load balancing, reliability improvement, and energy saving are described as possible extensions rather than evaluated policies (Mattes et al., 2014).

SEDMA applies an analogous dual-timescale principle to RRAM matrix processing, peer selection, caching, and runtime deployment. Long-term memory stores successful partitioning, routing, and placement patterns; short-term memory records recent device, workload, peer, and network conditions. Its reported comparison with Ray Distributed gives 87.3% memory utilization efficiency, 142.5 operations per second, and 171.2 milliseconds communication latency, compared with 72.1%, 98.7 operations per second, and 245.3 milliseconds for Ray Distributed (Li et al., 9 Jan 2026).

Continual-learning memory

Adaptive memory replay assumes that all previous datasets remain accessible while computation is scarce. Historical tasks are treated as bandit arms, and probe estimates of current forgetting are smoothed with an exponential moving average:

$$\mu_i^{(j)}=\beta\bar{\mathbf f}_i^{(j)} +(1-\beta)\mu_i^{(j-1)}.$$

Replay clusters are sampled with a Boltzmann distribution:

$$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$0

Replay examples replace current-task examples rather than increasing the number of model inputs and gradients. The reported settings are $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$1, $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$2, and a $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$3 replay-to-current-data ratio. Across DomainNet, Medical MNIST, SyViC, and language pre-training, the method generally reduces forgetting relative to uniform replay while keeping the computational budget approximately constant (Smith et al., 2024).

AMR addresses a different failure mode: stale replay samples can oppose adaptation when the representation of a recurring class changes. It compares uncertainty distributions for old and current samples using a two-sample Kolmogorov–Smirnov test. For detected drifted classes, it flushes all old class exemplars and refills the same memory slots with current labeled examples. It leaves stationary-class memory untouched and operates on top of ER, ER-ACE, DER++, SER, and CLS-ER (Ashrafee et al., 3 Jul 2025).

Reinforcement-learning memory

AMC assigns each transition a continuously evolving crystallization state governed by an Itô SDE:

$$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$4

High utility increases crystallization; interference causes decrystallization. The corresponding population-level Fokker–Planck equation admits a Beta stationary distribution under the paper’s averaging assumptions. The memory hierarchy uses Liquid, Glass, and Crystal buffers, with a default capacity ratio of $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$5. Learning rates are modulated by crystallization:

$$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$6

AMC is coupled to Q-learning, SAC, TD3, and Rainbow DQN. On Meta-World MT50, the reported AP is $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$7, compared with $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$8 for PER and $$\text{observe state} \rightarrow \text{evaluate memory utility} \rightarrow \text{select or transform memory} \rightarrow \text{execute} \rightarrow \text{receive feedback} \rightarrow \text{update memory policy}.$$9 for PNN, while using 380 MB rather than 1000 MB or 5000 MB for those respective baselines (Khanda et al., 2 Apr 2026).

AdaMemento uses a successful-memory buffer, a failed-prediction reflection buffer, and a prediction/reflection network pair. The prediction network proposes actions from successful trajectories; the reflection network estimates confidence in state-action pairs using successful and failed examples. A confidence gate switches between a memory-guided policy and an exploratory base policy. Its experiments include Montezuma’s Revenge, 56 Atari environments, MuJoCo, Dark Chamber, Four Rooms, and Cliff Walking (Yan et al., 2024).

Representation and optimization memory

Adaptive Retention learns Bernoulli-style token gates with probabilities $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$0, imposes an expected retention budget $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$1, and trains with a Hard-Concrete relaxation. At inference, it selects the top-$U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$2 token probabilities. The reported operating points are 30% and 50% retention; the paper claims at least approximately 95% of full-model performance, 35–45% peak-memory reduction, and up to 1.8-times throughput improvement (Rafiuddin et al., 9 Oct 2025).

Adaptive Memory Momentum replaces a fixed momentum coefficient with an online coefficient $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$3. Its update is:

$U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$4

The coefficient is derived as the dual mixture weight between a current-gradient plane and a historical-direction plane. When $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$5 approaches zero, the method behaves more like SGD; when it approaches its upper bound, it retains substantial historical direction. AM-SGD and AM-AdamW retain the respective optimizer’s principal structure while changing the memory mixture. The reported implementations use $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$6 and $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$7 in deep-learning experiments (Topollai et al., 6 Oct 2025).

4. LLM-agent and retrieval memory

Adaptive memory for language agents is primarily concerned with controlling context, memory formation, and procedural transfer without necessarily updating model parameters.

Admission control decides what enters long-term memory. A-MAC computes five normalized features:

$U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$8

It uses one LLM-assisted utility assessment and lightweight confidence, novelty, recency, and content-type features. On LoCoMo, A-MAC reports test F1 of 0.583, precision of 0.417, recall of 0.972, and 2644 milliseconds per candidate, compared with F1 of 0.541 and 3831 milliseconds for A-mem (Zhang et al., 4 Mar 2026).

Role-specific writing is the main intervention in AdaMem. Each character or user receives a natural-language Memory Policy describing what to retain. Weekly QA failures are classified as recall or precision errors, after which a patch is proposed and accepted only when historical validation improves. On AdaMem-Bench, the reported explicit-feedback comparison with DeepSeek gives 85.2 accuracy for AdaMem versus 76.2 for Mem0, with memory volume 371 versus 430 (Chen et al., 19 Jun 2026).

Trajectory abstraction separates durable experience from working strategy. AdaMEM stores successful trajectories offline, retrieves state-indexed entries at decision time, and synthesizes short-term strategies. AdaMEM-HIGH refreshes strategies dynamically, whereas AdaMEM-LOW persists a strategy until the agent requests refresh. On ALFWorld, AdaMEM reaches 54.0% success without fine-tuning, compared with 52.1% for Synapse and 45.2% without memory; STEP-MFT reaches 65.5% in the reported setting (Zhang et al., 4 Jun 2026).

Structured procedural memory combines semantic, episodic, and procedural stores. AdMem uses actor, memory, and critic agents. The critic compares expected and observed outcomes, creates reflections, assigns reward or success signals, and updates procedural memories. Its AgentBoard results report the best completeness in six of eight domains and the best progress in seven of eight domains, although the system adds planning, summarization, criticism, and memory-management cost (Wang et al., 5 Jun 2026).

Memory portability addresses the mismatch between the model that writes memory and the model that reads it. RoMem uses profile-conditioned write and read operators, each implemented through eight soft prefix tokens for separate FLAN-T5-small models. The writer converts model-specific traces into portable evidence; the reader presents that evidence according to the target model. On HotpotQA, 2WikiMultihopQA, and MuSiQue, RoMem reports F1 scores of 65.8, 61.0, and 34.2, respectively, outperforming the listed memory baselines (Yang et al., 5 Jun 2026).

Relation-aware coordination is emphasized by ConMem. Historical trajectories become structured memory cards containing state, plan, execution, evaluation, and trigger information. Cards form a typed graph with supports, constrains, satisfies, and conflicts relations. Retrieval is followed by maximal-marginal-relevance filtering, dependency expansion, conflict resolution, and budgeted serialization. Across AutoGen, CAMEL, and MacNet, ConMem reports more than 50% pruning of expanded candidates, more than 80% pruning on planning tasks, and more than 80% reduction in planning overhead (Tan et al., 7 Jun 2026).

Operation-level control is the focus of MemCon. A tabular contextual-bandit controller chooses retrieval depth, plan injection, re-retrieval, consolidation, forgetting, or NoOp based on a discretized task-and-memory state. UCB exploration updates action values from task-level success and efficiency feedback. Across six benchmarks, three agent frameworks, and three LLM backbones, the paper reports up to 15.2 percentage points of task-success improvement and 5–20% token reduction (Jiang et al., 15 Jul 2026).

5. Memory dynamics, control, and theoretical models

AdaptiveMem systems differ in whether adaptation is discrete, continuous, probabilistic, or policy-based.

Discrete state transitions are used by AMC’s Liquid–Glass–Crystal hierarchy. Promotion depends on crystallization thresholds, while hysteresis prevents immediate demotion after transient changes. ARM similarly uses a binary remembered flag: an item becomes protected after its retrieval count reaches $U_i(t)=w_1\delta_i(t)+w_2N_i(t)+w_3V_i(t),$9, with default $w_1=0.5$0, grace period $w_1=0.5$1, and decay factor $w_1=0.5$2 (Bursa, 4 Jan 2026).

Probabilistic selection appears in adaptive replay, token retention, and bandit-controlled memory access. Boltzmann sampling trades exploitation against exploration in historical replay (Smith et al., 2024). Hard-Concrete gates provide differentiable probabilistic retention during Transformer training (Rafiuddin et al., 9 Oct 2025). UCB selects memory operations while preserving exploration of rarely tried actions (Jiang et al., 15 Jul 2026).

Continuous stochastic dynamics are most explicit in AMC. Under fast–slow averaging, the crystallization process has a Beta stationary distribution with parameters

$w_1=0.5$3

Its mean is

$w_1=0.5$4

The paper claims well-posedness, global convergence of the population density, individual mean convergence, variance bounds, and Q-learning error bounds. These results require bounded utility, interference assumptions, ergodicity, coverage, Lipschitzness, bounded rewards, and related conditions (Khanda et al., 2 Apr 2026).

Regret and convergence formulations appear in bandit-based systems. Adaptive memory replay defines regret relative to an ideal set of currently forgotten examples (Smith et al., 2024). MemCon gives logarithmic per-context regret under stationary credited-return distributions, bounded rewards, and sufficient state-action visitation (Jiang et al., 15 Jul 2026). These guarantees are conditional and do not establish universal performance for nonconvex neural training or arbitrary non-stationary environments.

Control-theoretic and optimization objectives are used in systems such as SaM and SEDMA. SaM seeks to amortize decentralized control overhead through improved locality (Mattes et al., 2014). SEDMA combines compute cost and memory overhead in partitioning and placement objectives, while explicitly weighting historical and recent regularization through

$w_1=0.5$5

Budget-constrained composition is central to ConMem and Adaptive Retention. ConMem selects a coherent slate of cards under a token budget while penalizing conflict, redundancy, and staleness (Tan et al., 7 Jun 2026). Adaptive Retention enforces a token budget through a Lagrangian multiplier and uses top-$w_1=0.5$6 selection at deployment (Rafiuddin et al., 9 Oct 2025).

6. Applications, evaluation, and limitations

AdaptiveMem has been evaluated in manycore simulation, RRAM and distributed systems, continual vision and language learning, reinforcement learning, long-context language modeling, retrieval-augmented generation, LLM agents, multi-agent systems, and cross-model question answering.

Representative application-specific results include:

• SaM reports that locality optimization can outweigh decentralized monitoring and migration overhead under appropriate parameters (Mattes et al., 2014).
• Adaptive memory replay reduces forgetting relative to uniform rehearsal, including a reported DomainNet forgetting value of 4.39% compared with 22.97% for standard rehearsal (Smith et al., 2024).
• AMR generally approaches Full Relearning while requiring only replacement samples for affected memory slots rather than complete retraining (Ashrafee et al., 3 Jul 2025).
• AMC reports improvements in forward transfer, catastrophic-forgetting resistance, and memory efficiency across Meta-World, Atari, and MuJoCo (Khanda et al., 2 Apr 2026).
• ARM reports NDCG@5 of 0.9401 and Recall@5 of 1.0000 on its lightweight retrieval benchmark, with approximately 22 million embedding-layer parameters (Bursa, 4 Jan 2026).
• A-MAC improves precision–recall tradeoffs for personalized memory admission on LoCoMo (Zhang et al., 4 Mar 2026).
• AdaMEM, AdMem, ConMem, and MemCon report improvements in long-horizon agent task solving through strategy abstraction, procedural reflection, relation-aware coordination, or learned memory-operation control (Zhang et al., 4 Jun 2026, Wang et al., 5 Jun 2026, Tan et al., 7 Jun 2026, Jiang et al., 15 Jul 2026).
• RoMem addresses cross-LLM memory transfer and reports robustness under unseen-model replacement (Yang et al., 5 Jun 2026).

Despite these results, several limitations recur.

Memory utility is only indirectly observed. Retrieval frequency, loss increase, TD error, uncertainty, task success, and model compatibility are proxies. A frequently accessed memory may be wrong, a rarely accessed fact may be important, and high forgetting may not imply high downstream value.

Adaptation can be slow or unstable. Long monitoring periods, small exponential-moving-average coefficients, persistent strategies, or slowly decaying statistics may fail to respond to abrupt changes. Conversely, low thresholds and aggressive updates can produce excessive migration, retrieval, rewriting, or memory oscillation.

Local decisions lack global guarantees. Decentralized systems such as SaM optimize partial neighborhoods rather than globally optimal placement. Bandit and agent-memory controllers depend on recurring contexts and sufficient feedback. AMC’s stochastic and Q-learning guarantees rely on assumptions substantially stronger than those generally available in deep reinforcement learning.

Memory can amplify errors. Hallucinated, stale, private, biased, or unsafe content may be consolidated, retrieved, rewritten, or transferred across models. Negative memories can suppress useful behavior; positive memories can encode local optima or unsafe procedures. LLM critics, relation judges, and utility assessors may introduce evaluation errors or hindsight bias.

System costs are often incompletely specified. Several papers do not provide full insertion, deletion, reintroduction, indexing, deduplication, merge, concurrency, or pruning protocols. Some report selection or memory-management gains without complete latency, dollar-cost, variance, or statistical-significance analyses.

Evaluation remains domain-specific. Results from synthetic concept drift, controlled multi-hop QA, selected agent benchmarks, or simulator-based manycore systems do not establish performance under arbitrary real-world streams. In particular, long-term privacy, deletion compliance, multi-user isolation, adversarial memory poisoning, gradual drift, multimodal memory, and very large-scale deployment remain open problems.

A robust AdaptiveMem architecture therefore requires explicit provenance, timestamps, confidence, task or user scope, conflict handling, expiration or demotion, cold storage, recovery paths, and auditable decisions. It should measure not only task quality but also memory precision, retrieval recall, stale-memory rate, harmful-retrieval rate, token or compute cost, adaptation latency, memory growth, and failure recovery.

AdaptiveMem is consequently best understood as a design paradigm rather than a single technique. Its central principle is that memory should be governed by an adaptive policy whose decisions are conditioned on current utility, context, resource constraints, and feedback. The concrete implementations differ—from decentralized page migration and optimizer momentum to probabilistic token retention, replay selection, crystallized transitions, dynamic vector decay, structured memory graphs, and bandit-controlled agent operations—but they share the objective of making memory selective, revisable, resource-aware, and useful under changing conditions.