acceptodds
Under review as a conference paper at ICLR 2027

REKI: Registering Knowledge in VLAs

Abstract

Most vision-language-action models (VLAs) predict actions from the current observation alone, without retaining information from the past. Existing memory mechanisms either directly pass past frames into the vision-language backbone (VLM), unroll the model during training, or add dedicated memory modules, which increase training or inference costs for VLAs. To address this, we introduce REKI, a VLA with a lightweight memory mechanism that substantially improves performance with negligible overhead. A small set of memory tokens in the action head summarises outputs from the VLM at each step and is cached across time to inform next actions. We find that memory is particularly useful for reducing repetitive robot behaviours. Evaluations on LIBERO-Plus, RoboTwin, and real-world robot tasks demonstrate REKI's strong performance and generalisation. With only 2.2B parameters and trained only on public robot data, REKI achieves state-of-the-art results among models of comparable size and can even match or surpass larger models. We release our code, data curation pipeline, and models.

Primary area:
applications to robotics, autonomy, planning
Keywords:
robotics, vision-language-action models, memory

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_ZLGzOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes REKI, a vision-language-action model with short-term memory. It introduces a small set of register tokens in the action expert to store information from past observations. Its attention and normalization design allows these tokens to be reused across frames and denoising steps, supporting batched window training without repeatedly encoding past images. The authors train a 2.2B model on public data and demonstrate improvements on LIBERO-Plus, RoboTwin, and real-robot tasks. Their behavioral analysis also shows that short-term memory reduces back-and-forth motion across action chunks.

Critical strengths

1.The paper studies a meaningful problem. Using historical information while keeping computational costs low is important for continuous robot manipulation.

2.The method is simple and introduces little additional inference cost. Memory is placed directly in the action expert, avoiding repeated VLM processing of past images.

Critical weaknesses

1.Lack of direct comparisons with related memory methods. The paper discusses HAMLET and MemoryVLA but does not directly compare against them. The memoryless baseline demonstrates the value of historical information, but does not establish the advantages of the proposed memory structure over existing methods.

2.Limited ablations of key design choices. The ablations mainly vary the number of historical frames, without separately examining the sampling interval, number of register tokens, gradient propagation through history, or supervision across multiple frames. In particular, although the sampling intervals of 1 second in simulation and 2 seconds on real robots match the action chunk durations, their sensitivity is not evaluated. It therefore remains unclear how robust these settings are across tasks with different motion speeds and periods.

3.Lack of direct evidence for reduced oscillation on real robots. The paper provides oscillation statistics and trajectory analysis in simulation, but the real-robot experiments mainly demonstrate memory’s benefits through task success rates and partial completion scores. These results do not establish whether the gains come from reduced oscillation. Comparisons of oscillation rates and corresponding execution trajectories with and without memory would help verify this effect on real robots.

Questions for authors

Could the authors respond to the concerns raised in the weaknesses section?

4 comments
AuthorsOpenReview ↗

Answer to ZLGz

W1. Comparison with HAMLET and MemoryVLA

We ported HAMLET and MemoryVLA from the authors' released code to REKI. We now compare REKI with HAMLET (as published and with the all-frame supervision of REKI), MemoryVLA, a feature cache and frame stacking, on the same backbone and in the same training pipeline; for details, please see the common answer above (1/3, 2/3, 3/3). In short:

  • Success (common answer B): REKI, the feature cache and HAMLET with all-frame supervision are within 1.7 points of each other when finetuned, and MemoryVLA scores lower on RoboCasa365. HAMLET as published scores 5.1 points below REKI on RoboCasa365, 5.0 below on RoboTwin hard and 1.8 above on LIBERO-Plus; similarly to REKI (W2 below), supervising every frame helps on the more challenging benchmarks RoboCasa365 and RoboTwin hard (+3.6 and +3.3).
  • Inference cost (common answer A): with 16 frames, REKI and HAMLET stay at about 28 ms per chunk, against 38.9 ms for the feature cache and 88.2 ms for frame stacking.
  • Oscillation (common answer C): with all three designs, memory reduces the share of oscillating episodes from 21–37% to 5–7%.
AuthorsOpenReview ↗

Answer to ZLGz ctd.

W2. Design ablations

Below we report ablations of the history stride, the number of registers (randomly initialized for a fair comparison) and the supervision of history frames, on RoboCasa365, RoboTwin hard and LIBERO-Plus.

