🤖 machine learning

DuoMem: Towards Capable On-Device Memory Agents via Dual-Space Distillation

The paper introduces DuoMem, a dual-space distillation framework that combines context-space memory augmentation and parameter-space fine-tuning to enable compact on-device LLMs to achieve near-teacher-level performance in complex procedural tasks while significantly reducing latency and resource requirements.

Original authors: Peyman Hosseini, Ondrej Bohdal, Ahmed Alajrami, Andrea Maracani, Ignacio Castro, Matthew Purver, Mete Ozay, Savas Ozkan, Taha Ceritli

Published 2026-06-30

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Peyman Hosseini, Ondrej Bohdal, Ahmed Alajrami, Andrea Maracani, Ignacio Castro, Matthew Purver, Mete Ozay, Savas Ozkan, Taha Ceritli

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant but exhausted professor (the Teacher) who can solve complex household chores perfectly, but they are too slow and expensive to hire for every single task. Then, you have a bright but inexperienced intern (the Student) who is fast and cheap, but often gets lost, forgets what to do, or tries to open a drawer without walking to it first.

The paper introduces DuoMem, a training system designed to turn that clumsy intern into a master chef using two specific teaching methods. The goal is to let the small, fast intern do the work of the big professor, but on a regular smartphone or robot without needing a supercomputer.

Here is how DuoMem works, using simple analogies:

The Problem: The "Small Brain" Struggle

Large AI models are like geniuses who can solve a puzzle in 14 steps. Small AI models (like the 4-billion-parameter one tested) are like people trying to solve the same puzzle by guessing. They might wander around the house for 30 steps, try to pick up a spatula from a wall, and eventually give up. They lack "procedural memory"—the ability to remember how to do things based on past experiences.

The Solution: DuoMem (The Dual-Training Camp)

DuoMem teaches the small intern using two different "spaces" or methods at the same time.

1. Context-Space Distillation: The "Cheat Sheet"

The Old Way: When the intern tries a new task, they have to write their own notes on how to do it based on their own (often bad) memories.
The DuoMem Way: Before the intern even starts, the Professor writes a perfect, high-quality "cheat sheet" (a procedural script) based on how they solved similar tasks in the past.
How it works: When the intern faces a new task, the system hands them the Professor's cheat sheet. The intern doesn't have to figure out the strategy from scratch; they just read the Professor's notes and follow them.
The Analogy: It's like giving a student a textbook summary right before a test, rather than asking them to write the summary themselves while taking the test.

2. Parameter-Space Distillation: The "Muscle Memory"

The Old Way: The intern reads the cheat sheet but still fumbles their hands because they haven't practiced the specific movements.
The DuoMem Way: The system takes all the times the Professor successfully solved tasks and uses them to "fine-tune" the intern's brain. It's not just giving notes; it's rewiring the intern's neural pathways to mimic the Professor's successful habits.
How it works: The system trains a tiny, lightweight add-on (called LoRA) on the intern's brain. This add-on learns the "muscle memory" of the Professor's successful moves.
The Analogy: It's like a dance instructor watching a master dancer and then adjusting the student's posture and muscle tension so they naturally move like the master, even without looking at the notes.

The Results: Fast, Cheap, and Smart

The paper tested this on a virtual house called ALFWorld, where the agent has to do things like "clean a spatula and put it in a drawer."

Without DuoMem: The small 4B model was terrible. It succeeded only 4.3% of the time. It took about 29 steps and nearly 19 seconds per task.
With DuoMem: The same small model succeeded 77.9% of the time. It took only 21 steps and about 5 seconds.
The Comparison: The small model with DuoMem became almost as good as the massive 72-billion-parameter Professor (who succeeded 87.1% of the time), but it was 3 times faster and required a tiny fraction of the computing power.

Why This Matters

The paper claims that you don't need a massive, slow supercomputer to have a smart agent on your phone or robot. By combining the Professor's cheat sheets (Context) with the Professor's muscle memory (Parameters), a small, fast model can do complex tasks in real-time.

Key Takeaway: DuoMem proves that a small model doesn't need to be "dumb" if it is taught the right way. It can borrow the brainpower of a giant model without actually needing to carry the giant model's weight.

Technical Summary: DuoMem

Problem Statement

Large Language Model (LLM)-based agents demonstrate impressive capabilities in solving complex procedural tasks through multi-turn interactions with environments. However, achieving state-of-the-art performance typically requires massive models (30B–70B+ parameters) and extensive context windows. This computational burden creates a significant barrier to deploying advanced memory-augmented agents on resource-constrained edge devices (e.g., smartphones, robots). While smaller models (2B–12B parameters) are attractive for on-device use, they exhibit weak procedural reasoning and fail to effectively leverage memory, often resulting in low task success rates and inefficient exploration.

