T²Mem:

Learning Test-Time Memory for Robotics

Yize Liu1 · Huang Huang1 · Yining Hong1 · Zijian Du2 · Zhi Cao3 · Li Fei-Fei1 · Jiajun Wu11 Stanford University   2 NVIDIA   3 University of Michigan, Ann Arbor

yizeliu@stanford.edu

Memory as an intrinsic capability: a robot policy learns what to remember and how to use it, without auxiliary memory models or memory-specific annotations.

VideoUnmask

Recall a hidden object.

PickXtimes

Count repeated actions.

PatternLock

Recall a demonstrated sequence.

Task demonstrations from RoboMME. Red border: demonstration phase.

56.83%

Mean success on RoboMME

+38.90pp

Over the memory-free π0.5 baseline

16tasks

Across four memory categories

Abstract

Memory-dependent robotic manipulation requires policies to use information that is no longer available in the current observation. Retaining history alone is insufficient: memory must preserve information that supports future actions. One challenge is whether a memory-free foundation model can learn to retain and use historical information from action demonstrations alone, without external memory support. We introduce T²Mem, a framework that develops this capability within a pretrained vision-language-action policy, without external reasoning models or memory-specific annotations. T²Mem uses test-time training to encode observation history into compact fast weights through online self-supervised updates, avoiding repeated processing of the full history. An observation-grounded interface extracts vision-language information for memory formation and supplies retrieved context to the action expert. Action supervision shapes what the memory learns to retain and use, while alternating memory-policy learning gives each component a fixed counterpart during optimization. Across 16 RoboMME tasks, T²Mem improves average success from 17.93% to 56.83% over the memory-free base policy and outperforms the recurrent-memory methods reported in the benchmark, while controlled profiling indicates at least 3x inference speedup over explicit methods.

01 / THE METHOD

Observation-Grounded Memory

Observe → read memory → act → update memory.

Observation → interface
Observation + instruction↓Vision-language backbone
Current scene features
OBSERVATION-GROUNDEDMemory interfaceObservation features
read ←write →
EPISODE STATEFast weights W
SELF-SUPERVISED WRITEL = mean[(fW(K) − V)²]
↓Action expert↓History-conditioned action

Illustrative features · Blue: observation · Violet: retrieved history · Orange: memory update

01

Grounded in observations

Memory writes come from visual-language observations.

02

Adaptive self-supervision

Write strength adapts to new observations.

03

Independent episode state

Fast weights update online and reset each episode.

Explore the full architecture figureClick to expand the paper diagram
Detailed T²Mem architecture: VLM, memory interface, fast-weight read and write paths, and action expert.
T²Mem architecture. (a) Backbone, memory, and action expert. (b) Observation-grounded interface. (c) Fast-weight reads and self-supervised writes.

The memory interface extracts compact vision-language features, retrieves relevant history from fast weights, and supplies both to the action expert. The original backbone-to-action pathway preserves access to the current scene.

Memory is grounded in observations, without direct access to action or proprioception tokens. At inference, only fast weights update; each episode starts from the learned initialization.

Inside Test-Time Training

Read with a forward pass. Write with a self-supervised gradient.

READ · Retrieve memoryProject the interface → Qₜ
Interface projections, fast-weight forward pass, and self-supervised backward update Interface UₜVL features acquired Fast weights · fWₜForward pass · Wₜ unchanged θqQₜRₜMemory context θkKₜθvVₜ · targetComparefWₜ(Kₜ) − VₜPrediction error
Rₜ = fWₜ(Uₜ θQ)Read: retrieve history without changing W.

Schematic network and feature colors. Read → Write → Repeat · Only fast weights update during inference.

Read: project interface features into a query and pass it through the fast-weight network to retrieve context.

Write: project the same features into keys and values, then update fast weights to predict values from keys. Adaptive write strength helps preserve earlier associations. Reading happens before writing.

02 / LEARNING

Alternating Memory–Policy Learning

Learn what to remember. Then learn how to use it.