AblationSettingRoboCasa365 totalRoboTwin hardLIBERO-Plus
Reference1 s stride, 32 pretrained registers, all frames supervised39.267.1⋅33.1⋅13.8\displaystyle{\mathbf{39.2} \atop \scriptstyle 67.1 \cdot 33.1 \cdot 13.8}49.990.4
History striderandom in [0.5 s, 2 s]37.3 (−1.9)65.0⋅28.6⋅14.8\displaystyle{37.3\ (-1.9) \atop \scriptstyle 65.0 \cdot 28.6 \cdot 14.8}51.3 (+1.4)90.1 (−0.3)
2 s40.5 (+1.3)68.8⋅34.4⋅14.8\displaystyle{40.5\ (+1.3) \atop \scriptstyle 68.8 \cdot 34.4 \cdot 14.8}50.6 (+0.7)90.0 (−0.4)
Supervisionlast frame only34.2 (−5.0)60.9⋅26.5⋅11.9\displaystyle{34.2\ (-5.0) \atop \scriptstyle 60.9 \cdot 26.5 \cdot 11.9}49.3 (−0.6)90.8 (+0.4)
Registers per frame (random init.)837.4 (−1.8)62.8⋅31.2⋅15.1\displaystyle{37.4\ (-1.8) \atop \scriptstyle 62.8 \cdot 31.2 \cdot 15.1}47.4 (−1.4)90.1 (−0.1)
1639.4 (+0.2)67.1⋅31.1⋅16.6\displaystyle{39.4\ (+0.2) \atop \scriptstyle 67.1 \cdot 31.1 \cdot 16.6}47.5 (−1.3)90.1 (−0.1)
3239.267.4⋅32.8⋅14.0\displaystyle{39.2 \atop \scriptstyle 67.4 \cdot 32.8 \cdot 14.0}48.890.2
6441.2 (+2.0)68.6⋅35.4⋅16.2\displaystyle{41.2\ (+2.0) \atop \scriptstyle 68.6 \cdot 35.4 \cdot 16.2}49.4 (+0.6)91.0 (+0.8)

Success rate (%): RoboCasa365 over 50 tasks × 50 episodes, RoboTwin hard over 25 trials per task (35 for the reference), LIBERO-Plus over 10,030 episodes. Small numbers: atomic seen · composite seen · composite unseen. In parentheses: difference with the reference (register rows: with 32 registers).

  1. Supervising every frame matters. Supervising only the last frame divides the number of supervised action chunks per step by 3, which reduces the effective batch size, but it also makes the task simpler: the model always predicts from the full history, rather than from variable history lengths. This lowers the RoboCasa365 score by 5.0 points (34.2 vs 39.2), while it barely changes the LIBERO-Plus and RoboTwin hard results (+0.4 and −0.6). This suggests that more challenging tasks with larger training datasets, such as RoboCasa365, benefit more from a larger effective batch size, which should matter even more when finetuning on fewer GPUs. We observe the same effect with HAMLET (+3.6 on RoboCasa365 and −1.4 on LIBERO-Plus when every frame is supervised, common answer B).
  2. History stride. We train with a history stride of 1 s, of 2 s, or sampled at random in [0.5 s, 2 s] for each window. At inference, all three models replan every 1 s, and the model trained with random strides uses a stride of 1 s. The effect of the stride varies across benchmarks, but on average all three models perform similarly (−0.3 points with random strides and +0.5 with a 2 s stride, against the reference), which shows that the memory mechanism is robust to the choice of history stride. The stride can therefore be chosen depending on the pace of the task.
  3. Registers. With randomly initialized registers, performance increases from 8 to 64 registers from 37.4 to 41.2 on RoboCasa365, from 47.4 to 49.4 on RoboTwin hard and from 90.1 to 91.0 on LIBERO-Plus, suggesting that the memory benefits from more capacity per frame.

Note that evaluating the same checkpoint several times gives results that vary by about 1 point (common answer B), from numerical non-determinism in compiled inference. We will add this table and its discussion to our revision.

W3. Oscillation on the real robot

We applied the oscillation detector, see our reply to 5tf5 to the recorded real-robot runs, on the 5 tasks of Fig. 7 (success counts in our reply to qRzx), with the same thresholds as in simulation.

