Unified Memory Agent (UMA) Overview

• UMA is a unified memory agent that integrates short-term and long-term memory operations into a single policy, improving long-horizon reasoning.
• It employs reinforcement learning and cost-aware optimization with dynamic memory tools (Add, Update, Retrieve) to manage in-context and persistent memory.
• Empirical evaluations show UMA enhances performance on tasks like HotpotQA and ALFWorld by addressing limitations in passive long-context processing.

Unified Memory Agent (UMA) denotes a family of memory-centric agent architectures in which memory is treated as a first-class, unified substrate rather than as an external heuristic add-on. In recent large-language-model research, the term is used both as a general concept and as the name of specific systems: an agent may unify long-term and short-term memory operations inside a single policy, unify memory maintenance and question answering in one reinforcement-learned controller, or unify memory acquisition, validation, retrieval, and curation under explicit cost constraints without changing model weights (Wu et al., 25 Feb 2026, Zhang et al., 13 Feb 2026, Yu et al., 5 Jan 2026). Across these usages, the central claim is consistent: finite context windows and long-horizon task structure make passive long-context processing and query-time retrieval alone brittle, so memory must become an active part of the agent’s decision process (Yu et al., 5 Jan 2026, Zhang et al., 13 Feb 2026).

1. Conceptual Definition and Scope

In the autonomous memory-agent literature, UMA refers to an agent that “treats memory as a first-class, unified substrate for improving task performance without changing model weights,” and to architectures that expose memory operations as intrinsic parts of inference rather than as separate controllers or trigger-based pipelines (Wu et al., 25 Feb 2026). The immediate motivation is that LLM agents face “fundamental limitations in long-horizon reasoning due to finite context windows,” while prior systems often separate persistent long-term memory (LTM) from transient short-term memory (STM), thereby imposing predefined schedules, heuristics, and fragmented optimization (Yu et al., 5 Jan 2026).

A recurrent misconception is to equate UMA with retrieval-augmented generation. The recent agent-memory papers distinguish the two sharply. In the end-to-end RL formulation called UMA, passive long-context models repeatedly reprocess raw text, and standard RAG defers state tracking, contradiction resolution, and evidence aggregation to query time; this becomes brittle when answers are latent values derived from accumulated updates rather than local spans (Zhang et al., 13 Feb 2026). A related misconception is that unified memory implies a single storage format. In practice, the literature uses several memory abstractions—core summaries, key–value banks, procedural/corrective/preference stores, graph structures, and organization-scoped governed records—while retaining the same design principle: memory is part of the agent’s operational state and policy rather than a passive archive (Wu et al., 25 Feb 2026, Zhang et al., 13 Feb 2026).

A compact way to organize the main contemporary uses is as follows:

Usage	Representative paper	Characterization
Unified memory as policy-level LTM+STM control	"Agentic Memory: Learning Unified Long-Term and Short-Term Memory Management for LLM Agents" (Yu et al., 5 Jan 2026)	Add, Update, Delete, Retrieve, Summary, Filter are first-class actions
Unified memory as end-to-end memory-and-QA RL	"Learning to Remember: End-to-End Training of Memory Agents for Long-Context Reasoning" (Zhang et al., 13 Feb 2026)	One policy maintains memory during streaming and answers later queries
Unified memory as autonomous cost-aware improvement	"Towards Autonomous Memory Agents" (Wu et al., 25 Feb 2026)	Frozen backbone plus dynamic memory store, cost-aware acquisition and curation
Unified extraction and management	"UMEM: Unified Memory Extraction and Management Framework for Generalizable Memory" (Ye et al., 11 Feb 2026)	Memory extraction and management are jointly optimized

2. Architectural Patterns

A defining architectural move in UMA systems is to place memory directly inside the state seen by the policy. In AgeMem, the unified RL state is $s_t = (C_t, \mathcal{M}_t, \mathcal{T})$, where $C_t$ is STM, $\mathcal{M}_t$ is LTM, and $\mathcal{T}$ contains the task specification; the policy is $\pi_\theta(a_t \mid s_t) = P(a_t \mid s_t; \theta)$, and $a_t$ may be either language generation or a tool-based memory operation (Yu et al., 5 Jan 2026). The LTM tools are Add, Update, and Delete; the STM tools are Retrieve, Summary, and Filter. This converts memory control from external heuristics into learned first-class actions.