Methodology: DuoMem Framework

The authors propose DuoMem, a dual-space distillation framework designed to transfer procedural problem-solving abilities from a large teacher model to compact student models. The framework operates in two complementary spaces:

1. Context-Space Distillation (CD)

Instead of relying on the student model to generate its own memory summaries from past trajectories (which often results in low-quality or irrelevant details), DuoMem utilizes a powerful teacher model to extract high-quality procedural memories offline.

Mechanism: The teacher model summarizes successful trajectories into concise procedural scripts. At inference time, the $k$ most relevant teacher-generated memories are retrieved (via semantic embedding similarity) and prepended to the student's input context.
Benefit: This enriches the student's context with distilled procedural knowledge without modifying the student's parameters, acting as a training-free enhancement.

2. Parameter-Space Distillation (LoRA)

This component directly improves the student model's behavioral policy by fine-tuning it on expert demonstrations.

Mechanism: The framework collects successful trajectories generated by the teacher model. A lightweight Low-Rank Adaptation (LoRA) adapter is attached to the student model and fine-tuned via next-token prediction on these successful trajectories.
Input Strategy: The authors find that training on the Full History of interactions (rather than just the latest turn) yields the best results, allowing the model to learn the full procedural dynamics of how early observations inform later actions.

Integration

DuoMem combines both mechanisms: the student model is first LoRA-fine-tuned on teacher trajectories (parameter space) and then, during inference, receives teacher-generated memories in its context (context space). The authors posit that CD improves what the model sees (richer knowledge), while LoRA improves how the model acts (better utilization of context).

Key Contributions

Dual-Space Framework: The proposal of DuoMem, which transfers procedural memory via complementary context-space (CD) and parameter-space (LoRA) distillation.
Performance on Edge: Demonstration that DuoMem can lift a 4B-parameter model from a 4.3% success rate to 77.9% on the ALFWorld benchmark, closing 89% of the gap to a 72B teacher model, while adding fewer than 10M trainable parameters and only a few megabytes of pre-computed memory.
Efficiency: Showing that the DuoMem-enhanced 4B model completes tasks over 3× faster in wall-clock time than the 72B teacher, making real-time edge deployment viable.
Ablation Insights: Extensive experiments across eight models (2B–72B) reveal that both distillation axes contribute complementary gains. The combination consistently outperforms either component in isolation, with synergistic effects observed particularly in smaller models.

Experimental Results

Evaluated on ALFWorld, a text-based embodied decision-making benchmark:

Success Rates:
- Qwen3-4B-Instruct: Improved from 4.3% (no memory) to 77.9% (DuoMem), compared to the 72B teacher's 87.1%.
- Gemma4-E2B-it (2B): Improved from 2.1% to 55.7%.
- Gemma3-12B-it: Improved from 14.3% to 66.4%.
Efficiency:
- The 4B DuoMem model reduced average task completion time from ~18.5s to 4.9s (a 3.7× speedup over the teacher's best configuration).
- Average interaction steps decreased by 30% (from ~29 to ~21 steps).
Overhead:
- Parameters: LoRA adapters added <0.15% to the 4B model (5.9M parameters).
- Storage: The entire teacher memory store occupies ~4 MB; LoRA adapters require ~12–47 MB depending on the model size.
Model Size Sensitivity: The benefits of DuoMem are most pronounced for smaller models (2B–12B). For larger models (e.g., 32B+), the marginal gains diminish as the base model's own capabilities become sufficient for effective memory utilization.
Thinking vs. Non-Thinking: While "thinking-mode" models (Chain-of-Thought) achieve higher baselines, they incur 5–7× latency penalties, making them impractical for edge deployment. DuoMem enables non-thinking models to recover much of the accuracy gap at real-time speeds.

Significance and Claims

The paper claims that DuoMem bridges the critical gap between the high performance of large LLM agents and the resource constraints of edge devices. By decoupling the acquisition of procedural knowledge (via teacher distillation) from the execution of tasks (via compact student models), the framework enables capable, memory-augmented agents to run locally on devices where deploying a 72B model is infeasible due to memory and latency constraints.

The authors emphasize that the dual-space approach is not merely additive; the combination of context enrichment and parameter adaptation yields synergistic improvements that exceed the sum of individual components. Furthermore, the framework is architecture-agnostic and task-agnostic, suggesting potential for generalization to other procedural domains beyond ALFWorld.

The work concludes that for edge deployment, the trade-off between the latency of "thinking" models and the efficiency of distilled non-thinking models makes DuoMem a practical solution for deploying capable autonomous agents in real-world scenarios.