TaskOscillation (%) ↓ WithoutOscillation (%) ↓ WithTask score (%) ↑ WithoutTask score (%) ↑ With
Stack three cubes40.0 (8/20)13.6 (3/22)3550
Sweep paper into dustpan27.3 (3/11)5.9 (1/17)57.557.5
Place 3 fruits in plates0.0 (0/10)18.2 (2/11)4860
Place banana in box0.0 (0/8)0.0 (0/28)6565
Stack three cups9.1 (1/11)4.8 (1/21)67.585
Average15.38.554.663.5

Without / with memory. Oscillation: share of episodes with oscillation (oscillating / recorded episodes). Task score: Fig. 7.

Memory reduces the average oscillation rate by 1.8×, from 15.3% to 8.5%. Most of the reduction comes from stacking cubes and sweeping, the two tasks where the model without memory oscillates most.

We will add these rates and the joint trajectories with and without memory to our revised version.

Thank you for the detailed responses and the time spent conducting these additional experiments. The comparisons with existing memory methods, expanded ablations, and real-robot oscillation analysis have substantially addressed my main concerns. I appreciate these efforts and will take the additional results and clarifications into consideration when determining my final score.

AuthorsOpenReview ↗

Response to Reviewer ZLGz

We thank the reviewer for their constructive feedback, which helped us strengthen the paper, and for taking the additional results into consideration.

Reviewer_5tf5OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces REKI, a 2.2B vision-language-action model that stores recent visual context in register tokens within the action expert. The registers are independent of the noisy action tokens and flow time, allowing their keys and values to be reused across denoising steps and cached across observations. Training uses causal attention over short windows, with an action loss on every frame, so the frames can be processed in parallel. The paper evaluates REKI on LIBERO-Plus, RoboTwin, and five real-robot tasks. Its most useful empirical finding is that a short history improves task success and substantially reduces repetitive motion across action chunks. The reported inference overhead of reading the cached history is small relative to the same model without past-frame access.

Critical strengths
  1. The memory design fits naturally into the action expert. Keeping the registers independent of action noise and flow time allows their computation to be shared across denoising steps, while caching avoids repeatedly encoding past observations. The causal training scheme also allows all frames in a window to receive supervision in a batched pass. These are useful practical choices for adding history to a VLA without introducing a separate memory network.

  2. The memory ablations provide convincing evidence that reading history improves this policy. On RoboTwin Clean, success increases from 65.1% without memory to 73.4% with memory, while oscillating episodes decrease from 18.6% to 4.1% (Fig. 5). More importantly, removing history from the same memory-trained model reduces success to 67.7% and increases oscillation to 14.8%. This comparison helps separate the benefit of history at inference from differences in training. The real-robot experiments provide additional, though smaller-scale, evidence that the benefit extends beyond simulation.

Critical weaknesses
  1. My main concern is the lack of a matched memory baseline. The ablations show that history helps REKI, but do not show whether the register design offers a better trade-off between success rate and cost than other ways of storing the same history. A comparison with a simple feature cache or an existing memory method, using the same backbone, data, and training budget, would make the design choice easier to assess.

  2. The oscillation detector needs a more precise description. Figure 5 identifies oscillations through motion reversals across at least three consecutive chunks, but the paper does not explain precisely how a motion reversal is computed. Appendix A also mentions a threshold fixed on 16 tasks, without clarifying whether this refers to the three-chunk criterion or another parameter. A precise detector definition and a description of how the criterion was selected would make this analysis easier to reproduce.

Questions for authors
  1. Have you compared REKI with a simple historical-feature cache or another memory method under the same backbone and training setup? Results on one benchmark, including both success rate and inference cost, would help assess the benefit of the register design.

  2. Table 6 defines REKI's batch size in frames and notes that batches are trimmed to a token budget. For the K=1 and K=3 finetuning ablations in Fig. 5, was the number of windows per batch adjusted to keep the effective number of supervised frames comparable, both per update and over the full training run?

  3. Could you provide the exact oscillation detector and explain how the 16 calibration tasks were selected? Have you checked its predictions against manual labels or tested whether the reported reduction is stable under reasonable changes to the thresholds?

3 comments
AuthorsOpenReview ↗

Answer to 5tf5

W1 and Q1. Matched memory baseline

