Semantic Memory Management Unit (S-MMU)

• S-MMU is a memory-optimization construct that integrates extraction and management to encode, update, and generalize interaction traces into persistent semantic memories.
• Its UMEM instantiation jointly trains a Memory Extraction Unit and a Memory Management Unit, leading to measurable improvements in metrics like CSR and EM accuracy.
• An alternative approach, as seen in Sparsey, uses emergent sparse distributed representations to create semantic memory without explicit extraction-management policies.

Searching arXiv for the cited papers to ground the article. Semantic Memory Management Unit (S-MMU) denotes a memory-optimization construct for systems that must convert interaction traces into reusable semantic content while maintaining an external memory store. In the UMEM framework, S-MMU is instantiated as the jointly trained Memory-Optimizer that tightly couples memory extraction and memory management between a frozen Executor $E$ and an external Memory Bank $B$ (Ye et al., 11 Feb 2026). In a distinct but conceptually related usage, Sparsey can also be cast as an S-MMU, where semantic memory emerges from the superposition of episodic traces stored in sparse distributed representations rather than from a separately optimized extraction-and-management policy (Rinkus et al., 2017). Across these formulations, S-MMU refers not to a single canonical architecture but to a functional role: regulating how experience is encoded, updated, and generalized into persistent memory.

1. Conceptual scope and definitional variants

In UMEM, S-MMU is defined as the jointly trained Memory-Optimizer module whose purpose is to couple two operations that are often decoupled in LLM-agent memory systems: extracting a concise memory from an interaction trace and deciding how that memory should modify the memory bank (Ye et al., 11 Feb 2026). Its two sub-modules are the Memory Extraction Unit (MEU), which takes a new interaction trace $T_q$ and distills a concise, generalizable memory entry $A$, and the Memory Management Unit (MMU), which takes $A$ plus metadata and selects a memory operation $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$ to apply to $B$. The operational pipeline is given as: query $q \rightarrow$ retrieve Top-$K$ from $B \rightarrow$ Executor $B$0 yields trajectory $B$1 MEU distills $B$2 MMU chooses $B$3 memory bank $B$4 next query.

This formulation is motivated by a specific failure mode: existing methods predominately optimize memory management while treating memory extraction as a static process, resulting in poor generalization, where agents accumulate instance-specific noise rather than robust memories (Ye et al., 11 Feb 2026). S-MMU therefore names the mechanism that turns memory formation into a joint optimization problem.

Sparsey presents a different interpretation. There, S-MMU is not a policy module inserted between an executor and an external symbolic bank, but a hierarchical associative memory model in which semantic memory arises as a side effect of storing episodic traces in superposed sparse distributed representations (Rinkus et al., 2017). The model uses levels $B$5, with $B$6 as binary-pixel input and higher levels organized into 2-D arrays of macs, each containing $B$7 competitive modules with $B$8 binary neurons. A mac’s code $B$9 consists of exactly one winner per competitive module, so $T_q$0. In this sense, Sparsey treats semantic memory management as an emergent property of continual single-trial storage rather than as an explicit action-selection process.

A plausible implication is that “S-MMU” functions best as a systems-level category rather than a single algorithmic recipe. In one line of work it denotes a trainable controller over an explicit bank; in another it denotes a distributed representational substrate whose update rules induce semantic structure automatically.

2. Architectural organization in UMEM

The UMEM instantiation places S-MMU between a frozen Executor $T_q$1 and an external Memory Bank $T_q$2 (Ye et al., 11 Feb 2026). The Executor serves as the LLM inference engine. The external bank stores accumulated memories. S-MMU mediates between execution and persistent storage by observing the resulting trajectory and deciding what durable memory should be created or revised.

The MEU is responsible for transforming the trajectory $T_q$3 into a concise memory entry $T_q$4, described as “a rule or strategy” in structured form. The MMU then takes the extracted $T_q$5 together with metadata and selects a memory operation. The available operations are explicitly described as including $T_q$6 and $T_q$7. The update is then committed by $T_q$8.

The online loop is defined procedurally. The system initializes with $T_q$9 and initializes S-MMU policy parameters $A$0. It precomputes $A$1 for all training queries via cosine embeddings. During each training step, it samples a batch of queries, retrieves $A$2 for each query, executes the query with the Executor, samples $A$3 candidate actions from the policy, evaluates each action using a reward that combines a format check and neighborhood-level utility, updates $A$4 using Group Relative Policy Optimization (GRPO), and finally commits the best-scoring action to the memory bank (Ye et al., 11 Feb 2026).

