Elastic Memory in Adaptive Systems

• Elastic memory is an adaptive concept where memory allocation and representation change according to workload, execution phase, or historical state.
• It improves performance by decoupling compute and memory resources, optimizing processes in distributed systems, LLM serving, and recommender systems.
• Applications span adaptive cache management in machine learning to tunable constitutive responses in materials, leading to significant efficiency gains.

Elastic memory denotes a family of mechanisms in which memory is not treated as a fixed passive substrate, but as something whose effective capacity, allocation, representation, or readout changes with workload, query, execution phase, or deformation history. In contemporary systems literature this often means making memory independently elastic relative to compute or reallocating it across phases; in machine learning it includes adaptive latent-budget allocation and recurrent compression of long histories; in mechanics and materials it refers to enduring memory encoded in constitutive response, prestress, or cyclically trained states (Schmitz et al., 26 May 2025, Feng et al., 29 May 2026, Gupta et al., 16 Sep 2025).

1. Scope and major meanings

The expression is used across several technical domains, but it does not denote a single formalism. In distributed systems, it typically refers to memory as a first-class elastic resource. In sequence modeling and agents, it refers to a memory interface whose usage budget or reconstruction policy is query-dependent. In mechanics, it refers to recoverable but history-dependent constitutive or structural response. This suggests that the common denominator is not a particular architecture, but a shift from static memory to memory whose operative form changes under constraints or stimuli.

Domain	Elastic quantity	Representative paper
Distributed systems	CPU/memory decoupling or reallocation	(Schmitz et al., 26 May 2025)
LLM agents and sequence models	Latent budget or compressed recurrent state	(Feng et al., 29 May 2026)
LLM serving	Unified GPU/CPU memory pool with inflation/deflation	(Xu et al., 18 Jun 2025)
Recommenders and on-device learning	Embedding size or training footprint under budget	(Chen et al., 2021)
Recoverable materials	Constitutive return point memory and tunable modulus	(Gupta et al., 16 Sep 2025)
Disordered solids and gravity analogies	History encoded in trained states, prestress, or defect fields	(Kumar et al., 2024)

A recurrent misconception is to equate elastic memory with simple memory scaling. The surveyed literature is more specific. Some works enlarge usable memory without moving data by changing logical ownership rather than physical placement; some keep memory size fixed but alter what is reconstructed from it; some preserve shape while retaining a constitutive memory of prior loading; and some exploit residual internal stress as a memory of formation (Lee et al., 2022, Song et al., 11 Feb 2026, Zhang et al., 2021).

2. Elastic memory as an infrastructure resource

In data systems, elastic memory is frequently defined against the limitation of package-based resource scaling. Justin, for distributed stream processing, argues that memory should be treated as an independently elastic resource rather than as something that passively follows CPU scaling. Its controller monitors both operator busyness and RocksDB-side signals, notably average state access latency $o_i.\tau^t$ and average cache hit rate $o_i.\theta^t$, and uses thresholds $\Delta_\theta = 80\%$ and $\Delta_\tau = 1\text{ms}$ to decide whether to scale parallelism, managed memory, or both. Memory is represented in discrete levels $o_i.m^t=x$, where each task receives $2^x$ times the minimum managed memory, while stateless operators are assigned $o_i.m^t=\bot$. On Nexmark Q11 and Q8, this hybrid policy reached the target rate with about $48\%$ lower CPU and $28\%$ or $27\%$ lower memory than the DS2 CPU-only baseline, with the same number of reconfigurations or fewer (Schmitz et al., 26 May 2025).

A related but structurally different notion appears in disaggregated persistent-memory systems. DINOMO realizes elasticity by keeping data and metadata physically shared in disaggregated persistent memory while partitioning logical ownership across KVS nodes. Reconfiguration therefore changes ownership mappings rather than moving persistent data. The system combines ownership partitioning, disaggregated adaptive caching, selective replication, and lock-free and log-free indexing; at 16 KVS nodes it outperformed Clover by at least $o_i.\theta^t$0 across evaluated workloads while providing fast reconfiguration (Lee et al., 2022). The crucial idea is that elastic memory service capacity can grow through added front-end compute and cache without repartitioning the backing persistent pool.

Ditto extends the same architectural theme to in-memory caching on disaggregated memory. Because CPU-bypass remote memory access breaks traditional centralized replacement structures, Ditto adopts a client-centric caching framework, sample-based eviction, and distributed adaptive switching between caching algorithms. Its motivation is explicitly elastic: compute and memory can be adjusted independently without the multi-minute reshards required by monolithic Redis deployments. In evaluation, Ditto adapted to changing compute and memory resources and outperformed prior caching systems by up to $o_i.\theta^t$1 in real-world workloads and $o_i.\theta^t$2 in YCSB (Shen et al., 2023).

3. Elastic memory in LLM serving, agents, and long-context modeling