Stage 1
Action supervision updates the policy
MemorySlow parameters
PolicySlow parameters
Action lossExpert demonstrationsSupervision
Memory inactive

Blue: slow-parameter learning · Orange: episode-local fast-weight updates

↻   Alternate 2A ↔ 2B. Fast weights update in both.

Stage 1: adapt the policy without memory. Stage 2A: freeze the policy and train memory. Stage 2B: freeze memory’s slow parameters and train the policy to use it.

Alternate 2A and 2B using action demonstrations alone. Episode-local fast weights keep updating in both phases; no memory-specific labels are needed.

03 / RESULTS

Results on RoboMME

Table 1 from the paper: full success rates on all 16 RoboMME tasks, including human performance, symbolic, perceptual and recurrent memory baselines, and T²Mem. T²Mem achieves 56.83% average success.
50 test episodes per task × 3 seeds. Baselines from RoboMME; human and privileged Oracle scores are reference points. Click to enlarge.

T²Mem raises average success from 17.93% to 56.83% across 16 tasks, outperforming the reported recurrent-memory baselines. Gains are strongest in cue retrieval and event counting; tracking swaps and precise insertion remain harder.

Ablation Studies

Paper ablation figure: memory architecture, alternating learning, and adaptive memory writing.
Ablations. (a–b) Success on VideoUnmask and MoveCube. (c) Early-memory reconstruction error over 20 VideoUnmask Hard episodes; lower is better. Fixed β = 1 retains step-size calibration.

Architecture and learning: observation-grounded memory and alternating updates outperform their ablated counterparts on VideoUnmask and MoveCube.

Adaptive writing: early-memory reconstruction error falls by 18.8%–46.9% over 300 subsequent frames, indicating less interference with earlier associations.

04 / INSIDE THE MEMORY

Does the Policy Use Its Memory?

Same scene. Different histories. Different choices.

Same observation. Different histories.

VideoUnmask · counterfactual expert demonstrations

Front viewWrist view
History ABlue cube in the first location.
Front viewWrist view
History BBlue and green positions exchanged.

Same instruction: “Watch the video carefully, then pick up the container hiding the blue cube.” The container layout stays fixed; the earlier color locations change, so the robot must grasp a different container. Both clips include the full grasp.

Expert demonstrations illustrating the counterfactual task, not T²Mem policy rollouts.

Paper figure comparing online writes, correct versus conflicting or empty memory, and write timing.
Online memory. (a) Removing writes reduces success. (b) Replacing history changes outcomes. (c) Writing before occlusion is more effective. Results pooled over three seeds.

Change only the memory: Correct uses the same episode’s history; Conflicting uses a donor episode with a different target; Empty uses the learned initialization without demonstration history. Instruction, goal, and diffusion seed stay fixed.

Across 50 pairs × both directions × 3 seeds, these conditions yield 300/300, 1/300, and 101/300 successes. Wrong history is more damaging than no episode history, showing that the policy uses memory content.

Timing matters: eight writes before occlusion achieve 76.67% success, versus 20.67% after occlusion—and match all 16 demonstration writes.

Inference Efficiency

Paper figure showing memory-stage latency and total inference latency for T²Mem, the highest-scoring RoboMME baseline, and MemER.
Inference latency: memory only (left), full model computation (right). RTX A5000, batch size 1, synchronized after warm-up. Excludes initialization, compilation, communication, and environment execution.

Compact fast weights avoid reprocessing the full history. Under controlled profiling, T²Mem is 3.0× faster than FrameSamp+Modul and 69.2× faster than MemER.

Citation

@misc{liu2026t2memlearningtesttimememory,
  title={T$^2$Mem: Learning Test-Time Memory for Robotics},
  author={Yize Liu and Huang Huang and Yining Hong and Zijian Du and Zhi Cao and Li Fei-Fei and Jiajun Wu},
  year={2026},
  eprint={2609.36720},
  archivePrefix={arXiv},
  primaryClass={cs.RO},
  url={https://arxiv.org/abs/2609.36720},
}