The end-to-end RL UMA adopts a different but closely related dual-memory representation. Its state is $s_t = (M_t, x_t, h_t)$, where the memory itself is split into a compact core summary $m_t^{core}$ and a structured Memory Bank $\mathcal{B}_t$ of key–value entries. The policy interleaves Phase I sequential memory maintenance over chunks and Phase II hybrid retrieval-augmented question answering, using Add, Update, Delete, Retrieve, List, UpdateCore, BM25, Embedding, and Answer as actions (Zhang et al., 13 Feb 2026). This design makes proactive consolidation explicit: the core summary preserves global context, while the bank preserves structured entries needed for precise computation and contradiction resolution.

U-Mem instantiates UMA under a frozen LLM backbone $\theta$ and a dynamic memory store $C_t$0, with state $C_t$1. Its Retrieve–Infer–Evolve loop is not organized around gradient updates to the backbone, but around memory evolution: retrieval $C_t$2, inference $C_t$3, feedback $C_t$4, and memory evolution $C_t$5 (Wu et al., 25 Feb 2026). Its memory store is typed rather than monolithic: Global Procedural Memory, Local Corrective Memory, and Preference Memory.

UMEM pushes unification one step further by treating the memory bank $C_t$6 as the agent’s effective trainable parameters. A frozen executor solves tasks using retrieved memory, while a separate learned Mem-Optimizer jointly decides what reusable memory to distill and whether to ADD or UPDATE it (Ye et al., 11 Feb 2026). This suggests a broader architectural thesis: UMA is not defined by one canonical data structure, but by co-locating memory representation, memory evolution, and task control inside a unified decision loop.

3. Learning, Credit Assignment, and Retrieval Policies

The major methodological divergence inside the UMA literature concerns how unified memory behavior is learned. AgeMem uses a three-stage progressive reinforcement learning strategy: Stage 1 constructs LTM, Stage 2 learns STM control under distractors, and Stage 3 performs integrated reasoning and memory coordination. It introduces step-wise GRPO for sparse and discontinuous memory rewards, broadcasting group-normalized terminal advantages to all timesteps so that delayed task outcomes are attributed to earlier memory actions across stages (Yu et al., 5 Jan 2026). Its objective is written over trajectories $C_t$7 with cumulative reward

$C_t$8

and optimized through

$C_t$9

The end-to-end RL UMA also adopts GRPO, but stratifies credit between memory-maintenance and question-answering phases. Training first samples memory rollouts, then evaluates the resulting memory states across multiple future queries. Memory actions receive delayed credit through the average of subsequent QA rewards, formalized by a memory-side advantage

$\mathcal{M}_t$0

while QA rollouts receive per-question normalized advantages. The resulting clipped objective with KL regularization couples memory and answer generation without using a learned value function (Zhang et al., 13 Feb 2026). A plausible implication is that the key novelty is not GRPO in isolation, but the use of task-stratified normalization to prevent long-horizon credit dilution.

U-Mem replaces RL-style end-to-end policy tuning with a cost-aware optimization over retrieval policy $\mathcal{M}_t$1, extraction policy $\mathcal{M}_t$2, and supervision escalation levels $\mathcal{M}_t$3. Its deployment objective is

$\mathcal{M}_t$4

subject to a budget constraint $\mathcal{M}_t$5 (Wu et al., 25 Feb 2026). Its retriever, Semantic-Aware Thompson Sampling, combines semantic similarity with stochastic utility posteriors,

$\mathcal{M}_t$6

thereby addressing cold-start bias and exploration–exploitation trade-offs.

UMEM, by contrast, argues that optimizing memory management while keeping extraction static causes instance-specific noise accumulation. It introduces Semantic Neighborhood Modeling, builds $\mathcal{M}_t$7 from Top-$\mathcal{M}_t$8 nearest neighbors in embedding space, and defines memory utility over neighborhoods rather than single instances. Its reward is

$\mathcal{M}_t$9