This design makes extraction and management inseparable during optimization. Rather than assuming that memory content is already correct and optimizing only the bookkeeping around it, UMEM trains the production of the memory entry and the decision to store or revise it under a common reward signal. This suggests that the system treats memory quality as inseparable from memory operations.

3. Semantic Neighborhood Modeling and neighborhood-level utility

A central mechanism in UMEM is Semantic Neighborhood Modeling (SNM), introduced to mitigate overfitting to specific instances (Ye et al., 11 Feb 2026). For a query $A$5, its semantic neighborhood is defined over a precomputed corpus $A$6 using a fixed encoder $A$7 with $A$8-normalized embeddings. The neighborhood is

$A$9

An equivalent formulation is provided as

$A$0

with

$A$1

During training, any candidate memory update is evaluated not only on the source query $A$2 but averaged over all $A$3. This discourages instance-specific noise by rewarding memories that transfer across semantically related queries.

The practical example supplied for semantic neighborhoods is algebraic. For the query “Solve $A$4, $A$5”, the Top-3 neighbors might be “Given $A$6, $A$7”, “Solve $A$8, $A$9”, and “Find $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$0, $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$1”. A candidate memory such as “When $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$2 and $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$3, solve via $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$4, $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$5” is then scored on all three neighbors rather than on the source query alone (Ye et al., 11 Feb 2026).

This mechanism operationalizes semantic generalization by replacing pointwise reward with cluster-level evaluation. A plausible implication is that SNM converts memory learning from a local trace-compression problem into a neighborhood-consistency problem.

4. Reward design and policy optimization

UMEM defines a marginal utility reward for each sampled memory action $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$6, where an action consists of the pair $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$7 (Ye et al., 11 Feb 2026). For each neighbor $$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$8, two terms are computed.

The first is Success Gain:

$$\mathrm{opt}\in\{\mathrm{ADD},\mathrm{UPDATE},\ldots\}$$9

where $B$0 is correctness after applying the action and $B$1 is correctness under the reference memory bank with no update.

The second is Efficiency Regularization:

$B$2

where $B$3 and $B$4 are the token lengths of the reasoning trajectories before and after applying the action. The gating term $B$5 ensures that brevity is rewarded only when accuracy is preserved.

The per-neighbor marginal utility is

$B$6

and the group reward is averaged over the neighborhood:

$B$7

A small format-check bonus $B$8 is added to obtain the final reward,

$B$9

The joint training objective maximizes the expected marginal utility over the training set $q \rightarrow$0:

$q \rightarrow$1

where $q \rightarrow$2 is a small weight for the schema-format reward. The optimization is performed by Group Relative Policy Optimization without a value critic (Ye et al., 11 Feb 2026).

The pseudocode further specifies that group advantage is computed as

$q \rightarrow$3

and $q \rightarrow$4 is updated by maximizing $q \rightarrow$5. After policy update, the committed memory operation is the action with maximal reward for that query instance.

This reward design makes generalization measurable at training time. Rather than labeling a memory entry as intrinsically good, the framework defines goodness as marginal utility over a semantic neighborhood, with accuracy and trajectory compression jointly represented.

5. Monotonic growth and continual self-evolution

The UMEM formulation imposes a monotonic memory growth property by design: S-MMU never deletes entries and performs only $q \rightarrow$6 or $q \rightarrow$7 operations, so

$q \rightarrow$8

The empirical consequence is described as a strictly non-decreasing curve when plotting $q \rightarrow$9 against interaction step $K$0 (Ye et al., 11 Feb 2026). The stated rationale is that experience accumulates rather than vanishes, while $K$1 operations keep the size in check by replacing rather than blindly duplicating entries.

In continual self-evolution over 10 epochs on ALFWorld, UMEM is reported to achieve a steadily rising CSR curve, whereas competitors plateau or degrade, which is presented as confirmation of stable long-term memory growth and low error accumulation (Ye et al., 11 Feb 2026). The abstract likewise states that UMEM maintains a monotonic growth curve during continuous evolution.