We now compare REKI with HAMLET (as published and with the all-frame supervision of REKI), MemoryVLA, a feature cache and frame stacking, on the same backbone and in the same training pipeline; for details, please see the common answer above (1/3, 2/3, 3/3). In short:

  • Success (common answer B): REKI, the feature cache and HAMLET with all-frame supervision are within 1.7 points of each other when finetuned, and MemoryVLA scores lower on RoboCasa365. HAMLET as published scores 5.1 points below REKI on RoboCasa365, 5.0 below on RoboTwin hard and 1.8 above on LIBERO-Plus; similarly to REKI (reply to Reviewer ZLGz, W2), supervising every frame helps on the more challenging benchmarks RoboCasa365 and RoboTwin hard (+3.6 and +3.3).
  • Inference cost (common answer A): with 16 frames, REKI and HAMLET stay at about 28 ms per chunk, against 38.9 ms for the feature cache and 88.2 ms for frame stacking.
  • Oscillation (common answer C): with all three designs, memory reduces the share of oscillating episodes from 21–37% to 5–7%.

W2 and Q3. Oscillation detector

Oscillation detector. For each arm, two consecutive action chunks form a reversal when both move the joints by more than 0.05 rad and in opposite directions (cosine below −0.5). An episode oscillates after 3 consecutive reversals. We set these thresholds on the first 16 RoboTwin tasks in alphabetical order, and we will add the equation to our revised version. Its results on the real robot are in our reply to Reviewer ZLGz, W3.

Stability with respect to the thresholds. Over 18 settings (cosine −0.3, −0.5, −0.7; movement 0.01, 0.02, 0.05 rad; 2 or 3 reversals in a row), the average oscillation rate on the robot is 1.6× to 2.6× higher without memory than with memory. On RoboTwin, it is 1.6× to 5.2× higher for the model trained without memory, and 1.4× to 4.2× higher when memory is removed at test time.

Check against manual labels. To understand what the detector counts as oscillation, we manually labelled every flagged episode among 100 RoboCasa365 rollouts of REKI (trained from scratch), with and without memory at inference. The flagged episodes fall into several categories:

CategoryREKIREKI without memory
Arm oscillation421
· at a handle or control that the robot fails to operate17
· while holding an object, without placing it05
· empty gripper hovering after a failed grasp or placement24
· target hidden, e.g. behind a door the robot has closed12
· hesitation near the target, without contact03
Base oscillation (failed or erratic navigation)13
Repeated action on the wrong object01
No oscillation14
· grasp retries11
· task motions (wiping, stirring, pick-and-place)03
Total flagged episodes629

Number of flagged episodes out of 100 RoboCasa365 rollouts per model.

Most flagged episodes are arm oscillations, in which the arm moves back and forth near the target without making progress: at a handle or control it fails to operate, while holding an object, with an empty gripper after a failed grasp or placement, or when the target is hidden. The others are oscillations of the mobile base or repeated actions on the wrong object. Only 5 of the 35 flagged episodes are not oscillations: grasp retries, and task motions that are repetitive by nature. Memory reduces every type of oscillation: arm oscillations drop from 21 to 4 per 100 episodes, and base oscillations from 3 to 1.

We will add the threshold sweep and an analysis of the categories of movements flagged as oscillations to our revised version.

Q2. Supervised frames for K = 1 and K = 3

On every benchmark, the model without memory (K = 1) is trained on 3× more windows per batch than the model with memory (K = 3), within the same budget of 30k tokens per GPU (Appendix, Table 6). Both models thus see the same number of supervised frames per update (e.g. on average 425 vs 418 on RoboTwin).

We thank the authors for their detailed responses to our concerns. However, considering the other reviewers’ feedback, we remain unconvinced that the paper meets the ICLR acceptance standard. We will maintain our current score.

AuthorsOpenReview ↗

Response to Reviewer 5tf5

We thank the reviewer for their reply. We would be very grateful if the reviewer could concretely point out the remaining concerns so that we can respond to them and clarify any remaining doubts. While reviewer ZLGz initially shared many of the same concerns as 5tf5, they noted that the additional ablations and comparisons to other memory baselines substantially addressed those. We would also be happy to further discuss the relevance of our contribution.

Reviewer_qRzxOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper adds short-term memory to a VLA's action expert. Each frame gets 32 learnable register tokens that read that frame's VLM encoding and the registers of the two previous frames (1 s apart). Their keys and values are cached, and action tokens read them through the expert's existing self-attention. Unlike stacking frames in the VLM or a recurrent state, each frame is encoded once and a training window is one batched pass with a loss on every frame. Unlike added memory modules, no separate module is needed, and as the paper frames it (Fig. 1), HAMLET supervises only the last frame while MemoryVLA stores past entries without gradient. Inference GPU time rises by under 1%. A 2.2B model pretrained on public data is tested on LIBERO-Plus, RoboTwin 2.0 Clean2Rand and five UR5 tasks, with a window ablation and an oscillation analysis.

