ActiveMem: Active Memory Control Paradigm

• ActiveMem is a paradigm where memory functions as an adaptive control system, actively deciding what to encode, retrieve, and update rather than passively storing data.
• It employs structured memory representations and distributed architectures to support long-horizon reasoning through explicit write control and semantic retrieval methods.
• Empirical studies show that ActiveMem frameworks boost task performance by dynamically managing memory retention, retrieval, and consolidation across diverse applications.

ActiveMem denotes a family of memory formulations in which memory is treated as an active control problem rather than a passive archive: the system decides what to encode, when to retrieve, how to organize stored state, and, in some settings, how to revise, suppress, or forget it. In the narrow sense, the name refers to the distributed framework introduced for long-horizon LLM reasoning, where a high-level Planner operates on distilled semantic gists while a lightweight memory system accumulates and consolidates those gists in parallel (Jiang et al., 9 Jun 2026). In a broader usage suggested by adjacent work, the same design impulse appears in memory-aware active learning, active extraction for long-term agent memory, execution-state memory for GUI agents, and topology-evolving lifelong memory banks (Ashari et al., 2019, Kang et al., 9 Apr 2026, Liu et al., 30 Jun 2026, Lv et al., 20 Mar 2026).

1. Terminological scope and development

One early precursor appears in "Mindful Active Learning" (Ashari et al., 2019), which formulates sample selection under human memory decay. There, query utility is not determined by informativeness alone; it is discounted by a retention term, with memory retention defined as $R_i = e^{-\Delta t_i / s}$, where $\Delta t_i$ is the lag between the event and the query and $s$ is memory strength. The EMMA objective multiplies entropy-based uncertainty by retention, so that old but informative samples may be rejected when recall is unreliable (Ashari et al., 2019). This is an active-memory principle in a strict sense: label acquisition is scheduled against a model of human forgetting.

By 2024, "AMEGO: Active Memory from long EGOcentric videos" (Goletto et al., 2024) had shifted the term toward persistent, queryable memory built from a single pass over a long stream. AMEGO constructs a memory $\mathcal{E} = \{\mathcal{O}, \mathcal{L}\}$ consisting of hand–object interaction tracklets and location segments, designed to answer later queries without reprocessing the raw video (Goletto et al., 2024). In 2026, the term broadens further across agent systems: "Active Task Driving Memory (ATMem)" recasts GUI memory as a continually updated execution state (Liu et al., 30 Jun 2026), "MemReader" turns memory extraction into an action space with add_memory, buffer_memory, search_memory, and ignore_memory (Kang et al., 9 Apr 2026), and "ActiveMem: Distributed Active Memory for Long-Horizon LLM Reasoning" formalizes a heterogeneous Planner–memory split for web-scale reasoning (Jiang et al., 9 Jun 2026). This suggests that ActiveMem is no longer only a storage abstraction; it is a broader paradigm for memory as an operational, adaptive layer.

2. Core operational principles

Across the literature, the most stable ActiveMem property is explicit write control. In MemReader-4B, the memory state is $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1})$, and the model follows a ReAct-style trajectory over the action space $$\mathcal{A} = \{add\_memory,\ buffer\_memory,\ search\_memory,\ ignore\_memory\}$$ (Kang et al., 9 Apr 2026). The system evaluates information value, ambiguity, and completeness before acting, so the decision to store is itself modeled as part of inference. AdaMem adopts a related position at longer timescales: it maintains a structured, role-specific Memory Policy $$\mathcal{P} = \{ C_1 : \mathcal{T}_1, \dots, C_n : \mathcal{T}_n \}$$, refines that policy from weekly QA feedback, and applies patch-style self-reflection with rollback (Chen et al., 19 Jun 2026). In MemCtrl, write control is reduced to a binary gate $b \in \{0,1\}$ predicted by a trainable memory head $\mu$, so that an embodied agent decides online whether a step should be retained or discarded (Dorbala et al., 28 Jan 2026).

A second recurring principle is that retrieval is no longer treated as pure similarity search. ActMem converts dialogue history into a causal–semantic knowledge graph $\mathcal{G} = (\mathcal{V}, \mathcal{E})$, then uses counterfactual reasoning and commonsense completion to retrieve semantically distant but causally relevant facts (Zhang et al., 4 Feb 2026). U-Mem uses semantic-aware Thompson sampling, with retrieval scores of the form

$\Delta t_i$0