This design directly addresses a common concern in self-updating agent memory: that online adaptation can introduce regressions, overwrite useful abstractions, or amplify noise. Here the proposed answer is not deletion or periodic reset, but neighborhood-evaluated updates combined with non-decreasing bank growth. This suggests a specific interpretation of “memory management” in S-MMU: management is not synonymous with aggressive pruning, but with controlled accumulation under a utility criterion.

6. Evaluation benchmarks and reported performance

UMEM is evaluated with Exact Match (EM) accuracy on single-turn reasoning tasks and with Cumulative Success Rate (CSR) and Progress Rate (PR) on multi-turn embodied tasks (Ye et al., 11 Feb 2026). The single-turn EM benchmarks are AIME, GPQA-Diamond, HLE, and HotpotQA. The multi-turn benchmark is ALFWorld.

The reported gains are summarized below.

Setting	Baseline	UMEM
ALFWorld CSR	61.11 %	71.78 %
AIME	51.67 %	58.33 %
GPQA-Diamond	52.53 %	65.15 %

For ALFWorld, the no-memory CSR of $K$2 increases to UMEM CSR of $K$3, a gain of $K$4 percentage points (Ye et al., 11 Feb 2026). For AIME, the baseline of $K$5 increases to UMEM (Qwen 4 B) at $K$6, a gain of $K$7 percentage points. For GPQA-Diamond, the baseline of $K$8 increases to UMEM at $K$9, a gain of $B \rightarrow$0 percentage points. Across five benchmarks and three executor LLMs—Qwen 8B, GPT-5.1, and Gemini-2.5—UMEM is reported to uniformly outperform ReMem, Memp, and non-learning baselines by $B \rightarrow$1–$B \rightarrow$2 percentage points.

These results are specifically framed as evidence that joint optimization of extraction and management improves generalizable memory. The benchmark mix is notable: it spans single-turn reasoning and multi-turn interactive planning, which suggests that the S-MMU concept is intended to be agnostic to whether memory utility is expressed as answer accuracy or embodied task progress.

7. Relation to Sparsey and alternative interpretations of semantic memory management

Sparsey offers a markedly different but technically relevant interpretation of S-MMU (Rinkus et al., 2017). The model is hierarchical, unsupervised, and based on sparse distributed representations (SDRs). Each mac contains $B \rightarrow$3 competitive modules with $B \rightarrow$4 binary neurons, and the code space per mac is $B \rightarrow$5. The local sparsity is $B \rightarrow$6, since each mac activates exactly one neuron per competitive module.

Its core per-mac data structures are a bottom-up weight matrix $B \rightarrow$7, a lateral matrix $B \rightarrow$8, and a top-down matrix $B \rightarrow$9, all initialized to zero and represented with low precision. Encoding uses the Code Selection Algorithm (CSA), which computes bottom-up, horizontal, and top-down input potentials; forms a familiarity metric

$B$00

with $B$01; and then modulates winner selection according to whether the input is familiar enough for code completion or novel enough for code separation. All steps are $B$02 per mac and are independent of how many codes are already stored.

Learning is single-trial and Hebbian. After code selection, the synapses associated with active co-occurrences in $B$03, $B$04, and $B$05 are set to $B$06 or incremented by $B$07. No iterative weight descent is used; a single co-activation sets a synapse and it never decays. Because codes are stored in superposition, semantic memory is described as emerging computationally for free from episodic storage. Similarity in code space is measured by

$B$08

and this overlap monotonically tracks input-space similarity by construction of the CSA (Rinkus et al., 2017).

Sparsey also makes explicit complexity and systems claims. The three primitive S-MMU-style calls are write$B$09, read$B$10, and update$B$11, with total time complexity $B$12 for $B$13 total macs, independent of the number of stored items. Reported empirical figures include training on MNIST with 200 samples per class in 220 s on one CPU with approximately 90% accuracy, scaling to 800 per class with 89% accuracy in 25 min, and Weizmann Video training in approximately 210 s with 67% leave-one-actor-out accuracy after SVM readout on final-frame codes (Rinkus et al., 2017).

The contrast with UMEM is structurally instructive. UMEM treats semantic memory management as a learned policy over an external bank, evaluated through neighborhood-level utility. Sparsey treats it as the representational consequence of superposed SDR storage and constant-time retrieval. This suggests two distinct research programs under the same broad label: one centered on explicit memory actions for LLM agents, the other on distributed associative coding in hierarchical memory systems.