Darwinian Memory System (DMS)

• Darwinian Memory System (DMS) is a self-regulating memory architecture for GUI agents that adaptively reuses, mutates, and prunes sub-tasks based on success.
• It employs a dual-factor retrieval mechanism to match both preconditions and goals, reducing context pollution and ensuring task-specific memory relevance.
• DMS improves long-horizon task execution by boosting success rates and lowering latency, as demonstrated by significant gains in AndroidWorld benchmarks.

Darwinian Memory System (DMS) denotes a training-free, self-regulating memory architecture for GUI agents, proposed for multimodal LLM agents operating in long-horizon, cross-application workflows. In this formulation, memory is not a static archive but a dynamic ecosystem governed by the law of survival of the fittest: successful sub-task executions become reusable memory units, poor or risky memories are penalized, obsolete memories are pruned, and occasional mutation re-solves a sub-task from scratch in search of a superior trajectory. The architecture is designed to improve general-purpose MLLMs without additional training, reinforcement learning, or architectural changes, and is motivated by context-window limitation, granularity mismatch between high-level intent and low-level execution, and context pollution from outdated or suboptimal experience (Mi et al., 30 Jan 2026).

1. Problem setting and conceptual basis

DMS is formulated in a canonical Planner–Actor GUI-agent setting. The environment is modeled as a deterministic transition system $\mathcal{E}$, with state $s_t$, atomic action $a_t$, and transition

$s_{t+1} = \mathcal{E}(s_t, a_t).$

A high-level task $T$ is solved by a Planner $P$ and an Actor $A$. At planning step $t$, the planner emits a short sequence of sub-goals,

$$P(T, o_t, q) = \{ p_1, p_2, \dots, p_k \}, \quad k \le 5,$$

where $o_t$ is the current observation and $s_t$0 is a task-agnostic system prompt; the actor then executes each sub-task $s_t$1 by generating atomic GUI actions,

$s_t$2

This formulation is explicitly aimed at long-horizon, cross-application, and dynamic GUI environments, where agents otherwise exhibit context amnesia, reasoning fragmentation, hallucination, brittle reuse of old workflows, and contamination by obsolete trajectories (Mi et al., 30 Jan 2026).

The architecture’s central critique of prior memory systems is twofold. First, monolithic storage of whole trajectories creates a granularity mismatch: a high-level intent may recur while the exact low-level path becomes invalid after layout shifts or widget changes. Second, static accumulation retains obsolete and suboptimal trajectories, producing context pollution and toxic priors. DMS therefore treats planner-generated sub-goals, rather than full tasks or isolated atomic actions, as the natural unit of memory. This makes reuse compositional while preserving alignment with execution structure (Mi et al., 30 Jan 2026).

A second defining property is that DMS is training-free. Its adaptive behavior occurs online at inference time through retrieval, reuse, mutation, replacement, and pruning, rather than through fine-tuning or RL. This distinguishes the architecture from systems that require backbone modification or gradient-based policy improvement. The paper’s explicit aim is to unlock the latent planning capabilities of base MLLMs by attaching a memory layer that continually regulates itself during task execution (Mi et al., 30 Jan 2026).

2. Memory representation, decomposition, and retrieval

DMS stores memory at the level of planner-generated sub-tasks, each written as

$s_t$3

A memory entry is

$s_t$4

where $s_t$5 is the natural-language plan or sub-task, $s_t$6 is the dense execution trajectory for that sub-task, and $s_t$7 stores metadata such as success status and descriptions. Trajectories with $s_t$8 are discarded, so the memory store retains only non-trivial reusable behavioral patterns (Mi et al., 30 Jan 2026).

This decomposition is the core representational move. The reusable unit is neither a whole end-to-end workflow nor a single atomic GUI action, but a sub-task-level macro. The paper argues that this middle granularity is fine enough to survive partial layout change and coarse enough to retain meaningful procedural structure. A plausible implication is that DMS operationalizes procedural memory as reusable local transformations, rather than as global demonstrations or purely semantic summaries.

Retrieval is governed by Dual-Factor Retrieval, which matches both starting condition and intended end state: $s_t$9 Here $a_t$0 is the embedding function and $a_t$1 is cosine similarity. The multiplicative form is important: a memory is considered appropriate only if both precondition and goal match. The ablations reported for the full system show that replacing this with a standard goal-based key is actively harmful in dynamic GUIs (Mi et al., 30 Jan 2026).