In LLM serving, memory elasticity has become inseparable from KV-cache management. eLLM frames the problem as a mismatch between static tensor-backed runtime memory and virtualized KV-cache memory. Its solution is a unified memory substrate built from a Virtual Tensor Abstraction, an Elastic Memory Mechanism, and a lightweight SLO-aware scheduler. The core mechanism is GPU-memory inflation and deflation between activation and KV pools, optionally extended by CPU DRAM as a buffer. The scheduler uses conditions such as

$o_i.\theta^t$3

to trigger inflation, and it reports up to $o_i.\theta^t$4 decoding throughput improvement and $o_i.\theta^t$5 larger batch sizes for $o_i.\theta^t$6-token inputs (Xu et al., 18 Jun 2025).

MemServe generalizes this idea from a single serving engine to a cluster-managed KV substrate. Its MemPool manages CPU DRAM and GPU HBM across serving instances and exposes memory, index, and transfer APIs for active and historical KV caches. This is the enabling layer for combining context caching with disaggregated inference: match(tokenList) locates reusable historical KV, while transfer and transfer_with_insert move and register cache objects across instances. Coupled to a global prompt-tree scheduler, MemServe improved average and P99 JCT over PD-colocated baselines and reduced TTFT substantially on ShareGPT, LooGLE, and ReAct workloads (Hu et al., 2024).

KunServe introduces a more aggressive form of serving-time elasticity: reclaim memory not from live request state, but from replicated model parameters. Under throttling, it selectively drops replicated parameters and executes requests cooperatively using pipeline parallelism, with remote attention bridging the transient mismatch between parameter placement and KV-cache placement. The central systems claim is that replicated parameters are a reclaimable HBM reserve. Evaluations report tail TTFT reductions of up to $o_i.\theta^t$7 times compared to state-of-the-art systems including Llumnix, vLLM, and InferCept (Cheng et al., 2024).

At the agent level, ElasticMem treats long-term memory as a learnable elastic latent resource rather than a fixed retrieval interface. It builds an offline latent memory bank $o_i.\theta^t$8, retrieves memories from the reasoner hidden state, assigns each retrieved memory a variable budget $o_i.\theta^t$9, and injects the selected latent states as soft memory tokens. The retrieval and budget policy are optimized by group-relative policy optimization. On MemorySuite and ALFWorld, ElasticMem improved weighted average QA accuracy by $\Delta_\theta = 80\%$0 and $\Delta_\theta = 80\%$1 on Qwen2.5-3B-Instruct and Qwen2.5-7B-Instruct, and improved ALFWorld success rate by $\Delta_\theta = 80\%$2 and $\Delta_\theta = 80\%$3, while achieving the lowest ALFWorld token cost among compared methods (Feng et al., 29 May 2026).

A more theoretical sequence-modeling variant appears in "Towards Compressive and Scalable Recurrent Memory". There, Elastic Memory is grounded in HiPPO-LegS and treats historical K/V sequences as samples from continuous signals. The recurrent state stores polynomial coefficients via

$\Delta_\theta = 80\%$4

and memory retrieval reconstructs summary tokens through polynomial sampling,

$\Delta_\theta = 80\%$5

With equal parameters, it beat Memorizing Transformer by $\Delta_\theta = 80\%$6 memory and outperformed Melodi at all memory sizes, while remaining significantly faster than Melodi at $\Delta_\theta = 80\%$7 model size (Song et al., 11 Feb 2026).

4. Budget-adaptive memory in recommendation and federated learning

In recommender systems, elastic memory often means post-training or training-time adaptation to heterogeneous device budgets. RULE—recommendation with universally learned elastic embeddings—splits each item embedding into $\Delta_\theta = 80\%$8 embedding blocks,

$\Delta_\theta = 80\%$9

and defines an elastic embedding as the concatenation of a selected subset,

$\Delta_\tau = 1\text{ms}$0

A performance-estimator-based evolutionary search then chooses blocks under a strict device memory budget $\Delta_\tau = 1\text{ms}$1, with no retraining of the recommender. The method is designed specifically for arbitrary device-specific memory constraints and reported superior performance under tight memory budgets on Amazon-Book and Yelp2020 (Chen et al., 2021).

ELASTIC, for sequential recommendation, uses the term in a narrower architectural sense. It replaces quadratic self-attention with fixed length interest experts and a linear dispatcher attention mechanism, compressing long behavior sequences into a compact representation. To preserve expressive capacity, it initializes a vast learnable interest memory bank and sparsely retrieves compressed user interests from that memory. The abstract reports up to $\Delta_\tau = 1\text{ms}$2 GPU memory usage reduction together with $\Delta_\tau = 1\text{ms}$3 inference speedup (Deng et al., 2024).

NeuLite transfers the notion to cross-device federated learning, where the dominant issue is on-device training memory rather than serving-time storage. It divides a model into blocks $\Delta_\tau = 1\text{ms}$4, trains them progressively, and at stage $\Delta_\tau = 1\text{ms}$5 uses

$\Delta_\tau = 1\text{ms}$6