Critical strengths

The memory is cheap and its effect is shown on matched seeds. Past registers add 0.6 to 0.9% GPU time (Fig. 3). On RoboTwin Clean, the K=3 model scores 73.4 against 65.1 without memory, and oscillating episodes fall from 18.6% to 4.1% (Fig. 5). This directly supports the first two contributions and explains what a short history fixes. The open 2.2B model also matches pi0.5 out of distribution (63.9 vs 63.8, 86.6 vs 85.7).

Critical weaknesses

The memory design is compared only with itself at K=1 to 3. No experiment tests frame stacking, a recurrent state or a HAMLET-style module on the same backbone, so the claimed cost/benefit advantage rests on the argument of Fig. 1. The external comparisons use copied numbers from runs with different budgets (Table 6, App. F), so they speak to the model, not the memory. This limits the main claim but not the internal ablation.

The memory spans 2 s (4 s on the robot), and the authors note that the benchmarks rarely require more (App. A). The evidence that memory tracks task progress rests on three real-robot tasks with 10 episodes each. No variance is reported, and with 10 partial-credit episodes per arm, gains of 12 to 17.5 points may be within run-to-run noise.

Questions for authors

New experiment: could you compare REKI with one alternative memory design, for example the previous frame stacked in the VLM, on the same backbone and budget, reporting success and cost?

Clarification: was the 1→1 model finetuned from the K=3 pretrained checkpoint, and how much of the RoboTwin gain comes from window training (3→1 is 2.6 points above 1→1)?

Verify an existing result: please give the per-task full-success counts as numbers (Fig. 7 shows them only as bars) and the variance for the real-robot study, and confidence intervals in simulation.

2 comments
AuthorsOpenReview ↗

Answer to qRzx

W1 and Q1. Comparison with other memory designs

We now compare REKI with HAMLET (as published and with the all-frame supervision of REKI), MemoryVLA, a feature cache and frame stacking, on the same backbone and in the same training pipeline; for details, please see the common answer above (1/3, 2/3, 3/3). In short:

  • Success (common answer B): REKI, the feature cache and HAMLET with all-frame supervision are within 1.7 points of each other when finetuned, and MemoryVLA scores lower on RoboCasa365. HAMLET as published scores 5.1 points below REKI on RoboCasa365, 5.0 below on RoboTwin hard and 1.8 above on LIBERO-Plus; similarly to REKI (reply to Reviewer ZLGz, W2), supervising every frame helps on the more challenging benchmarks RoboCasa365 and RoboTwin hard (+3.6 and +3.3).
  • Inference cost (common answer A): with 16 frames, REKI and HAMLET stay at about 28 ms per chunk, against 38.9 ms for the feature cache and 88.2 ms for frame stacking.
  • Oscillation (common answer C): with all three designs, memory reduces the share of oscillating episodes from 21–37% to 5–7%.

W2 and Q3. Real-robot counts and variance

We report the full-success counts of Fig. 7, over 10 trials per task.

Taskπ0.5REKI w/o memoryREKI
Place banana in box2/106/106/10
Sweep paper into dustpan0/103/105/10
Place 3 fruits in plates2/102/102/10
Stack three cubes0/101/103/10
Stack three cups2/104/108/10

Although memory improves or matches the results on every task, we acknowledge that 10 trials per task is limited: the variance of a single task is high, and more trials are needed for a robust per-task success rate. We are running more real-robot trials per task and will share the results in the coming days.

The confidence intervals and the evaluation noise in simulation are in the common answer B.

Q2. Initialization of 1→1

Both models are finetuned from the same pretrained model, so comparing 3→1 with 1→1 indeed measures the gain from training with memory. Across benchmarks, this gain is small (0 to 2 points), while most of the gain comes from using memory at inference (up to 6 points).

AuthorsOpenReview ↗

Answer to qRzx

As promised, here are the real-robot results over 30 trials per task.

Taskπ0.5REKI w/o memoryREKI
Banana in box35.8 ± 8.4 (9)70.8 ± 7.8 (19)72.5 ± 7.8 (20)
Sweep paper20.0 ± 6.4 (2)50.8 ± 7.9 (10)55.0 ± 8.3 (11)
3 fruits in plates34.0 ± 5.9 (3)57.6 ± 7.8 (13)66.3 ± 6.2 (11)
Stack 3 cubes27.5 ± 5.1 (1)48.3 ± 7.2 (7)58.3 ± 6.8 (10)
Stack 3 cups42.5 ± 7.3 (6)65.0 ± 7.3 (14)70.8 ± 6.9 (17)
Average32.0 ± 3.0 (4.2)58.5 ± 3.4 (12.6)64.6 ± 3.2 (13.8)