Storage is decoupled. The natural-language plan $a_t$2 is embedded and indexed, while the heavy trajectory $a_t$3 is stored on disk. When retrieval succeeds, the actor can reuse the stored trajectory directly rather than regenerate actions token by token. This reduces token cost, lowers latency, and makes execution more deterministic by bypassing some MLLM sampling variance. The execution policy is explicitly stochastic: with probability $a_t$4, replay the retrieved trajectory; with probability $a_t$5, re-solve the sub-task from scratch as a mutation. If the mutated trajectory $a_t$6 is successful and shorter than the stored one,

$a_t$7

the old memory is overwritten. This is the system’s in-place evolutionary replacement rule (Mi et al., 30 Jan 2026).

3. Utility-driven natural selection and self-regulation

The Darwinian character of DMS is implemented through Utility-driven Natural Selection. Each memory $a_t$8 is assigned a survival value built from utility, temporal freshness, and reliability. If $a_t$9 is the reuse count for memory $s_{t+1} = \mathcal{E}(s_t, a_t).$0, utility is

$s_{t+1} = \mathcal{E}(s_t, a_t).$1

The novelty bonus $s_{t+1} = \mathcal{E}(s_t, a_t).$2 appears in the appendix hyperparameters and protects young memories from immediate elimination (Mi et al., 30 Jan 2026).

Dormancy is handled by adaptive temporal decay: $s_{t+1} = \mathcal{E}(s_t, a_t).$3 with usage-dependent half-life

$s_{t+1} = \mathcal{E}(s_t, a_t).$4

The main text uses $s_{t+1} = \mathcal{E}(s_t, a_t).$5, while the appendix reports a longevity coefficient of $s_{t+1} = \mathcal{E}(s_t, a_t).$6; the notation is explicitly inconsistent. Reliability is penalized by strike count: $s_{t+1} = \mathcal{E}(s_t, a_t).$7 where $s_{t+1} = \mathcal{E}(s_t, a_t).$8 is the number of verification failures for memory $s_{t+1} = \mathcal{E}(s_t, a_t).$9. The combined survival score is

$T$0

Memories therefore survive if they are used often, used recently, and verified as reliable (Mi et al., 30 Jan 2026).

Pruning is homeostatic rather than purely threshold-based. DMS ranks memories by survival value $T$1, forming a ranked curve

$T$2

and uses the Elbow Method to locate the onset of the low-value tail: $T$3 When capacity reaches $T$4, the elbow estimate determines whether the tail should be pruned or whether capacity should expand: $T$5 This is the architecture’s explicit homeostatic regulation mechanism (Mi et al., 30 Jan 2026).

A separate feedback loop inhibits risky plans through Bayesian reputation modeling. For plan $T$6, with failures $T$7, successes $T$8, and latent failure probability $T$9,

$P$0

Defining prior strength $P$1 and global failure rate

$P$2

the posterior mean and uncertainty are

$P$3

The final risk score is

$P$4

and the dynamic rejection threshold is

$P$5

Plans with $P$6 are suppressed. Within the paper’s terminology, the three main regulatory mechanisms are Feedback Regulation, In-place Evolutionary Updates, and Homeostatic Regulation (Mi et al., 30 Jan 2026).

4. Execution loop and empirical behavior in GUI automation

The appendix’s DMS Verification Loop describes the online control cycle in procedural form. The planner generates sub-plans $P$7; for each sub-plan $P$8, DMS retrieves a memory $P$9; if a memory exists, is low-risk, and exploration is not triggered, the actor reuses it; otherwise a new trajectory is generated. Execution is then verified. Successful reused memories are rewarded; successful newly generated trajectories become new memories; failing reused memories receive additional strikes $A$0; and if strikes exceed the pseudocode’s deletion limit $A$1, the memory is deleted. If a failure occurs, the agent breaks and replans. After task completion, active memories receive global success/failure feedback, which updates posterior failure estimates and risk scores (Mi et al., 30 Jan 2026).