where $\Delta t_i$1 is sampled from a Gaussian utility posterior for each memory (Wu et al., 25 Feb 2026). Taken together, these systems suggest that ActiveMem is defined less by any single storage substrate than by three coupled decisions: active encoding, structured retrieval, and explicit maintenance.

3. Memory representations

Different ActiveMem systems choose different memory units, but nearly all replace flat conversation logs with typed, task-specific structures.

System	Memory unit	Active mechanism
EMMA (Ashari et al., 2019)	Sensor observation $\Delta t_i$2 with retention $\Delta t_i$3	Budgeted query selection under memory decay
AMEGO (Goletto et al., 2024)	HOI tracklets $\Delta t_i$4 and location segments $\Delta t_i$5	Single-pass construction of semantic-free episodic memory
ATMem (Liu et al., 30 Jun 2026)	JSON execution state with phase, context, schema, items	Per-item status updates: remaining, finished, skipped
AtomMem (Yao et al., 18 Jun 2026)	Atomic facts, events, temporal profiles	Hybrid retrieval plus associative memory graph
All-Mem (Lv et al., 20 Mar 2026)	Node $\Delta t_i$6	Visible surface plus SPLIT/MERGE/UPDATE
ActiveMem (Jiang et al., 9 Jun 2026)	Query-conditioned gist $\Delta t_i$7 in shard entry $\Delta t_i$8	Distributed memorization, reuse, and consolidation

These representations are not interchangeable. EMMA models memory reliability as a probability of correct recall, suitable for human-oracle annotation (Ashari et al., 2019). AMEGO stores visual tracklets and segments because the downstream task is sequencing, concurrency, and temporal grounding over egocentric video (Goletto et al., 2024). ATMem stores task-relevant data items plus workflow status because retrieval alone does not tell a GUI agent whether a value has already been used or remains pending (Liu et al., 30 Jun 2026). AtomMem decomposes long-form interactions into atomic facts

$\Delta t_i$9

then layers events, temporal profiles, and an associative graph on top (Yao et al., 18 Jun 2026). All-Mem adds typed links—temporal, semantic, version, and sibling edges—to support bounded, recoverable expansion from a curated visible surface (Lv et al., 20 Mar 2026). This suggests that in ActiveMem systems the memory unit is chosen to match the dominant failure mode: misremembered labels, lost temporal structure, execution-state ambiguity, profile drift, or long-horizon evidence fragmentation.

4. Distributed ActiveMem for long-horizon LLM reasoning

The 2026 ActiveMem framework is the most explicit attempt to decouple memory from reasoning in long-horizon web agents (Jiang et al., 9 Jun 2026). It draws on an analogy between prefrontal executive control and hippocampal memory management, arguing that the usual trade-off between context overload and irreversible pruning is largely a by-product of centralized memory organization (Jiang et al., 9 Jun 2026). The Planner state is

$s$0

where $s$1 is the original question, $s$2 is a trimmed interaction history, and $s$3 is the distilled memory returned at the previous step. Rather than reading raw documents directly, the Planner emits a set of retrieval queries

$s$4

or terminates with submit_answer(a) (Jiang et al., 9 Jun 2026).

The memory side is distributed across Memorizers, Memory Shards, and an Operator. For a query $s$5 and document $s$6, a Memorizer produces a query-conditioned gist

$s$7

returning either a short relevant summary or NONE (Jiang et al., 9 Jun 2026). Each shard stores document-specific entries of the form

$s$8

where $s$9 is the set of prior Planner queries that have used that document (Jiang et al., 9 Jun 2026). When a document is revisited, the Operator invokes a Similarity Judge $\mathcal{E} = \{\mathcal{O}, \mathcal{L}\}$0 that returns SIMILAR or NEW. A SIMILAR verdict triggers direct gist reuse; a NEW verdict triggers re-distillation followed by asynchronous consolidation into an updated shard entry (Jiang et al., 9 Jun 2026). Because consolidation is document-specific and shard-local, the system can preserve multiple query views without forcing them into a single monolithic context.

This architecture changes the cost profile of long-horizon reasoning. The Planner keeps only the last $\mathcal{E} = \{\mathcal{O}, \mathcal{L}\}$1 interaction steps, with $\mathcal{E} = \{\mathcal{O}, \mathcal{L}\}$2 in the main configuration, while most raw tokens are processed by 4B-scale Memorizers and 4B Operator models rather than by the large Planner (Jiang et al., 9 Jun 2026). The implementation uses 16 shards, a Qwen3.5-397B-A17B Planner, a Qwen3-Embedding-8B retriever, and a Memorizer-4B trained by SFT on about 12,000 $\mathcal{E} = \{\mathcal{O}, \mathcal{L}\}$3 triples distilled from BrowseComp-Plus trajectories (Jiang et al., 9 Jun 2026). The paper’s central claim is therefore architectural rather than merely algorithmic: planning should operate over distilled gists, while memory accumulation and consolidation should occur in parallel, outside the core reasoning context.