where $\mathcal{T}$0 is a neighborhood-level marginal utility term and $\mathcal{T}$1 enforces strict XML schema (Ye et al., 11 Feb 2026). This suggests an internal split within the UMA tradition: one line emphasizes long-horizon credit assignment over tool actions, while another emphasizes generalization pressure on the memories being written.

4. Empirical Performance and Evaluation

The empirical literature evaluates UMA-like systems on markedly different task families, but a shared pattern recurs: unified memory tends to help most on long-horizon, dynamic, or interdependent tasks. AgeMem reports results on five long-horizon benchmarks—ALFWorld, SciWorld, PDDL, BabyAI, and HotpotQA—using Qwen2.5-7B-Instruct and Qwen3-4B-Instruct. For Qwen2.5-7B-Instruct, AgeMem reaches an average of 41.96 versus No-Memory 28.05 and versus best baseline Mem0 37.14; for Qwen3-4B-Instruct, it reaches 54.31 versus No-Memory 43.97 and versus A-Mem 45.74. On HotpotQA, Memory Quality is 0.533 for Qwen2.5-7B and 0.605 for Qwen3-4B, and STM efficiency shows reduced average prompt tokens versus RAG variants: 2,117 vs 2,186 for Qwen2.5-7B and 2,191 vs 2,310 for Qwen3-4B (Yu et al., 5 Jan 2026).

The end-to-end RL UMA evaluates across 13 datasets spanning Ledger-QA, Test-Time Learning, and Accurate Retrieval, and reports an average Accuracy of 77.36%. On Ledger-QA, its accuracy across session counts $\mathcal{T}$2 is 90.38, 78.95, 88.89, 64.44, 68.18, 66.67, and 53.33, compared with RAG’s 75.00, 36.84, 31.11, 26.67, 18.18, 15.56, and 17.78. Its ablations are unusually direct: w/o Phase I gives 63.81%, w/o RL gives 61.38%, Global Group gives 73.58%, and Two Stage gives 66.29%, all below the full model (Zhang et al., 13 Feb 2026).

U-Mem evaluates on both verifiable and non-verifiable tasks. On HotpotQA with Qwen2.5-7B, No Memory is 37.80% and U-Mem is 52.40%, surpassing ReasoningBank at 46.40%, ReMe at 44.20%, MemRL at 47.80%, and the RL-based GRPO baseline at 46.60%. On AIME25 with Gemini-2.5-flash, it improves from 46.67% to 54.00%; on HotpotQA with Gemini-2.5-flash, from 62.40% to 71.60%. In a HotpotQA ablation, “Always Expert” reaches 52.80%, while U-Mem retains 99.2% of this while using expert in 23.17% of cases (Wu et al., 25 Feb 2026).

UMEM reports gains across AIME, GPQA-Diamond, HLE, HotpotQA, and ALFWorld. The paper states “up to a 10.67% improvement in multi-turn interactive tasks,” and, with GPT-5.1 as executor, reports ALFWorld SR 82.84 and PR 84.20 for UMEM-Qwen3-4B, with average 57.74 versus Qwen3-4B baseline average 53.18. It also reports that removing Semantic Neighborhood Modeling drops AIME with GPT-5.1 from 51.67 to 41.67 (Ye et al., 11 Feb 2026).

MemoryArena, although not itself a UMA method, is significant because it evaluates persistent memory in multi-session Memory-Agent-Environment loops with explicitly interdependent subtasks. Its results show that agents with near-saturated performance on benchmarks such as LoCoMo perform poorly in this agentic setting. For example, GPT-5.1-mini long-context on Bundled Web Shopping achieves SR about 1% and PS about 58%, while Group Travel Planning remains near zero SR across methods; the benchmark therefore exposes a gap between memorization-oriented evaluation and memory-guided action (He et al., 18 Feb 2026).

5. Ecosystem Extensions and Production Interpretations

Several contemporaneous works broaden UMA from an algorithmic controller into an infrastructure concept. Governed Memory is described as “precisely the infrastructure that would realize UMA in practice”: a shared memory and governance layer for multi-agent workflows built from a dual memory model, tiered governance routing with progressive context delivery, reflection-bounded retrieval with entity-scoped isolation, and a closed-loop schema lifecycle. Its controlled experiments report 99.6% fact recall, 92% governance routing precision, 50.3% total token savings over a five-step mixed-domain workflow, zero true cross-entity leakage across 3,800 results, and 74.8% overall accuracy on LoCoMo (Taheri, 18 Mar 2026).