The system is evaluated on AndroidWorld, described as a live Android emulator benchmark with 116 distinct tasks across 20 real-world applications. The paper reports headline average gains of 18.0% in success rate and 33.9% in execution stability, while also reducing latency. On AndroidWorld, PA-Lite with Qwen2.5-VL-72B reaches 41.0% success rate, whereas DMS-PA-Lite with the same backbone reaches 66.4%, a gain of $A$2 points. Additional reported improvements are 25.0% $A$3 44.0% for Qwen3-VL-30B-A3B, 38.0% $A$4 50.4% for GLM-4.5V, and 41.0% $A$5 56.0% for Seed1.6-VL. The 66.4% result is reported as surpassing GPT-4o at 34.5%, UI-TARS at 46.6%, EchoTrail-GUI at 46.6% on Qwen2.5-VL, MobileUse at 62.9%, and UI-Venus at 65.9% (Mi et al., 30 Jan 2026).

Execution stability is measured with Success Retention Rate (SRR),

$A$6

The reported SRR improvements include 36.5% $A$7 84.7% for Qwen3-VL-30B and 53.0% $A$8 87.0% for GLM-4.5V. The interpretation given in the paper is that DMS reduces stochastic variance because replayed verified memories make execution more reproducible across repeated trials (Mi et al., 30 Jan 2026).

The memory system also exhibits longitudinal behavioral change. Across five execution rounds, memory reuse rises from cold start to above 30%, stabilizing around 30–36%; for Qwen2.5-VL-72B the paper notes growth from about 12% to above 30%. In the same five-round setting, Qwen3-VL-30B gains $A$9% and Qwen2.5-VL-72B gains $t$0% in task success. Over 1,000 planning cycles, memory footprint oscillates around 5 MB and remains below 8 MB rather than growing linearly. The latency heatmap is described as showing a transition toward lower execution times over rounds, whereas the memory-free baseline remains erratic and slow (Mi et al., 30 Jan 2026).

The ablation study is central to the architecture’s interpretation. Using Qwen2.5-VL-72B, full DMS-PA-Lite reaches 66.4%. Removing Feedback Regulation drops performance to 40.1%; removing Dynamic Thresholding yields 36.6%; replacing Dual-Factor Retrieval with a standard goal-based key yields 29.7%; removing Self-Regulation gives 39.2%; and the PA-Lite baseline is 41.0%. The paper further reports that without pruning, disk usage after 1,000 tasks becomes 258% larger than with DMS and average execution time becomes 18.8% higher. These ablations support the claim that DMS depends on selective retention, not merely on the existence of a memory store (Mi et al., 30 Jan 2026).

5. Position within the broader selectionist memory literature

The direct DMS paper sits within a broader set of memory models that use competition, retention, and adaptive restructuring, although most of those models are not full DMS theories in the strict sense. One important antecedent is the neuroevolutionary work on short-term memory in multigoal stochastic environments. That paper shows that agents can evolve the ability to store short-term memory because it improves adaptive behavior under competing goals and delayed reward recovery, and it identifies two mechanisms: integration of sensory signals with ongoing internal neural activity, and slow neurodynamical processes that encode previous behavioral choice. The authors explicitly state that this is not a full DMS theory, because selection operates across generations of agents rather than among internal memory traces during lifetime; nevertheless, it demonstrates that memory can emerge as an adaptive function rather than as a hand-designed module (Lakhman et al., 2012).

A second adjacent tradition is formal selectionist memory modeling. Guralnik’s observer model represents memory as a geometric/combinatorial database whose nodes are weighted by excitation values and whose structure can degenerate or expand as observation data accumulate. The observer is defined as

$t$1

where $t$2 is a finite poc-set, $t$3 is its representation in the environment, $t$4 is a relevance weighting on vertices of the dual median graph $t$5, and $t$6 is the current conjecture about the world. This framework is explicitly described as a hybrid combinatorial-geometric and selectionist memory model rather than a fully Darwinian one. A plausible implication is that DMS can be read as an engineering-level descendant of the same general idea: relevance-weighted retention and restructuring under ecological pressure (Guralnik, 2010).

Recent LLM-agent memory architectures also supply nearby but distinct formulations. D-Mem is a dual-process memory system that adaptively routes queries between lightweight vector retrieval and an exhaustive Full Deliberation module through Multi-dimensional Quality Gating. Its gating policy

$t$7

selects between a cheap approximate memory route and an expensive high-fidelity route. The paper explicitly states that this is not a Darwinian memory system, because selection is per query and prompt-defined rather than evolutionary or learned over time; still, it is a strong architectural precedent for adaptive memory access under compute constraints (You et al., 19 Mar 2026). D-MEM, by contrast, is a dopamine-gated agentic memory that routes utterances into SKIP, CONSTRUCT_ONLY, or FULL_EVOLUTION tiers using an Agentic Reward Prediction Error,