Task score (%, as in Fig. 7) ± standard error over 30 trials; in parentheses, full successes out of 30.

These results are in line with the 10-trial experiments, with a smaller gap between REKI and REKI without memory. Although within statistical uncertainty, the gain from memory is consistent across tasks: REKI has a higher task score on all 5 tasks and more full successes on 4 of 5. Memory also reduces oscillation on the robot (15.3% to 8.5%, reply to Reviewer ZLGz, W3). We will update Fig. 7 with these results.

Comments on the paper

4 comments
AuthorsOpenReview ↗

Common answer to all reviewers (1/3)

We are very thankful for the thorough reviews, which we believe will make the paper stronger after revision. Following the reviewers' suggestions, we compared REKI with other memory designs on the same backbone, in the same training setup, and we will include these results in the revised paper. In short, they corroborate our findings on the benefits of memory, and they highlight the robustness and strength of our training and inference pipeline, which we release in full. In particular, we make the following contributions:

  1. A strong, fully reproducible VLA. REKI is a 2.4B VLA that reaches state-of-the-art results among VLAs pretrained on public data, and rivals VLAs of similar size pretrained on in-house data. This comes from a set of careful choices: curated training data, efficient supervision (every frame of the history window is supervised, with eight flow-matching draws per frame), and visual augmentations such as mirroring and camera dropout. Inference is compiled entirely into CUDA graphs, and REKI is faster than the state-of-the-art VLAs we timed, even after we compile them too. We release the full code, from data curation to deployment, and all model weights.
  2. A flexible building block for VLA research. With the full pipeline released, new architectures, data mixtures or training objectives can be trained and compared against REKI under fixed conditions. For memory, we rely on a simple approach that takes advantage of the existing VLA architecture, without any additional module: the action expert's own self-attention reads the registers of past frames. Our code base also makes other memory designs easy to implement: for this rebuttal, we added HAMLET, MemoryVLA, a feature cache and frame stacking, and we will release them with optimized, compiled implementations.
  3. An analysis of how memory helps VLAs. We analyse how memory changes the behaviour of VLAs, and find that it consistently reduces oscillation: across several memory designs in simulation, and for REKI on a real robot.

Additional experiments

We ported HAMLET and MemoryVLA from the authors' released code to our pipeline, which is much stronger than the VLAs they were built on (GR00T N1.5 and a 7B OpenVLA-based model; see REKI vs GR00T N1.7 in App. Table 2). HAMLET summarizes each frame with 4 learnable tokens in the VLM, and a small transformer combines those of recent frames for the action expert. MemoryVLA keeps compressed features of past frames in a bank of fixed size, which the features of the current frame attend to through a gate. We also compare REKI with two simple baselines: a feature cache, in which the action expert attends to the VLM features of all frames in the history window instead of the current one only, and frame stacking, in which the VLM processes all past frames in its prompt. To isolate the effect of the memory design, we trained HAMLET, MemoryVLA and the feature cache in the same setup as REKI, either finetuned from the REKI checkpoint or trained from scratch from the Qwen3.5-2B VLM. Below, we compare the designs on inference cost (A), success on three benchmarks (B) and oscillation (C).

A. Inference cost

MethodIndependent encodingCompressed per frameFixed-size expert contextInference (4 frames)Inference (16 frames)
Frame stacking✗✗✗37.0 ms88.2 ms
Feature cache✓✗✗29.6 ms38.9 ms
REKI✓✓✗27.5 ms28.3 ms
HAMLET✓✓✓27.3 ms27.2 ms
MemoryVLA✓✓✓30.6 ms30.6 ms

Time per predicted action chunk on one H100.

We measure inference on one H100 (two 448×448 cameras, chunks of 10 actions, 10 flow steps). The official HAMLET and MemoryVLA code has no compiled inference path, so we compiled all models ourselves, which reduces the prediction time per chunk from about 130 ms to about 30 ms.