MemTrust addresses the same unification problem under a security lens. It abstracts unified AI memory into five layers—Storage, Extraction, Learning, Retrieval, and Governance—and places each under TEE protection, with RA-TLS, attestation-bound tokens, side-channel hardened retrieval, and cryptographic erasure via per-memory-unit destruction keys. This frames UMA as a zero-trust “Context Hub” rather than only as a learning algorithm (Zhou et al., 11 Jan 2026).

Mandol recasts the problem as representation and retrieval unification for long-term conversational agents. It uses a hierarchical memory model, an agglomerative semantic data structure combining SemanticMap and SemanticGraph, and a quantitative query mechanism with query-adaptive routing, denoising, conflict resolution, and token-constrained context generation “without involving LLMs during retrieval.” On LoCoMo it reports 89.48% with GPT-4o-mini and 92.21% with GPT-4.1-mini; on LongMemEval it reports 85.00% and 88.40%, respectively, together with a 5.4x retrieval speedup and a 4.8x insertion speedup under 10 QPS concurrent load (Zhang et al., 29 Jun 2026).

Other works extend the unification axis in different directions. MemFactory provides a unified, modular training and inference framework for memory-augmented agents, with out-of-the-box support for Memory-R1, RMM, and MemAgent and relative gains up to 14.8% on MemAgent-style evaluations (Guo et al., 31 Mar 2026). MemAdapter targets cross-paradigm retrieval unification by aligning explicit, parametric, and latent memories into a shared space of dimension 1536, completing cross-paradigm alignment within 13 minutes on a single GPU and outperforming five memory systems across three paradigms (Zhang et al., 9 Feb 2026). The survey on graph-based agent memory does not use the term UMA, but it provides a taxonomy in which unified memory would integrate short-term and long-term memory, knowledge and experience memory, and structural and non-structural stores inside a single lifecycle of Write, Read, Update, and Delete (Yang et al., 5 Feb 2026).

6. Foundations, Ambiguities, and Non-Agent Uses

The acronym UMA is historically overloaded. In "Universal Memory Architectures for Autonomous Machines" the term refers not to large-language-model agents but to a self-organizing memory architecture for a discrete binary agent operating over a finite Boolean sensorium. Its core objects are snapshots, weak poc sets, and the dual CAT(0) cube complex; its central guarantees include $\mathcal{T}$3 space and update/execute time, minimal internal representation among all models consistent with the current implication record, and learnability with arbitrary precision under random action in finite connected environments (Guralnik et al., 2015). This older usage is conceptually related through its emphasis on unified internal representation, but it is mathematically and historically distinct from contemporary LLM-agent UMA.

A further source of confusion is hardware literature. In the Grace Hopper paper, UMA denotes a unified memory system realized by a single integrated CPU-GPU system page table, hardware ATS, and cache-coherent NVLink-C2C, not an agent (Schieffer et al., 2024). In the PIUMA paper, UMA means Unified Memory Architecture inside a distributed global address space for large-scale graph analytics; the paper explicitly states that it does not define any component called a “Unified Memory Agent” (Aananthakrishnan et al., 2020). These systems share only the general idea of collapsing fragmented memory substrates into a unified one.

Within the agent literature itself, the term remains plural rather than standardized. Some papers reserve UMA for an end-to-end RL framework with a core summary plus Memory Bank (Zhang et al., 13 Feb 2026); some use it as a design principle instantiated concretely by U-Mem (Wu et al., 25 Feb 2026); some describe AgeMem as operationalizing the “UMA principle” by turning LTM and STM operations into tool-based actions inside the policy (Yu et al., 5 Jan 2026); and some treat UMEM as a unified memory agent because extraction and management are jointly optimized (Ye et al., 11 Feb 2026). The clearest common denominator is therefore not a fixed architecture, but a research program: memory is promoted from passive storage to an actively managed, unified control surface for long-horizon agents.