$t$8

and explicitly frames itself as a biologically inspired selective memory architecture rather than a full Darwinian system (Song et al., 15 Mar 2026).

Continual-learning work provides another neighboring cluster. “Sparse Coding in a Dual Memory System for Lifelong Learning” uses a working memory, an episodic replay buffer, and a long-term semantic memory updated by EMA, together with sparse coding and semantic dropout, to reduce interference and catastrophic forgetting; the paper is clear that it is not Darwinian in the strict sense, but it offers a concrete fast/slow memory scaffold (Sarfraz et al., 2022). The Information-Theoretic Dual Memory System likewise maintains a fast memory buffer via reservoir sampling and a slow memory buffer selected by a Rényi-entropy and Cauchy–Schwarz-divergence objective, making memories compete for limited retention under a fixed budget; it is framed as a strong conceptual analogue to DMS rather than a literal Darwinian memory model (Wu et al., 13 Jan 2025).

Other papers move even closer to population-level persistence and turnover. “Persistent Memory Through Triple-Loop Consolidation in a Non-Gradient Dissipative Cognitive Architecture” introduces Deep Memory, in which expert-specific centroids $t$9 are recorded, used to seed replaced units, and stabilized through continuous re-entry. The paper’s own DMS-oriented synthesis states that this mechanism is highly relevant because memory survives not in immortal units but in population summaries that are repeatedly re-instantiated after stochastic replacement (Lou, 28 Mar 2026). More broadly, DIME organizes cognition around engrams, execution threads, marker systems, and hyperengrams, and explicitly describes marker-mediated competition among execution threads and value-based selection; the accompanying synthesis concludes that DIME is best understood as a selectionist memory architecture with strong Darwinian analogies rather than a complete DMS (Vladu et al., 7 Mar 2026). This suggests that the DMS label in current arXiv usage names one specific GUI-agent architecture, but also touches a wider family of selectionist, ecological, and adaptive memory theories.

6. Scope, limitations, and common misconceptions

Within its own paper, DMS is not presented as a universal memory theory. It is a memory layer for GUI agents, specialized to Planner–Actor execution in dynamic applications, and its strongest claims are about long-horizon procedural reuse, self-pruning, and training-free online adaptation. The paper explicitly notes several limitations: DMS can be less helpful when tasks require extremely fine-grained atomic behaviors that resist macro abstraction; difficult logical tasks may require longer accumulation before stable gains appear; exploration and risk suppression can produce temporary volatility; and negative transfer can still occur transiently, including cases where memory reuse is high but the reused memory is confidently wrong. The claimed advantage is that DMS can later “unlearn” such toxic memories through its regulation mechanisms (Mi et al., 30 Jan 2026).

A common misconception is to read the Darwinian label as implying fine-tuning, reinforcement learning, or architectural modification of the backbone model. In the direct DMS formulation, none of these are required: the system is explicitly training-free and is attached to an existing Planner–Actor GUI agent through retrieval, mutation, replacement, risk estimation, and pruning (Mi et al., 30 Jan 2026). A second misconception is to treat all selectionist memory models as equivalent. The surrounding literature repeatedly distinguishes evolutionary emergence of memory across generations, relevance-weighted restructuring, adaptive routing, and true within-lifetime competition among memory traces. The direct DMS paper implements the Darwinian metaphor at the level of memory-unit survival, mutation, replacement, and pruning; other adjacent papers often supply only subsets of that machinery.

Terminological ambiguity also exists at the acronym level. In other arXiv domains, “DMS” can denote a diluted magnetic semiconductor rather than a Darwinian Memory System, as in theoretical work on nearest-neighbour antiferromagnetic interaction and critical temperature in model DMS systems. That usage is entirely unrelated to memory architectures and belongs to condensed-matter and spintronic contexts (Szalowski, 2016).

Taken in its narrowest sense, Darwinian Memory System refers to the self-evolving GUI-agent memory architecture of (Mi et al., 30 Jan 2026). Taken more broadly, the term also marks a contemporary research direction in which memory is treated as an adaptive population of reusable structures subject to differential retention, selective reuse, and continual ecological cleanup. The direct paper’s specific contribution is to make that program operational for real-world GUI automation through structured sub-task memories, Dual-Factor Retrieval, Utility-driven Natural Selection, Bayesian risk inhibition, and homeostatic pruning (Mi et al., 30 Jan 2026).