With a short history, memory is almost free if each frame is encoded only once: with 4 frames, REKI, the feature cache, HAMLET and MemoryVLA take 27.3 to 30.6 ms per chunk. Frame stacking is slower (37.0 ms), because the language model must process all frames again at every step. With a longer history, the cost grows for the designs that keep all the VLM tokens of each past frame: with 16 frames, frame stacking needs 88.2 ms, and the feature cache, which attends to about 6,900 past tokens, needs 38.9 ms, while REKI attends to about 500 and stays at 28.3 ms. Compact per-frame tokens therefore keep the cost almost constant, a promising property for long-horizon tasks. HAMLET and MemoryVLA go further and give the action expert a context of fixed size, whatever the history length: 4 memory tokens in HAMLET, and the current frame fused with the memory in MemoryVLA. This fixed budget may, however, limit how much information the model can use over long horizons.

AuthorsOpenReview ↗

Common answer to all reviewers (2/3)

B. Benchmark comparison of memory designs

We compare the memory designs on LIBERO-Plus, RoboTwin hard and RoboCasa365. We add RoboCasa365 because this recent benchmark is challenging and diverse: it includes long-horizon composite tasks, some unseen in training, and it is far from saturated.

Method\matrixRoboCasa365\crfinetuned\cr(25k steps)\matrix{\text{RoboCasa365} \cr \text{finetuned} \cr \text{(25k steps)}}\matrixRoboCasa365\crscratch\cr(40k steps)\matrix{\text{RoboCasa365} \cr \text{scratch} \cr \text{(40k steps)}}\matrixRoboTwin hard\crfinetuned\cr(20k steps)\matrix{\text{RoboTwin hard} \cr \text{finetuned} \cr \text{(20k steps)}}\matrixRoboTwin hard\crscratch\cr(40k steps)\matrix{\text{RoboTwin hard} \cr \text{scratch} \cr \text{(40k steps)}}\matrixLIBERO-Plus\crfinetuned\cr(15k steps)\matrix{\text{LIBERO-Plus} \cr \text{finetuned} \cr \text{(15k steps)}}\matrixLIBERO-Plus\crscratch\cr(30k steps)\matrix{\text{LIBERO-Plus} \cr \text{scratch} \cr \text{(30k steps)}}
REKI39.267.1⋅33.1⋅13.8\displaystyle{\mathbf{39.2} \atop \scriptstyle 67.1 \cdot 33.1 \cdot 13.8}34.260.0⋅28.2⋅11.2\displaystyle{\mathbf{34.2} \atop \scriptstyle 60.0 \cdot 28.2 \cdot 11.2}49.9\mathbf{49.9}25.4\mathbf{25.4}90.490.486.0\mathbf{86.0}
Feature cache38.165.1⋅31.1⋅14.8\displaystyle{\mathbf{38.1} \atop \scriptstyle 65.1 \cdot 31.1 \cdot 14.8}35.063.1⋅28.4⋅9.9\displaystyle{\mathbf{35.0} \atop \scriptstyle 63.1 \cdot 28.4 \cdot 9.9}48.5\mathbf{48.5}22.922.990.290.285.3\mathbf{85.3}
HAMLET, published (last-frame supervision)34.158.8⋅28.8⋅11.8\displaystyle{34.1 \atop \scriptstyle 58.8 \cdot 28.8 \cdot 11.8}33.258.6⋅27.6⋅10.1\displaystyle{33.2 \atop \scriptstyle 58.6 \cdot 27.6 \cdot 10.1}44.944.922.122.192.2\mathbf{92.2}85.9\mathbf{85.9}
HAMLET, with REKI's all-frame supervision37.764.6⋅29.5⋅15.8\displaystyle{\mathbf{37.7} \atop \scriptstyle 64.6 \cdot 29.5 \cdot 15.8}35.061.9⋅31.0⋅8.9\displaystyle{\mathbf{35.0} \atop \scriptstyle 61.9 \cdot 31.0 \cdot 8.9}48.2\mathbf{48.2}26.9\mathbf{26.9}90.890.885.9\mathbf{85.9}
MemoryVLA30.956.2⋅21.8⋅11.5\displaystyle{30.9 \atop \scriptstyle 56.2 \cdot 21.8 \cdot 11.5}31.256.2⋅24.4⋅10.0\displaystyle{31.2 \atop \scriptstyle 56.2 \cdot 24.4 \cdot 10.0}48.5\mathbf{48.5}22.422.485.885.885.4\mathbf{85.4}

Success rate (%). Small numbers: atomic seen · composite seen · composite unseen. Bold: within evaluation noise of the best result in the column (95% interval over evaluation episodes).