5. Empirical behavior

On BrowseComp-Plus, ActiveMem achieves a LasJ score of 0.79, 2,145 PFLOPs, and an ACT score of 0.785; on GAIA WebSearch it reaches 0.62 LasJ, 187 PFLOPs, and 0.620 ACT (Jiang et al., 9 Jun 2026). The gains are concentrated on harder long-horizon cases: on BrowseComp-Plus medium questions it reports 0.94 LasJ versus 0.84 for Context-Folding, and on hard questions 0.44 versus 0.36 (Jiang et al., 9 Jun 2026). Ablations support the role of distributed persistence and consolidation. Removing Memory Shards drops LasJ from 0.786 to 0.750, removing consolidation drops it to 0.720, and using the SFT-trained Memorizer-4B outperforms both an instruction-tuned 4B memorizer and a vanilla “thinking” 4B variant (Jiang et al., 9 Jun 2026).

Related ActiveMem-style systems show similar gains in other regimes. EMMA raises activity-recognition accuracy by an average of 13.5% over entropy-only active learning and can reach 21% to 97% accuracy depending on memory strength, query budget, and task difficulty (Ashari et al., 2019). AdaMem improves QA accuracy by up to +9.0% over the uniform Mem0 baseline while shrinking memory volume by 9% (Chen et al., 19 Jun 2026). ATMem-UI 8B reaches 76.6% success rate on AndroidWorld and 23.3% on MobileWorld, while remaining best among end-to-end agents on DataScope across terminal success, app-level progress, and scope-aware F1 (Liu et al., 30 Jun 2026). MemCtrl reports around 16% average improvement in embodied task completion ability, with over 20% on specific instruction subsets (Dorbala et al., 28 Jan 2026). AutoMem reports that optimizing memory alone improves the base agent’s performance ~2x-4x on Crafter, MiniHack, and NetHack (Wu et al., 1 Jul 2026). SwiftMem shows that query-aware indexing can achieve 47× faster search while maintaining competitive accuracy on long-memory benchmarks (Tian et al., 13 Jan 2026). The empirical pattern is consistent: once memory becomes an explicit decision layer rather than a passive store, both effectiveness and efficiency can improve, although the exact trade-off depends on the task.

6. Governance, limitations, and open directions

The literature is equally clear that active memory does not automatically imply reliable memory governance. GateMem, which evaluates utility, access control, and active forgetting in multi-principal shared-memory agents, finds that no method simultaneously achieves strong utility, robust access control, and reliable forgetting; long-context prompting often yields the best governance score at high token cost, while retrieval-based and external-memory methods still leak unauthorized or deleted information (Ren et al., 17 Jun 2026). ActMem improves QA on logic-driven memory tasks by moving from similarity retrieval to causal reasoning, but it remains text-only and can suffer error propagation from graph construction (Zhang et al., 4 Feb 2026). The distributed ActiveMem framework reports PFLOPs rather than wall-clock latency and leaves the cross-domain generalizability of the Memorizer as an open issue (Jiang et al., 9 Jun 2026). All-Mem, despite strong retrieval and QA results, still depends on the reliability of an LLM diagnoser for SPLIT, MERGE, and UPDATE proposals, and identifies noisy histories and domain shifts as remaining challenges (Lv et al., 20 Mar 2026).

Open directions are correspondingly diverse. "Mindful Active Learning" explicitly points toward real-time, context-sensitive active learning and user studies with cognitively impaired patients (Ashari et al., 2019). AdaMem identifies better preference inference from weaker signals and richer policy representations as bottlenecks (Chen et al., 19 Jun 2026). GateMem makes explicit deletion semantics and policy-aware retrieval unavoidable for institutional deployment (Ren et al., 17 Jun 2026). ActMem points toward multimodal extensions and more explicit causal modeling (Zhang et al., 4 Feb 2026). A plausible synthesis is that ActiveMem is evolving toward a governed, trainable, task-specific control layer: one that not only retrieves relevant context, but also learns the operative granularity of memory, constrains access, tracks revision lineage, and decides when a memory operation is worth performing at all.