Abstract
Current Large Language Model (LLM) agents face a fundamental trade-off between high latency and limited personalization. MOBIMEM introduces a memory-centric architecture that enables agents to evolve post-deployment without expensive model retraining. By utilizing specialized memory primitives—Profile, Experience, and Action Memory—alongside an OS-inspired integration layer, MOBIMEM achieves significant performance gains. Experimental results demonstrate up to a 9x reduction in end-to-end latency and a 50% improvement in task success rates on mobile devices.
Introduction
Large Language Model (LLM) agents are traditionally "model-centric," meaning their capabilities and personalization are baked into the model weights. Improving an agent's ability to handle specific user habits or new applications typically requires fine-tuning, a process that is computationally prohibitive for mobile devices. This creates a dilemma: users must choose between a "smart" but slow cloud-based agent or a "fast" but generic on-device model. Furthermore, the serial execution of tasks by current agents leads to high end-to-end latency, making them feel sluggish compared to manual interaction.
System Architecture: The MOBIMEM Framework
MOBIMEM addresses these challenges by shifting the burden of evolution from model weights to a structured memory system. The architecture is divided into three specialized layers that facilitate "self-evolution" through experience.
1. Profile Memory (DisGraph)
Unlike standard vector databases or complex Knowledge Graphs that require expensive LLM calls for navigation, MOBIMEM utilizes a "Distance-Graph" (DisGraph). In this structure, concepts and entities are nodes, while edges represent simple relational distances. This design enables lightning-fast, zero-LLM retrieval of user preferences.
2. Experience Memory
This module distills successful task executions into reusable "templates." Rather than storing raw history, it identifies parameter slots (e.g., a "Book Flight" template with variable destinations), allowing the agent to generalize from past successes to new, similar tasks.
3. Action Memory
Acting as a "muscle memory" cache, this layer stores fine-grained UI interaction sequences. It uses two structures: ActTree for shared prefixes (like opening an app) and ActChain for specific task flows. When a task matches a cached sequence, the agent replays the actions directly, bypassing the LLM reasoning step entirely.
OS Integration Layer
To manage these components, MOBIMEM introduces an OS Integration Layer. This includes a task scheduler that identifies independent sub-tasks and executes them in parallel, mirroring how a traditional operating system manages threads to reduce latency.
Evaluation and Key Results
The system was evaluated using the AndroidWorld benchmark (116 tasks across 20 apps), a Top-50 Apps real-world test, and a custom User Profile Benchmark designed to test preference inference.
The results highlight the efficiency of the memory-centric approach:
- Latency Reduction: On a Snapdragon 8 Elite SoC, Action Memory reduced end-to-end latency by up to 9x by avoiding redundant LLM inference.
- Retrieval Speed: Profile retrieval via DisGraph is 280x faster than GraphRAG baselines, averaging just 23ms.
- Accuracy Gains: Task success rates improved by up to 50.3% for smaller models (e.g., UI-TARS-7B), allowing them to rival the performance of much larger models.
- Minimal Footprint: The Action Memory for the entire AndroidWorld suite required only 1.54MB, making it ideal for on-device deployment.
Discussion and Future Work
The core insight of MOBIMEM is that an agent's intelligence can be decoupled from its model weights. By treating the agent system like an operating system—applying concepts like memory management, scheduling, and record-and-replay—developers can solve the latency and personalization issues inherent in LLM-based automation.
However, limitations remain. Initial reasoning for entirely new tasks still requires capable (and often cloud-dependent) LLMs. Additionally, Action Memory is sensitive to UI changes. While MOBIMEM includes a rollback mechanism for app updates, future iterations could benefit from "fuzzy matching" for UI elements to increase resilience against layout shifts. Deeper integration with the mobile OS kernel represents another promising avenue for further optimization.
Summary updated