When finetuned with our training setup, HAMLET scores 1.8 points above REKI on LIBERO-Plus (92.2 vs 90.4), but 5.1 points below on RoboCasa365 (34.1 vs 39.2) and 5.0 points below on RoboTwin hard (44.9 vs 49.9). Our investigation shows that a key choice behind this gap is the supervision of every frame that we introduce in REKI. It multiplies the number of supervised action chunks per step at no training cost, since the frames are already encoded. Interestingly, while the authors of HAMLET supervised only the last frame, presumably for consistency with inference, we observe that on the more challenging benchmarks supervising on intermediate frames gives consistent improvements: on RoboCasa365 and RoboTwin hard HAMLET supervised on every frame gains 3.6 and 3.3 points (37.7 and 48.2), and REKI loses 5.0 points on RoboCasa365 when only the last frame is supervised (response to Reviewer ZLGz, W2).

In the same training setup, REKI, HAMLET with all-frame supervision and the feature cache are competitive alternatives: they are within 1.5 points of each other on RoboCasa365, within 1.7 points on RoboTwin hard when finetuned and within 1 point on LIBERO-Plus. These differences are within the statistical noise of the evaluations (see below), so we do not interpret them. What these three designs share is that their memory is built directly from the VLM outputs of recent frames, each encoded independently. MemoryVLA, whose memory stores mostly vision-encoder features, scores lower on RoboCasa365 (30.9 vs 39.2 finetuned, 31.2 vs 34.2 from scratch) and on LIBERO-Plus when finetuned (85.8 vs 90.4). MemoryVLA's lower results may be partly attributed to its long training windows (16 frames), which reduce the diversity within each batch.

Evaluation noise. In simulation, the 95% confidence interval is about ±1.5 points over 50 tasks with 50 episodes each, as in RoboCasa365. Experimentally, re-training the same model or re-evaluating the same checkpoint, for example with a different compiled version, changes the results by about 1 point on average.

AuthorsOpenReview ↗

Common answer to all reviewers (3/3)

C. Oscillation analysis

ModelSuccessOscillating episodes (% ± 95% interval)Reversals per chunk pair
REKI34.66.1 ± 1.55.9
REKI without memory at inference (K = 1)31.523.8 ± 2.69.3
Feature cache34.27.3 ± 1.66.2
Feature cache without memory at inference (K = 1)34.121.5 ± 2.58.8
HAMLET, supervised on all frames34.74.8 ± 1.35.8
HAMLET without memory at inference (K = 1)25.437.1 ± 3.014.4

RoboCasa365, trained from scratch (40k steps), 50 tasks × 20 episodes with the same seeds for every model; success therefore differs slightly from Table B (50 episodes per task).

The reduction in oscillation that we reported for REKI (Fig. 5) holds across memory designs. With the same detector (reply to Reviewer 5tf5, W2 and Q3), 4.8 to 7.3% of the episodes oscillate with any of the three designs, against 21 to 37% when memory is removed at inference. Recent work reports this effect qualitatively [1]; our results strengthen the hypothesis that memory is a key, low-cost remedy for this behaviour.

[1] M. Zeng, A. Agarwal, A. Bati, B. Lee, S. Ancha, R. Tedrake. Revisiting Open-Loop Execution in Robotics: Toward Reactive, Higher-Performing Policies. arXiv:2608.15938, 2026.

In summary, REKI, HAMLET and the feature cache perform similarly when each frame is encoded only once, which keeps memory cheap, and every frame receives direct loss supervision, which helps on the more challenging benchmarks. Across designs, memory consistently helps and reduces oscillation. We will revise the paper accordingly, present our approach as one of several memory designs with comparable results, and release all memory designs with the pipeline. We thank the reviewers again for their detailed feedback, and we are happy to answer any remaining or follow-up questions. The individual points of each review are answered in the replies to each reviewer.

Area_Chair_kM8TOpenReview ↗

Reminder: Author–Reviewer Discussion Deadline Approaching

Dear Reviewers and Authors,

Thank you to the reviewers for your time, effort, and dedication in reviewing this paper. This AC also appreciates the authors' detailed rebuttal, which addresses the reviewers' comments and includes additional clarifications and experimental results.

To the reviewers: As the author–reviewer discussion deadline approaches, please carefully review the authors' responses and assess whether they adequately address your concerns, if you haven't already. If any concerns have not been fully addressed, please let the authors know what further clarification or evidence would be helpful.

Thank you again for your valuable contributions and constructive discussion.

Best,

Your AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.