so that frozen blocks no longer require the full training-time footprint. Its Curriculum Mentor introduces the blockwise loss

$\Delta_\tau = 1\text{ms}$7

while the Training Harmonizer breaks information isolation across blocks. On simulation and Jetson TX2 hardware testbeds, NeuLite reduced peak memory usage by up to $\Delta_\tau = 1\text{ms}$8, enhanced model performance by up to $\Delta_\tau = 1\text{ms}$9, and accelerated training by up to $o_i.m^t=x$0 (Wu et al., 2024).

These works use different mechanisms—block selection, sparse memory-bank retrieval, or progressive blockwise training—but all replace fixed-budget memory usage with memory policies that are explicitly conditioned on deployment constraints or training stage. This suggests that, in learning systems, elastic memory is increasingly a control problem over representational budget rather than only a storage problem.

5. Elastic memory in mechanics and materials

In mechanics, the term acquires a materially specific meaning: memory can persist even when a body remains elastically recoverable. The clearest example is the demonstration of constitutive return point memory in elastically recoverable vertically aligned carbon nanotube foams. The work reports non-volatile memory arising from rate-independent nanoscale friction rather than viscoelastic fading memory. In this setting, reversing loading direction writes a memory, reloading reads it, and nested hysteresis subloops close exactly, consistent with return point memory. The same constitutive mechanism enables tunable dynamic modulus and wave speed, and is exploited in a layered VACNT–aluminum waveguide with 17 VACNT disks and 17 rigid aluminum cylinders (Gupta et al., 16 Sep 2025).

A distinct but related form appears in autonomous deployable structures based on shape memory polymers. In the solar-panel array built from an elastic flasher origami sheet and a circle of scissor mechanisms, memory is distributed across geometry, stored strain, and SMP programming. The system is programmed above $o_i.m^t=x$1, cooled below $o_i.m^t=x$2 in a constrained compact state, and later recovers autonomously when reheated. The reported device is entirely 3D printed, achieves an expansion ratio of $o_i.m^t=x$3 in under $o_i.m^t=x$4 seconds, and exhibits a bifurcation during folding into either a cone or disk configuration, making path control part of the memory problem (Chen et al., 2018).

Prestress provides a third mechanical formulation of elastic memory. In amorphous solids, the residual internal stress field stores the memory of formation and directly changes linear elasticity. For a prestressed network, the quadratic bond energy includes both longitudinal and prestress-controlled transverse terms,

$o_i.m^t=x$5

and in the continuum the shear modulus becomes

$o_i.m^t=x$6

The paper shows that prestress can stiffen or soften moduli, shift vibrational frequencies, produce strong spatial heterogeneity in stress response unique to prestressed solids, generate a power-law distribution of minimal dipole stiffness, and require a new criterion to classify floppy modes (Zhang et al., 2021).

Across these mechanical examples, elastic memory is neither simple elasticity nor generic hysteresis. It is a persistent record encoded in constitutive branches, stored strain, or internal stress, yet still read out through nominally elastic or elastically recoverable response.

6. Cyclic training, disorder, and effective continuum analogies

A closely related body of work studies how elastic or elasto-plastic systems self-organize under repeated driving. For a driven elastic line in a periodic quenched landscape, memory is encoded in the geometrical and velocity profiles of the line. Repeated driving causes the line to forget its initial condition and converge to disorder-dependent limit cycles jointly for geometry and velocity, with forgetting strongly coupled to whether the dynamics are continuous or intermittent (Agoritsas et al., 2023). The result is an explicitly dynamical form of elastic memory: a repeatable orbit selected by disorder and drive, rather than a fixed static state.

The QMEP model of an amorphous solid under cyclic shear makes the same point in a yielding system. After oscillatory training, a readout protocol gives access to both the training amplitude and the last shear direction. The directional memory is attributed to a mechanically induced polarization, and despite quadrupolar elastic interactions the model exhibits behavior close to Return Point Memory, enabling a simple Preisach-like description of directional memory (Kumar et al., 2024). This is significant because it places quasi-RPM behavior in a disordered interacting medium that is not an ideal ferromagnetic Preisach system.

At the most formal end of the spectrum, Weyl–Cosserat elasticity reinterprets gravitational memory in vacuum general relativity as the topological charge of an effective dislocation field in spacetime. In that framework, ordinary displacement memory corresponds to an edge dislocation and spin memory to a screw-type defect, with the construction presented explicitly as an effective coarse-grained description rather than a modification of classical GR (Izabel, 3 May 2026). The paper extends the phrase “elastic memory” beyond matter to effective geometric media, but it preserves the same underlying theme: a transient disturbance leaves a permanent, structurally encoded remnant.

These usages clarify an important boundary condition. Elastic memory does not always mean that the same microscopic variable is written and read. In some works the memory is a managed resource; in others it is a compressed recurrent state; in others it is a constitutive branch structure, a prestress field, a trained limit cycle, or a defect charge. What unifies them is the replacement of static memory by memory whose operative content depends on adaptation, history, or both.