betaFeedback

WorksComputer Science

ReRead: Wrong Predictions, Useful Representations - Correcting Frozen Robot Policies by Re-reading Their Own Representations

Abstract

When a pretrained robot policy fails on challenging tasks, common remedies include retraining the backbone, adding an external visual encoder, or introducing a memory module. We argue that wrong predictions do not imply wrong representations: a policy can retain the required information yet fail to read it out as the correct action. To test this view, we propose ReRead: with the backbone frozen, a corrector re-reads the current and two previous caches to predict an action residual. The corrector sees no images, is trained solely on offline demonstrations from all 50 RoboTwin 2.0 tasks, and adds only 4.17% latency. Ablations and interventions show that the correction relies on the backbone's own representations: none of four external visual encoders adds further gain, and swapping in past caches from other trajectories sharply increases action error. On the 11 hardest RoboTwin 2.0 tasks, ReRead improves the success rates of LingBot-VLA, π0.5π_{0.5}, and Fast-WAM by 23.45, 13.09, and 8.00 percentage points, respectively. In paired evaluation on all 50 tasks, it raises Fast-WAM's average success rate from 90.73% to 92.66%. On a Flexiv dual-arm robot, it raises success on a phase-ambiguous task from 0% to 36%.

Introduction

When a pretrained robot policy fails on challenging tasks, common remedies include retraining the backbone, adding an external visual encoder, or introducing a memory module [6, 13, 18]. These remedies share an implicit assumption: if the predicted actions are wrong, the policy’s representations must lack task-relevant information.

But failure has another possible cause: the policy already has the information it needs, yet fails to read it out as the correct action. Similar findings in image recognition show that retraining only the classifier can improve accuracy while keeping the learned representations fixed [11, 12]. Robot tasks have a further property: the current frame is often insufficient to determine the action, because the action also depends on the current task phase. The information needed to distinguish phases is not in the current frame, but it may already reside in the internal representations of the policy’s previous decisions, which are discarded once the actions are output.

We therefore argue that wrong predictions do not imply wrong representations. The attention keys and values (K/V) cached by the backbone, the robot state, and temporal information form an internal memory, and we call its task-relevant information the representation. (In Figure 1 and Figure 2, “R” stands for “Representations”.) The process that maps the internal memory to an action is the readout, and the action finally returned is the prediction. A backbone error may arise because the required information was never in the caches, or because it is in the caches but is not read out as the correct action. In the latter case, it is the readout that needs to be improved, and the backbone need not be retrained. This corresponds to the classical decomposition under squared loss: the prediction error equals the representation error plus the readout gap.

Figure 1. Overview of ReRead.

Figure 2. Illustration of ReRead training along expert trajectories.

To test this view, we propose ReRead (Figure 1): with the backbone frozen, a new corrector re-reads the representations cached by the backbone. The backbone generates candidate actions as usual, and ReRead stores the native visual and action K/V from each of its decisions. Using the candidate action as the query, the corrector reads the caches of the current and the two previous decisions and outputs an action residual, which is added back to the candidate action. The corrector sees no images, does not retrain the backbone, and does not re-encode the history. It is trained solely on offline demonstrations with an action MSE loss and adds 11.66 ms of latency per decision (4.17%).

We train ReRead on offline demonstrations from all 50 tasks of RoboTwin 2.0 [4]. Fast-WAM [23] has a reported average success rate of 91.83% on these tasks, but its failures are concentrated in a few tasks: the 11 tasks with the lowest published success rates (Hard11) account for about 66.5% of the failures. We use Hard11 as an evaluation subset to analyze cases in which the policy retains the required information but predicts the wrong action, and evaluate the overall effect of re-reading on all 50 tasks.

The experiments are organized around four questions. First, when the backbone errs, is the required information still in the caches? Re-reading the current cache alone reduces the native candidate’s open-loop MSE by 61.45%. With ReRead, the success rates of LingBot-VLA, π0.5\pi_{0.5}, and Fast-WAM on Hard11 improve by 23.45, 13.09, and 8.00 percentage points, respectively. In our paired evaluation on all 50 tasks, Fast-WAM’s average success rate rises from 90.73% to 92.66%.

Second, can prediction and representation be evaluated separately? Intervention experiments show that the corrected action is determined mainly by the caches: increasing the error of the candidate action 2-fold increases the error of the corrected action by only 12.08%, whereas replacing the past caches with those from other trajectories of the same task increases it 12.37-fold.

Third, do backbone failures stem from insufficient perception? None of the four external visual encoders outperforms ReRead, whereas replacing the past caches markedly changes the corrected action. These results do not support the perception-bottleneck explanation.

Fourth, when the current frame cannot distinguish phases, where is the required information? On a phase-ambiguous task, ReRead raises the success rate from 2% to 50% in simulation and from 0% to 36% on a real Flexiv dual-arm robot. Swapping in caches from the opposite phase moves the corrected action toward the other phase, indicating that the required information lies in the caches of previous decisions.

Our contributions are as follows:

  • We propose a new perspective: wrong predictions do not imply wrong representations. We decompose the prediction error into the representation error and the readout gap, and estimate the part that re-reading can eliminate.

  • To test this perspective, we propose ReRead, which freezes the backbone and trains a corrector solely on offline demonstrations to re-read the backbone’s cached representations and correct the actions. Our training and inference code and model weights are publicly available at https://github.com/tan2355/reread.

  • Interventions and ablations show that the correction relies on the backbone’s own caches. Phase information also remains in the caches of previous decisions. Prediction and representation can therefore be evaluated separately.

Related Work

Gap between Representations and Outputs

Good internal representations do not imply good outputs. In image recognition, the representation and the classifier can be adjusted separately for long-tailed recognition [11], and the representations of models that rely on spurious correlations still contain robust features [12]. In language models, truth signals that do not depend on the surface form of the answer can be read out from internal activations [3], and simply intervening on attention-head activations improves answer truthfulness [14]. Probing studies examine both how much information can be read out from representations [17] and how much these readouts depend on the capacity of the probe itself [10]. Unlike these works, we focus on the continuous actions of frozen robot policies, where the information is also spread across the past few decisions, and we directly quantify how much error re-reading can eliminate.

Temporal Memory in Robot Policies. History helps policies distinguish visually similar task phases. Octo processes recent observations [6]. MemoryVLA and HAMLET represent, retrieve, or compress history to condition action generation [13, 18]. GeoMem-VLA stores geometric and observation representations in temporal memory and retrieves them to guide action generation [26]. HyVLA-0.5 compresses visual history through temporal-spatial attention before passing the resulting representations to the VLM [25]. These methods use history to condition action generation. If the error lies in the readout, adding historical context does not necessarily help. In contrast, ReRead leaves the backbone’s inputs and candidate generation unchanged and, once the candidate action is produced, uses a corrector to read the current and past caches.

Residual Correction for Frozen Policies. Residual policies add a small adjustment on top of existing actions while preserving the backbone’s original capabilities. Residual Policy Learning and FISH use reinforcement learning to optimize a residual on top of the backbone [7, 19]. Policy Decorator freezes a large imitation policy and learns a small residual through online interaction [24]. Dejavu freezes a VLA, retrieves information from an experience database, and learns action corrections from interaction rewards [21]. Within a framework of multi-round human corrections, I3L also evaluates a supervised residual correction scheme [1]. These methods all rely on online interaction, rewards, or additional human-correction data. ReRead uses only existing offline demonstrations and reads the backbone’s caches from the current episode to test whether they retain the information needed for correct actions.

Separating Prediction from Representation

Whether an action prediction is wrong and whether the caches contain useful information are two different questions. We distinguish them by decomposing the prediction error into the representation error and the readout gap.

Problem Formulation

At the nn-th decision, the frozen backbone receives images InI_n, the robot state sns_n, and the instruction ℓ\ell, denoted xn=(In,sn,ℓ)x_n = (I_n, s_n, \ell), and generates a candidate action chunk from sampling noise ξn\xi_n

An0=πθ(xn;ξn)∈RH×d,(1)A_n^0 = \pi_\theta(x_n;\xi_n) \in\mathbb{R}^{H \times d}, \tag*{(1)}

where HH is the chunk length and dd is the action dimension. The native K/V, state, and temporal information produced by this decision together form a cache. ReRead combines the current and past caches into a memory Mn\mathcal{M}_n and learns a residual correction

A^n=An0+Rϕ(An0,Mn),(2)\widehat{A}_n = A_n^0 + R_\phi(A_n^0,\mathcal{M}_n), \tag*{(2)}

supervised by the expert action An⋆A_n^\star, while the backbone parameters θ\theta remain frozen.

Two Sources of Prediction Error

In what follows, we fix the backbone and the evaluation distribution and omit the subscript nn. We denote the corrector’s input by Z=(A0,M)Z = (A^0,\mathcal{M}) and its output residual by rϕ(Z)=Rϕ(A0,M)r_\phi(Z) = R_\phi(A^0,\mathcal{M}). The mean squared error after adding a residual rr is R(r)=E∥A⋆−A0−r(Z)∥2\mathcal{R}(r) = \mathbb{E}\lVert A^\star- A^0 - r(Z)\rVert^2, where R(0)\mathcal{R}(0) is the error of executing the candidate action directly. Under squared loss, the best prediction from ZZ is the conditional mean mZ=E[A⋆∣Z]m_Z = \mathbb{E}[A^\star\mid Z]. By the projection property of the conditional mean [8], we have

R(0)=E∥A⋆−mZ∥2⏟κ(Z): representation error+E∥mZ−A0∥2⏟G(Z): readout gap.(3)\mathcal{R}(0) = \underbrace{\mathbb{E}\lVert A^\star- m_Z\rVert^2}_{\kappa(Z):\text{ representation error}} + \underbrace{\mathbb{E}\lVert m_Z - A^0\rVert^2}_{G(Z):\text{ readout gap}}. \tag*{(3)}

The first term is the representation error: the minimum prediction error given the candidate action and the caches. Hence, even when the prediction error is large, the representation error can still be small; the optimal residual r⋆(Z)=mZ−A0r^\star(Z) = m_Z - A^0 exactly eliminates the entire readout gap.

The optimal readout is not directly available, but its prediction error can be bounded above with a trained corrector. When R(0)>0\mathcal{R}(0) > 0,

bϕ(Z)=1−R(rϕ)R(0)≤G(Z)R(0),b_\phi(Z) = 1 - \frac{\mathcal{R}(r_\phi)}{\mathcal{R}(0)} \le\frac{G(Z)}{\mathcal{R}(0)},
K(Z)R(0)≤1−bϕ(Z).(4)\frac{\mathcal{K}(Z)}{\mathcal{R}(0)} \le1 - b_\phi(Z). \tag*{(4)}

Here, bϕ(Z)b_\phi(Z) is the fraction of the error actually reduced by the corrector. The eliminated error cannot exceed the readout gap, and the ratio of the representation error to the initial error is at most 1−bϕ1-b_{\phi}. In the experiments, we use held-out data to estimate both bϕb_{\phi} and the corresponding upper bound on the representation error. See Appendix § 8 for the proofs and measurement definitions.

Roles of the Candidate and Past Caches

Candidate changes and cache reading. Suppose the candidate is replaced with an arbitrary UU, while the memory M\mathcal{M} stays unchanged. If, given the memory, the candidate provides no additional information about the target action, i.e., E[A⋆∣U,M]=E[A⋆∣M]=h(M)\mathbb{E}[A^\star\mid U,\mathcal{M}] = \mathbb{E}[A^\star\mid\mathcal{M}] = h(\mathcal{M}), then

r⋆(U,M)=h(M)−U,f⋆(U,M)=h(M)(5)r^\star(U,\mathcal{M}) = h(\mathcal{M}) - U,\qquad f^\star(U,\mathcal{M}) = h(\mathcal{M}) \tag*{(5)}

where f⋆=U+r⋆f^\star= U + r^\star is the optimal corrected action. That is, the optimal residual exactly cancels the change in the candidate, and the final action is determined solely by the caches.

Why history remains useful. Let ZcZ_c denote the current candidate and the current cache, let Zm=(Zc,H−)Z_m = (Z_c,\mathcal{H}^{-}) denote the input that further includes the ordered history, and let mi=E[A⋆∣Zi]m_i = \mathbb{E}[A^\star\mid Z_i]. After adding the history, the optimal error decreases by

Ghist=K(Zc)−K(Zm)=E∥mm−mc∥2.(6)G_{\mathrm{hist}} = \mathcal{K}(Z_c) - \mathcal{K}(Z_m) = \mathbb{E}\lVert m_m - m_c \rVert^2 . \tag*{(6)}

Thus, the gain is positive as long as the history changes the conditional mean of the target action. For example, two phases with similar current frames but different target actions can be distinguished using the past caches. This gain

does not require the past action predictions to be correct. Appendix § 8.§ 4 constructs an example in which all past predictions are wrong, yet the caches still recover the phase.

ReRead: Re-reading the Policy’s Cache

Native Caches

After each decision, ReRead (Figure 2) directly stores the native K/V computed by the backbone, rather than re-encoding the observations with an external encoder. Each cache record contains K/V from multiple layers, the robot state, the decision anchor (the time step on the demonstration trajectory at which a new decision is made, once every S=20S = 20 executed steps), and the executed prefix. The visual K/V come from the prefill of the current observation, and the action K/V, which come from the last denoising call, are the backbone’s internal plan when generating the candidate action. By default, the corrector reads the caches of the current and the two previous decisions (corresponding to tnt_n, tn−St_n-S, tn−2St_n-2S) and receives no images; all the scene content it sees is computed by the backbone.

For cache τ\tau, source layer ll, and token position ii, we construct

Bτli=LN⁡(WK sg⁡(Kτli)+WV sg⁡(Vτli)+Wssτ)(7)B_{\tau li} = \operatorname{LN}\left(W_K\,\operatorname{sg}(K_{\tau li}) + W_V\,\operatorname{sg}(V_{\tau li}) + W_s s_{\tau}\right) \tag*{(7)}

where LN denotes layer normalization, sg denotes stop-gradient, and WKW_K, WVW_V, WsW_s project the frozen K/V and the state into the corrector’s space. The positional encoding PτliP_{\tau li} marks the source layer, camera, modality, and spatial or action position of each token, and also includes the cache age and the executed prefix. When reading, B+PB + P serves as the keys and BB as the values, so matching considers both content and position, while only content is retrieved.

Candidate Queries and Residual Correction

The candidate action is the plan that the backbone intends to execute, and the corrector uses it as the query to decide what to read from the caches. Specifically, it directly uses the full candidate action values and embeds each action position as a query

q0=WaUn+Eact.(8)q_0 = W_a U_n + E^{\mathrm{act}}. \tag*{(8)}

Here, EactE^{\mathrm{act}} denotes the action-position embedding. At inference time, Un=An0U_n = A_n^0; during training, UnU_n is a perturbed candidate (see § 4.3). The corrector has five layers, each applying query self-attention, cross-attention to the caches, and a feed-forward network in turn, all with pre-norm residual connections:

qj′=qj+SAj(LN(qj)),(9)q'_j = q_j + \mathrm{SA}_j(\mathrm{LN}(q_j)), \tag*{(9)}
qj′′=qj′+CAj(LN(qj′),B+P,B;M),(10)q''_j = q'_j + \mathrm{CA}_j(\mathrm{LN}(q'_j), B + P, B; M), \tag*{(10)}
qj+1=qj′′+FFNj(LN(qj′′)),(11)q_{j+1} = q''_j + \mathrm{FFN}_j(\mathrm{LN}(q''_j)), \tag*{(11)}

where the mask MM masks out missing past caches and those dropped during training; the layers do not share attention parameters. The final output is

A^n=Un+WoLN(q5).(12)\widehat{A}_n = U_n + W_o \mathrm{LN}(q_5). \tag*{(12)}

The output head is zero-initialized, so the initial residual is zero and the corrected action equals the input candidate. The corrector has 198.52M parameters and adds 11.66 ms per decision; see Appendix § 7.§ 1 for cost measurements.

Supervised Training

Candidate perturbation. If the candidate always remained unchanged during training, the corrector could reduce the error merely by calibrating the candidate, without reading the caches. Therefore, during training, we add sparse noise only to the candidate action values provided to the corrector:

Un,h,j=An,h,j0+vn,hmn,hϵn,h,j,U_{n,h,j} = A^0_{n,h,j} + v_{n,h}m_{n,h}\epsilon_{n,h,j},
mn,h∼Bernoulli⁡(0.2),ϵn,h,j∼N(0,0.052),(13)m_{n,h} \sim\operatorname{Bernoulli}(0.2), \qquad\epsilon_{n,h,j} \sim\mathcal{N}(0, 0.05^2), \tag*{(13)}

where each action position is selected with probability 0.2, and Gaussian noise with a standard deviation of 0.05 is added to the arm joints at the selected positions (see Appendix § 7); vn,hv_{n,h} indicates whether the label at that position is valid. The backbone inputs, the native K/V, and the expert targets all remain unchanged. The corrector receives only the perturbed candidate and the backbone’s caches, without direct access to environment observations. By Eq. (5), when the caches suffice to determine the target action, the optimal residual exactly cancels the perturbation.

Training objective. The supervision target An⋆A_n^\star is the original continuous action chunk at the decision anchor, and training uses only the action MSE:

Lact=∑b,h,jvb,h(A^b,h,j−Ab,h,j⋆)2d∑b,hvb,h.(14)\mathcal{L}_{\mathrm{act}} = \frac{\sum_{b,h,j} v_{b,h}(\widehat{A}_{b,h,j} - A^\star_{b,h,j})^2} {d\sum_{b,h} v_{b,h}}. \tag*{(14)}

Causal caching. Training and deployment share the same causal path: the corrector can only read the current and past caches. During training, we step through each demonstration trajectory in the order of its decision anchors, run the backbone only once at each anchor, and store the resulting native K/V in the cache, where later anchors directly reuse them as history (Figure 2). Thus, each training sample requires only one backbone forward pass, the backbone’s computation does not grow with the number of past caches, and gradients do not backpropagate across decisions. The K/V in the cache remain unchanged, whereas the content projection and age encoding are recomputed at every read with the latest corrector parameters.

Experiments

Experimental Setup

Tasks and metrics. We evaluate on the 50 tasks of RoboTwin 2.0 [4], with 100 episodes per task in each of the clean and random settings. On Hard11, we evaluate 25 episodes per task and setting, 550 episodes in total. We re-evaluate both the backbones and ReRead on Hard11 under this protocol and report the success rates.

Training. On the RoboTwin 2.0 benchmark, we train all correctors from scratch using offline demonstrations from all 50 tasks, with the backbones frozen. We use the same demonstrations and splits for all correctors and train for 20K steps with a global batch size of 1024, using only the action MSE as the objective. Both training and inference use D=20D = 20 denoising steps and replan after executing SS steps, with chunk length H=32H = 32 and action dimension d=14d = 14. Each ablation variant is trained separately. For Fast-WAM, the Hard11 and full-benchmark evaluations use the same ReRead weights. See Appendix § 7 for implementation details and resource measurements.

Open-loop measurement. The open-loop analysis fixes the trained ReRead and computes statistics over the first SS executed steps on the 22 held-out expert trajectories of Hard11. The past K/V come from the backbone’s forward passes when it makes its own predictions.

Is the Required Information Still in the Caches?

Open loop: readout gap. Re-reading the current cache alone reduces the native candidate’s MSE from 19.74 × 10−410^{-4} to 7.61 × 10−410^{-4}, a 61.45% reduction. Adding the caches of the two previous decisions further reduces it to 1.49 × 10−410^{-4}, a total reduction of 92.45% (Figure 3). The MSE decreases relative to the native candidate on all 11 tasks, and on 10 of them it decreases further once the past caches are added. We thus estimate that the representation error accounts for at most about 7.55% of the initial error. The candidate sampling variance accounts for only 4.20% of the prediction error, and directly averaging six candidates reduces the MSE by only 3.52%, far less than the reduction from reading the caches (Appendix C).

Figure 3. Open-loop readout error.

Closed loop: three backbones. We attach the corrector to LingBot-VLA, π0.5\pi_{0.5}, and Fast-WAM, which differ in architecture and include two VLAs and one video world action model. ReRead improves their success rates on Hard11 by 23.45, 13.09, and 8.00 percentage points, respectively (Table 1). See Appendix D.1 (Table A8) for per-task results.

ModelClean↑Random↑Average↑
LingBot-VLA [22]46.5553.4550.00
ReRead-LingBot-VLA75.2771.6473.45
π0.5\pi_{0.5} [2]30.1830.5530.36
ReRead-π0.5\pi_{0.5}45.4541.4543.45
Fast-WAM [23]76.7370.1873.45
ReRead85.4577.4581.45

Table 1. Closed-loop results on Hard11 across three backbones (local re-evaluation).

TaskFast-WAM Backbone only CFast-WAM Backbone only RFast-WAM ReRead CFast-WAM ReRead Rπ0.5\pi_{0.5} Backbone only Cπ0.5\pi_{0.5} Backbone only Rπ0.5\pi_{0.5} ReRead Cπ0.5\pi_{0.5} ReRead RLingBot-VLA Backbone only CLingBot-VLA Backbone only RLingBot-VLA ReRead CLingBot-VLA ReRead R
open_microwave1382523131156112123
hanging_mug10191610005156109
turn_switch1918161565131110161617
place_can_basket20161918148171710111715
move_stapler_pad201520175410513191918
stack_bowls_three20212124910131414151919
pick_diverse_bottles2319232051314717172419
place_mouse_pad2120232025101412152322
handover_block2215242210510710101515
place_object_basket22202422912192024242319
move_can_pot21222422101191212132021
Average (%)73.4581.4530.3643.4550.0073.45

Table A8. Successful episodes on Hard11. C/R: clean/random.

Full benchmark. Table 2 reports the effect of re-reading alongside results from other models trained on RoboTwin 2.0 demonstrations. In our paired evaluation on all 50 tasks, Fast-WAM achieves an average success rate of 90.73% (Fast-WAM†), and ReRead raises it to 92.66%. See Appendix D for per-task results.

ModelClean↑Random↑Average↑
π0.5\pi_{0.5} [2]42.9843.8443.41
LingBot-VLA [22]86.5085.3485.92
Motus [2]88.6687.0287.84
HyVLA-0.5 [25]90.9090.0690.48
GeoMem-VLA [26]91.1091.2491.17
LingBot-VA [15]92.9091.5092.20
Fast-WAM [23]91.8891.7891.83
Fast-WAM† [23]91.0690.4090.73
ReRead (Ours)93.2092.1292.66

Table 2. Results on all 50 tasks of RoboTwin 2.0. †: local re-evaluation; other baselines are published values.

Fast-WAM achieves an average success rate of 90.73% (Fast-WAM†), and ReRead raises it to 92.66%. See Appendix D for per-task results.

Are Prediction and Representation Separable?

Bidirectional interventions. If the corrected action is determined by the caches, it should remain nearly unchanged when only the candidate changes, but change markedly when only the caches change. We fix the trained ReRead and apply two opposite interventions on the same trajectories: one keeps the caches unchanged and adds sparse Gaussian noise to the candidate; the other keeps the candidate and the current K/V unchanged and replaces only the caches of the two previous decisions (design in Appendix C; results in Figure 4 and Figure 5). When only the candidate is changed, noise with σ=0.10\sigma= 0.10 increases the candidate MSE 2-fold, whereas the MSE of the corrected action increases by only 12.08%.

Figure 4. Candidate perturbation.

History replacement bar chart

Figure 5. History replacement.

When only the caches are changed, swapping in the history from other trajectories of the same task increases the MSE from 1.49 × 10−410^{-4} to 18.43 × 10−410^{-4} (12.37-fold), close to the level of the native candidate; swapping the temporal order of the two past caches also increases the MSE 3.69-fold, indicating that the corrector uses the temporal order of the caches. These are the two input paths in Eq. (5): changes in the candidate are largely canceled by the residual, whereas changes in the caches alter the action through re-reading. All conditions share the same weights, so the performance differences reflect the effect of cache replacement.

Corrective value of high-error history. When a past decision predicts the action inaccurately, is the cache it leaves behind still useful? We fix the current candidate, the current K/V, and all observations, and rerun the backbone only at the two past anchors with six preset seeds, obtaining six sets of history; in each set, the candidate and the K/V come from the same forward pass. We divide the six sets into low-, medium-, and high-error groups by the error of the past candidates (protocol in Appendix C). Relative to the current-only readout, the three groups reduce the current MSE by 72.01%, 72.01%, and 64.13%, respectively (Figure 6): higher past error yields a slightly smaller gain, but the highest-error group still retains most of the corrective value.

Figure 6. MSE reduction across past prediction error groups.

This gain comes from the content of the past K/V rather than from the past states or temporal information. Replacing the past K/V with the current K/V removes the gain;

zeroing out only the past K/V while keeping the states and temporal information raises the error to 14.92×10−414.92 \times10^{-4} (Tab. A6 in the appendix). With naturally occurring history, the MSE of the past candidates varies 38.45-fold, yet the error reduction after reading the history remains between 77.66% and 82.04% (Tab. A7 in the appendix).

Is Perception the Missing Piece?

External visual encoders. If the backbone’s failures stem from insufficient perception, adding visual information should yield gains. We equip the corrector with an external frozen visual branch that reads the four frames [t−6,t−4,t−2,t][t - 6, t - 4, t - 2, t], and compare four visual encoders (Tab. 3, group A). These branches add about 86M pretrained parameters and 86M trainable parameters, yet their average success rates range from 78.91% to 80.36%, all below that of ReRead without external vision (81.45%). With DINOv3 fixed, the four short-term frames and the current single frame both yield 80.36%, and removing the cross-decision caches yields 79.09%. These results do not support the explanation that the backbone’s failures stem from insufficient perception.

Which K/V to read. We separately evaluate reading only the action K/V, reading only the visual K/V, and a no-K/V control (Tab. 3, group B). Reading only one of the two yields average success rates of 81.09% and 80.55%, respectively, both comparable to the 81.45% obtained by reading the full caches. The action K/V come from the computation that generates the candidate action; they contain only one third of the tokens in the full caches, yet still suffice for effective correction. The no-K/V control has the same architecture, parameter count, and training setup as ReRead, differing only in that all K/V are removed; its success rate drops to 75.82%.

Where Is the Phase Information?

Cross-decision caches. When the current frame cannot distinguish phases, past caches can help tell them apart (Eq. (6)). In closed-loop evaluation, we change the number of readable past caches from the default 2 to 0, 1, and 4 (Memory0/1/4; Tab. 3, group C). Reading only the current cache (Memory0) raises success from 73.45% to 78.55%. Adding two past caches raises it further to 81.45%. Hard11 is selected by backbone success rate and does not target phase ambiguity, so we further test on a task with clear phase ambiguity below.

Phase-ambiguous task. Based on RoboTwin 2.0, we build a phase-ambiguous task (Figure 7, top): pick up a bottle, put it back in place, then open the gripper and return to the initial pose. The frames before grasping and after placing look similar, yet the next actions differ, so the current frame alone cannot determine the phase. Fast-WAM is first fine-tuned on 200 expert demonstrations and then frozen. ReRead keeps this backbone frozen and continues training from the corrector weights trained on all 50 RoboTwin 2.0 tasks. The two are compared scene by scene on 50 paired scenes. In simulation, ReRead raises the success rate from 2% to 50%. We also set up the same task on a Flexiv dual-arm robot platform, where ReRead raises the real-robot success rate from 0% to 36% (Table 4). See Appendix § 11 for task details.

Phase-ambiguous task: top simulation, bottom real Flexiv dual-arm robot

Figure 7. Phase-ambiguous task. Top: simulation. Bottom: real Flexiv dual-arm robot.

ModelClean↑Random↑Average↑
Simulation
Fast-WAM4.000.002.00
ReRead48.0052.0050.00
Real robot
Fast-WAM0.000.000.00
ReRead36.0036.0036.00

Table 4. Results on the phase-ambiguous task in simulation and on a real robot.

VariantClean↑Random↑Average↑
ReRead85.4577.4581.45
A. External vision and short-term dense history
DINOv3 [20]81.8278.9180.36
C-RADIOv3 [9]83.2776.3679.82
LingBot-Vision [5]80.0078.9179.45
V-JEPA 2.1 [16]82.5575.2778.91
DINOv3 (current image only)82.1878.5580.36
DINOv3 (current cache only)81.4576.7379.09
B. K/V sources
Action K/V only83.6478.5581.09
Visual K/V only83.6477.4580.55
No K/V78.1873.4575.82
C. History capacity
Memory078.5578.5578.55
Memory181.0976.3678.73
Memory481.4575.2778.36

Table 3. Closed-loop ablation of readout configurations.

Targeted intervention on phase history. To test whether ReRead uses phase information in past caches, we intervene at 14 pre-grasp and post-place decisions in 7 scenes. We fix the current input, the candidate action, and the current K/V, and replace only the caches of the two previous decisions with history from the same or the opposite phase; the replacements come from other trajectories and from the

other phase of the same scene. We measure the change in the corrected action with a directional coordinate: the expert action of the current phase is 0 and the expert reference action of the other phase is 1, so a positive shift means that the corrected action turns toward the other phase (definition in Appendix § 11.§ 2).

Compared with swapping in same-phase history, swapping in opposite-phase history turns the corrected action toward the other phase. Under cross-trajectory replacement, the action MSE is 127.52×10−4127.52 \times10^{-4} with same-phase history and 521.52×10−4521.52 \times10^{-4} with opposite-phase history; the mean directional shift (opposite phase minus same phase) is +0.33, positive in all seven scenes. With the other-phase history from the same scene, the mean shift is +0.31.

Broken down by replaced field (Figure 8), the effect comes mainly from the past action K/V: replacing only the action K/V yields shifts of +0.31 and +0.30 for the two history sources, close to the +0.33 and +0.31 obtained by swapping in the full history; replacing only the visual K/V or the past states yields shifts near zero. Phase information is thus stored in past native caches and read out mainly through action K/V. Past-state replacement does not reproduce the directional shift caused by action-K/V replacement.

Figure 8. Directional shift after replacing history fields.

Conclusion

We argue that wrong predictions do not imply wrong representations: a policy can retain the required information yet fail to read it out as the correct action. To test this view,

ReRead re-reads the frozen backbone’s native K/V to predict an action residual, without seeing images. It improves average success rates across three backbones on Hard11 and for Fast-WAM on all 50 tasks. Interventions and ablations show that correction relies on the backbone’s own caches, with phase information read out mainly through past action K/V. On a Flexiv dual-arm robot, ReRead raises success on the phase-ambiguous task from 0% to 36%. These findings support evaluating prediction and representation separately to understand policy failures. Our training and inference code and model weights are publicly available at https://github.com/tan2355/reread.

Implementation and Training Details

Model and training. ReRead uses a five-layer corrector to read the native K/V. All history-capacity variants use the same candidate action interface and loss function, differing only in the number of readable past caches. Memory1 and Memory4 reuse the continuous temporal metadata encoding; Memory0 keeps the three-slot interface, masks out the past K/V and states before content projection, and excludes past tokens through the attention mask. Table A1 lists the Fast-WAM configuration used for the history-capacity ablations. Seen/unseen refers to the task-instruction split.

ItemConfiguration
Backbone / optimization scopeFrozen Fast-WAM / corrector only
Action interface20 denoising steps, replan after 20 executed steps, 32×14 action chunk
K/V source layers (0-based)4, 14, 24, 29, visual prefill and last action denoising call
CorrectorWidth 1536, 5 layers, 24 heads, FFN 6144, ReLU
Trainable parameters198,523,406
Training budget16 GPUs, batch size 64 per GPU and 1024 globally, 20K steps
Optimizer / learning rateAdamW / peak 10−410^{-4}, 1000 warmup steps
Training lossMSE over the full valid action chunk
Candidate perturbationAction-position selection probability 0.2, normalized joint noise std. 0.05
Training tasksAll 50 RoboTwin 2.0 tasks
Data compositionclean:random = 1:10; clean/seen, random/seen+unseen

Table A1. History-capacity ablation settings.

Cache reading. For Fast-WAM, the native K/V are extracted from backbone layers 4, 14, 24, and 29, after normalization and before RoPE. At each source layer, we apply adaptive average pooling to the visual K/V, using a 4×84 \times8 grid for the head camera and a 4×44 \times4 grid for each wrist camera. This yields 64 visual tokens per layer, with all 32 action tokens retained. The cache slots store the older past cache, the more recent past cache, and the current cache, in that order. During training, we mask both past caches with probability 0.05 and only the older past cache with probability 0.0475. The current cache remains visible, and the same mask is shared across all source and reader layers.

Training Cost and Inference Overhead

We measure ReRead’s inference cost on a single A100 80GB GPU. At each decision, the backbone generates a full action chunk of length HH using DD denoising steps, and ReRead corrects it. Replanning follows after SS steps are executed.

As shown in Table A2, adding ReRead to Fast-WAM increases the mean latency per decision by 11.66 ms (4.17%). Table A3 reports the memory and computation overhead, including temporary memory for packing current and past K/V.

ConfigurationMean latency (ms)Throughput (decisions/s)
Fast-WAM279.893.573
ReRead291.553.430

Table A2. End-to-end inference cost.

ItemValue
Resident past K/V memory9 MiB
Temporary K/V packing memory13.5 MiB
Compute per decision87.84 GFLOPs

Table A3. Memory and computation overhead.

The corrector is trained on 16×16 \times H800 GPUs, with per-GPU and global batch sizes of 64 and 1024, respectively. Training runs for 20K steps and takes about 5.80 hours, or 92.73 GPU-hours.

Representation Error, Readout Gap, and Historical Information

Projection Decomposition and Error Bounds

We fix the backbone, the trained corrector, and the evaluation distribution. Let Z=(A0,M)Z = (A^0, \mathcal{M}) and Δ=A⋆−A0\Delta= A^\star- A^0. We assume that the actions and readouts are square-integrable, with the squared norm averaged over action dimensions. For brevity, we write K(Z)\mathcal{K}(Z), G(Z)G(Z), and bϕ(Z)b_\phi(Z) from the main text as K\mathcal{K}, GG, and bϕb_\phi. Define mZ=E[A⋆∣Z]m_Z = \mathbb{E}[A^\star\mid Z] and r⋆=mZ−A0r^\star= m_Z - A^0, and write

K=inf⁡fE∥A⋆−f(Z)∥2=E∥A⋆−mZ∥2,R(r)=E∥A⋆−A0−r(Z)∥2=K+E∥r−r⋆∥2.(15)\begin{aligned} \mathcal{K} &= \inf_f \mathbb{E}\lVert A^\star- f(Z)\rVert^2 \\ &= \mathbb{E}\lVert A^\star- m_Z\rVert^2, \\ \mathcal{R}(r) &= \mathbb{E}\lVert A^\star- A^0 - r(Z)\rVert^2 \\ &= \mathcal{K} + \mathbb{E}\lVert r-r^\star\rVert^2. \tag*{(15)} \end{aligned}

To prove this decomposition, expand A⋆−A0−r=(A⋆−mZ)+(r⋆−r)A^\star- A^0 - r = (A^\star-m_Z)+(r^\star-r). Since E[A⋆−mZ∣Z]=0\mathbb{E}[A^\star-m_Z \mid Z] = 0, the cross term has zero expectation. Writing G=E∥mZ−A0∥2G = \mathbb{E}\lVert m_Z-A^0\rVert^2 and setting r=0r=0 gives R(0)=K+G\mathcal{R}(0) = \mathcal{K} + G. Since A0A^0 is part of ZZ, any action readout f(Z)f(Z) can be written as A0+[f(Z)−A0]A^0+[f(Z)-A^0]. Thus, residual readout and direct action prediction have the same optimal risk K\mathcal{K}.

Let the approximation error of the trained corrector be ϵϕ=E∥rϕ−r⋆∥2\epsilon_\phi= \mathbb{E}\lVert r_\phi-r^\star\rVert^2. The same decomposition gives

R(rϕ)=K+ϵϕ,\mathcal{R}(r_\phi) = \mathcal{K} + \epsilon_\phi,
R(0)−R(rϕ)=G−ϵϕ.(16)\mathcal{R}(0)-\mathcal{R}(r_\phi) = G-\epsilon_\phi. \tag*{(16)}

When R(0)>0\mathcal{R}(0)>0, define

bϕ=1−R(rϕ)R(0).b_\phi= 1-\frac{\mathcal{R}(r_\phi)}{\mathcal{R}(0)}.

Since ϵϕ≥0\epsilon_\phi\ge0, we have

bϕ≤GR(0),KR(0)≤1−bϕ.b_\phi\le\frac{G}{\mathcal{R}(0)}, \qquad\frac{\mathcal{K}}{\mathcal{R}(0)} \le1-b_\phi.

Thus, the achieved error reduction cannot exceed the readout gap and can be used to estimate a lower bound on it; the corrected risk is no smaller than the representation error, so 1−bϕ1-b_\phi upper-bounds the ratio of the representation error to the initial error. These results concern population risk; in the experiments, we estimate bϕb_\phi using held-out data.

Current Caches and the Gain from History

Let Zc=(A0,C)Z_c = (A^0,C) and Zm=(Zc,H−)Z_m = (Z_c,\mathcal{H}^{-}), with corresponding conditional means mc,mmm_c,m_m. Write

Kc=K(Zc)=E∥A⋆−mc∥2,K_c = \mathcal{K}(Z_c) = \mathbb{E}\lVert A^\star-m_c\rVert^2,
Km=K(Zm)=E∥A⋆−mm∥2,K_m = \mathcal{K}(Z_m) = \mathbb{E}\lVert A^\star-m_m\rVert^2,

and similarly define Gc=G(Zc)=E∥mc−A0∥2G_c = G(Z_c) = \mathbb{E}\lVert m_c-A^0\rVert^2 and Gm=G(Zm)=E∥mm−A0∥2G_m = G(Z_m) = \mathbb{E}\lVert m_m-A^0\rVert^2. By the law of iterated expectations, E[mm∣Zc]=mc\mathbb{E}[m_m \mid Z_c] = m_c. Expanding A⋆−mc=(A⋆−mm)+(mm−mc)A^\star-m_c = (A^\star-m_m)+(m_m-m_c) and eliminating the cross term gives

Ghist=Kc−Km=E∥mm−mc∥2=Gm−Gc.(17)\begin{aligned} G_{\mathrm{hist}} &= K_c-K_m \\ &= \mathbb{E}\lVert m_m-m_c\rVert^2 = G_m-G_c. \tag*{(17)} \end{aligned}

This quantity is the reduction in optimal prediction error after adding history.

Let Rc,Rm\mathcal{R}_c,\mathcal{R}_m be the actual readout risks under the two inputs, with approximation errors ϵc,ϵm\epsilon_c,\epsilon_m. Then

Rc−Rm=Ghist+ϵc−ϵm.(18)\mathcal{R}_c-\mathcal{R}_m=G_{\mathrm{hist}}+\epsilon_c-\epsilon_m. \tag*{(18)}

If the error reduction ratios of both readouts use the same R(0)\mathcal{R}(0) as the baseline, then

bm−bc=Ghist+ϵc−ϵmR(0).(19)b_m-b_c=\frac{G_{\mathrm{hist}}+\epsilon_c-\epsilon_m}{\mathcal{R}(0)}. \tag*{(19)}

Bidirectional Interventions on the Candidate and Caches

Replace the candidate action with a perturbed version U=A0+ηU=A^0+\eta, while keeping the caches M\mathcal{M} unchanged. Under squared loss, the optimal residual and corrected action are

rη∗(U,M)=E[A⋆∣U,M]−U,(20)r_\eta^*(U,\mathcal{M})=\mathbb{E}[A^\star\mid U,\mathcal{M}]-U, \tag*{(20)}
fη∗(U,M)=E[A⋆∣U,M].f_\eta^*(U,\mathcal{M})=\mathbb{E}[A^\star\mid U,\mathcal{M}].

If, given the caches, the candidate provides no additional information about the target action, i.e., E[A⋆∣U,M]=h(M)\mathbb{E}[A^\star\mid U,\mathcal{M}]=h(\mathcal{M}), then the optimal residual exactly cancels changes in UU, and the corrected action is determined solely by the caches.

For a fixed network fϕ(U,M)=U+Rϕ(U,M)f_\phi(U,\mathcal{M})=U+R_\phi(U,\mathcal{M}), the responses along the two input paths are

dU=η+Rϕ(A0+η,M)−Rϕ(A0,M),dM=Rϕ(A0,M′)−Rϕ(A0,M).(21)\begin{aligned} d_U&=\eta+R_\phi(A^0+\eta,\mathcal{M})\\ &\quad-R_\phi(A^0,\mathcal{M}),\\ d_\mathcal{M}&=R_\phi(A^0,\mathcal{M}')-R_\phi(A^0,\mathcal{M}). \tag*{(21)} \end{aligned}

Thus, the response along the candidate input path is determined by both the direct addition term and the residual; the cache input path affects the corrected action only through the residual. Appendix § 9.§ 3 measures the ratio of the RMS of dUd_U to that of the input perturbation; Appendices § 9.§ 2 and § 11.§ 2 measure the action error after cache replacement and the directional shift, respectively.

Distinguishing Phases Despite Past Prediction Errors

Fix the current input Zc=zZ_c=z. Let p(z)=Pr⁡(J=+∣Zc=z)p(z)=\Pr(J=+\mid Z_c=z), with phase targets a−,a+a_-,a_+, and let A⋆=aJ+ϵA^\star=a_J+\epsilon, where E[ϵ∣Zc,J,H−]=0\mathbb{E}[\epsilon\mid Z_c,J,\mathcal{H}^{-}]=0. Denote the phase probability given the history by pH=Pr⁡(J=+∣Zc=z,H−)p_H=\Pr(J=+\mid Z_c=z,\mathcal{H}^{-}), so that

mc=a−+p(z)(a+−a−),m_c=a_-+p(z)(a_+-a_-),
mm=a−+pH(a+−a−).(22)m_m=a_-+p_H(a_+-a_-). \tag*{(22)}

Define the conditional gain from history as Ghist(z)=E[∥mm−mc∥2∣Zc=z]G_{\mathrm{hist}}(z)=\mathbb{E}[\|m_m-m_c\|^2\mid Z_c=z]. The population gain in Eq. (17) then satisfies Ghist=E[Ghist(Zc)]G_{\mathrm{hist}}=\mathbb{E}[G_{\mathrm{hist}}(Z_c)]. Substituting the conditional means above gives

Ghist(z)=E[(pH−p(z))2∣Zc=z]⋅∥a+−a−∥2.(23)G_{\mathrm{hist}}(z)=\mathbb{E}[(p_H-p(z))^2\mid Z_c=z]\cdot\|a_+-a_-\|^2. \tag*{(23)}

The error reduction is positive when the history changes the phase probability and the two phases have different targets. If the history fully distinguishes the phases, it eliminates the entire error due to phase ambiguity, p(z)(1−p(z))∥a+−a−∥2p(z)(1-p(z))\lVert a_{+}-a_{-}\rVert^{2}.

Consider the following example: JJ takes the values −1-1 and +1+1 with equal probability; both phases have the same current observation and state, with Fn=0F_n=0 and An⋆=JA_n^\star=J; the past feature and expert action satisfy Fn−1=An−1⋆=JF_{n-1}=A_{n-1}^\star=J. For the same frozen readout a(f)=−fa(f)=-f, we have

An−10=−J,An0=0,(24)A_{n-1}^{0}=-J,\qquad A_n^{0}=0, \tag*{(24)}
(An−10−An−1⋆)2=4.\left(A_{n-1}^{0}-A_{n-1}^\star\right)^2=4.

The past prediction is wrong in both phases, but the past feature fully retains JJ. Thus,

rc⋆=0,rm⋆=J,r_c^\star=0,\qquad r_m^\star=J,
Kc=1,Km=0,Ghist=1.(25)K_c=1,\qquad K_m=0,\qquad G_{\mathrm{hist}}=1. \tag*{(25)}

In this example, the error lies in the action readout, while the information needed to distinguish the phases remains fully preserved in the past caches.

Candidate Sampling Variance Decomposition

Let XX be the current input and A0=πθ(X;ξ)A^0=\pi_\theta(X;\xi), where the sampling noise ξ\xi is independent of (X,A⋆)(X,A^\star). Write μ0=E[A0∣X]\mu_0=\mathbb{E}[A^0\mid X], μ⋆=E[A⋆∣X]\mu_\star=\mathbb{E}[A^\star\mid X]. Expanding

A0−A⋆=(A0−μ0)+(μ0−μ⋆)+(μ⋆−A⋆),A^0-A^\star=(A^0-\mu_0)+(\mu_0-\mu_\star)+(\mu_\star-A^\star),

and eliminating the cross terms using conditional independence and zero conditional means gives

R(0)=V0+BX2+KX,\mathcal{R}(0)=V_0+B_X^2+K_X,
V0=E∥A0−μ0∥2,BX2=E∥μ0−μ⋆∥2,KX=E∥A⋆−μ⋆∥2.(26)V_0=\mathbb{E}\lVert A^0-\mu_0\rVert^2,\qquad B_X^2=\mathbb{E}\lVert\mu_0-\mu_\star\rVert^2,\qquad K_X=\mathbb{E}\lVert A^\star-\mu_\star\rVert^2. \tag*{(26)}

The three terms are the average conditional variance of the candidate action, the mean squared error between the conditional means of the candidate and target actions, and the average conditional variance of the target action. Combining Eq. (26) with R(0)=K+G\mathcal{R}(0)=\mathcal{K}+G gives

G=V0+BX2+KX−K.G=V_0+B_X^2+K_X-\mathcal{K}.

Appendix C.1 uses six fixed candidate sampling seeds to estimate V0V_0 and directly measures the error reduction from averaging the candidates.

Valid Action Elements and Held-out Measurement

Training and evaluation use nonnegative weights wk≥0w_k\geq0 to select valid action elements: training uses the label mask, while open-loop evaluation uses an evaluation mask over the first S=20S=20 steps. Assume 0<μ=E∑kwk<∞0<\mu=\mathbb{E}\sum_k w_k<\infty and finite weighted second moments. Then

Rw(r)=E∑kwk(Δk−rk(Z))2μ,\mathcal{R}_w(r)=\frac{\mathbb{E}\sum_k w_k(\Delta_k-r_k(Z))^2}{\mu},
rw,k⋆(Z)=E[wkΔk∣Z]E[wk∣Z].(27)r_{w,k}^\star(Z)=\frac{\mathbb{E}[w_k\Delta_k\mid Z]}{\mathbb{E}[w_k\mid Z]}. \tag*{(27)}

When the denominator is zero, set rw,k⋆=0r_{w,k}^\star=0. Weighted orthogonality, E[wk(Δk−rw,k⋆)∣Z]=0\mathbb{E}[w_k(\Delta_k-r_{w,k}^\star)\mid Z]=0, gives

Rw(r)=Kw+E∑kwk(rk−rw,k⋆)2μ,\mathcal{R}_w(r)=\mathcal{K}_w+\frac{\mathbb{E}\sum_k w_k(r_k-r_{w,k}^\star)^2}{\mu},
Kw=Rw(r⋆).(28)\mathcal{K}_w=\mathcal{R}_w(r^\star). \tag*{(28)}

Thus, the error decomposition and readout bounds in the main text also apply to weighted risk over valid action elements. With the corrector fixed, we compute the following over decisions ii on the held-out trajectories:

R^(r)=∑i,kwik(Aik⋆−Aik0−rk(Zi))2∑i,kwik,\widehat{\mathcal{R}}(r)=\frac{\sum_{i,k}w_{ik}(A_{ik}^\star-A_{ik}^{0}-r_k(Z_i))^2}{\sum_{i,k}w_{ik}},
b^ϕ=1−R^(rϕ)R^(0).(29)\widehat{b}_\phi=1-\frac{\widehat{\mathcal{R}}(r_\phi)}{\widehat{\mathcal{R}}(0)}. \tag*{(29)}

where R^(0)>0\widehat{\mathcal{R}}(0)>0. Appendix C.1 provides the measurement settings.

Open-loop Analysis and History Interventions

Readout Gap and Sampling Variance

With ReRead’s weights fixed, we compare three conditions on the 22 held-out expert trajectories of Hard11: the native candidate, reading only the current cache, and reading the current and two previous caches. Errors are aggregated over valid action elements using the weights in Eq. (29).

Sampling variance. On the same trajectories, we generate candidate actions with six nonzero denoising seeds, estimate the sampling variance, and compute the MSE of the mean of the six candidates. Table A4 reports the results.

StatisticValue
Mean single-candidate MSE20.48
MSE of the six-candidate mean19.76
Sampling variance0.86
Risk minus sampling variance19.62

Table A4. Candidate error and sampling variance (10−410^{-4}).

History Replacement

We evaluate ReRead in open loop on the 22 held-out trajectories of Hard11. Figure 5 in the main text aggregates the clean/seen and random/seen results over valid action elements using Eq. (29); Table A5 reports the MSE for each setting and adds the random/unseen results under the same protocol. Here, seen/unseen refers to the task-instruction split. All interventions keep the candidate action, current images, robot state, target instruction, initial denoising noise, and current K/V unchanged, and take effect only for the current cache read.

History conditionClean/seenRandom/seenRandom/unseen
Native candidate26.56112.86713.219
True history1.5061.4771.514
Current only8.9906.2246.195
Repeat current8.9956.2236.198
Swap order5.6185.3875.347
Other trajectory (same task)22.62914.20114.328
Other task24.90112.07212.411

Table A5. History replacement MSE (10−410^{-4}).

History conditions. The cache slots store the older past cache, the more recent past cache, and the current cache, in that order. Each slot contains visual K/V, action K/V, and the robot state. We compare six history conditions:

  1. True history: read the caches of the current and two previous decisions.

  2. Current only: mask out the K/V and states of both past caches, keeping the current cache.

  3. Repeat current: copy the current K/V and state into the past slots, preserving each slot’s age encoding and number of visible tokens.

  4. Swap order: swap the contents of the two past caches, preserving each slot’s age encoding.

  5. Other trajectories of the same task: replace the past caches with those of two consecutive decisions from another trajectory of the same task.

  6. Other task: replace the past caches with those of two consecutive decisions from another task.

All content replacements apply to K, V, and the state together.

Selecting replacement trajectories. Replacement caches come from other training trajectories. We select three distinct replacement trajectories per task and clean/random setting, 66 trajectories in total; the replacements contain at least four consecutive decision anchors spaced SS steps apart. The replacement and target trajectories use the same clean/random setting, and their past anchors are matched by relative decision progress.

Response to Candidate Perturbations

We use the same ReRead weights, 22 held-out trajectories, and candidate perturbation settings as in the main text. All noise levels share the same random mask and Gaussian samples, with only the perturbation scale changed. We measure perturbation transfer by the RMS ratio of the change in the corrected action to the input perturbation, RMS⁡(dU)/RMS⁡(η)\operatorname{RMS}(d_U)/\operatorname{RMS}(\eta), where dUd_U is defined in Eq. (21). At σ=0.05\sigma= 0.05 and 0.20, the ratios are 12.3% and 15.1%, respectively.

Past Prediction Error and Corrective Value

We pair each past candidate’s prediction error with the cache generated in the same forward pass to test whether the cache remains useful for correction when the past prediction is wrong. The experiments fix ReRead’s weights and use the 22 held-out trajectories of Hard11. For decision ww, let QwQ_w be the mean error of the native candidates at the two previous decisions. We fix the current observations, candidate action, and current K/V, and use six preset denoising seeds only on the past observations to generate six sets of history. We divide them into low-, medium-, and high-error groups by QwQ_w.

Table A6 reports the MSE for each error group and the controls on history content. Here, K/V includes both visual and action K/V. The zero-K/V and current-K/V controls retain past states and temporal information; the three error groups use native history.

History conditionPast candidate MSECurrent action MSE
Mask past K/V and states—7.61
Zero past K/V—14.92
Current K/V in past slots—7.81
Low-error history K/V14.392.13
Medium-error history K/V18.722.13
High-error history K/V24.402.73

Table A6. History content controls (MSE in 10−410^{-4}).

For naturally occurring history, we compute the quantiles of QwQ_w at 1/3 and 2/3 separately for each task and clean/random setting. These thresholds divide the decisions into low-, medium-, and high-error history groups, with results in Table A7.

History error groupPast candidate MSECurrent onlyTrue historyMSE reduction (%)
Low error1.189.731.8181.40
Medium error5.077.431.6677.66
High error45.375.791.0482.04
Both past candidates: high error44.624.050.8379.51

Table A7. History error groups (MSE in 10−410^{-4}).

Closed-loop Results and Ablations

Three Backbones on Hard11

We use the authors’ Fast-WAM Base checkpoint for RoboTwin from yuanty/fastwam, revision 8eacee b24c3c92ff2a9c9a9d266a4941b836705. The weight file is robotwin_uncond_3cam_384.pt, paired with the normalization statistics in robotwin_uncond_3cam_384_dataset_stats.json.

For π0.5\pi_{0.5}, we use the RoboTwin 2.0 checkpoint fine-tuned and released by Motus from motus-robotics/pi0.5_robotwin2, revision effc6e1a99bd4d0edf9447e8ba313def67649cfe.

Motus converted the official π0.5\pi_{0.5} weights from JAX to PyTorch and fine-tuned them on 27,500 trajectories across 50 RoboTwin 2.0 tasks, with 50 clean and 500 random trajectories per task. The action chunk length is 32.

For LingBot-VLA, we use the authors’ 4B RoboTwin post-trained checkpoint without depth inputs from robbyant/lingbot-vla-4b-posttrain-robotwin, revision fb71a2c9749ccfedbb7290c2c3f0e5e7c7305c9e.

We keep these backbones frozen and train a separate ReRead corrector from scratch on offline demonstrations from all 50 RoboTwin 2.0 tasks.

ReRead reads native K/V from layers 2, 8, 14, and 17 of π0.5\pi_{0.5} and layers 5, 17, 29, and 35 of LingBot-VLA. The candidate action provides the query, and the corrector reads the caches of the current and two previous decisions to predict an action residual.

Each model is evaluated for 25 episodes per task and setting on Hard11, 550 episodes in total. We evaluate all three backbone-only baselines using the inference settings provided with their respective checkpoints. Table A8 reports the per-task results.

Taskπ0.5\pi_{0.5} Cπ0.5\pi_{0.5} RLingBot-VLA CLingBot-VLA RMotus CMotus RHyVLA-0.5 CHyVLA-0.5 RGeoMem-VLA CGeoMem-VLA RLingBot-VA CLingBot-VA RFast-WAM CFast-WAM RFast-WAM†^\dagger CFast-WAM†^\dagger RReRead CReRead R
Adjust Bottle7983100100899399991001009094100100100100100100
Beat Block Hammer63508791958899999994969899979795100100
Blocks Ranking RGB433592919997999999959998100100100100100100
Blocks Ranking Size81466737563939487869496949891919694
Click Alarmclock97939326100100100100929799100100100100100100100
Click Bell75763219100100100999795100100100100100100100100
Dump Bin Bigbin304297929591969897988996979695999896
Grab Roller9089100991001001001009898100100100100100100100100
Handover Block181980838673937393929978958191789288
Handover Mic2818949878638798100989496991001001009998
Hanging Mug3332273838373344404028586258674751
Lift Pot0010099969999991001001009910010010099100100
Move Can Pot292779843474949987919497908888899694
Move Pillbottle Pad332993949396969610098999910099999910099
Move Playingcard Away5967969910096989610099100991001009999100100
Move Stapler Pad161874498385949578689179776480608066
Open Laptop193596969591999899100929498100989996100
Open Microwave353791759591726499998286624545459688
Pick Diverse Bottles5379869091887273728982808588828682
Pick Dual Bottles1068295969082828489100991009697979795
Place A2B Left626086838879777580829793959398949994
Place A2B Right625774779187747875729795939995949796
Place Bread Basket485692939194959397939795919395969295
Place Bread Skillet384690898683949089899590909388889490
Place Burger Fries6670959698989998959997959699979896100
Place Can Basket192568788176918187938184716968707071
Place Cans Plasticbox404797100989410010099100100999996100989899
Place Container Plate71789999989998991001009997961009910099100
Place Dual Shoes127808393879495858194899488949310090
Place Empty Cup75861001009998100100100100100100100100100100100100
Place Fan2536917991879698981009993969696929896
Place Mouse Pad212682786668889390929396838979808685
Place Object Basket433690918187868583869188898884799393
Place Object Scale404984908885908992929695909794899695
Place Object Stand746597939897949897949996909496969796
Place Phone Stand4953929387869194901009797979995989299
Place Shoe5761999499979810099979898969987969197
Press Stapler80709088939888801001008582909791929392
Put Bottles Dustbin12988928179898584888791959091939095
Put Object Cabinet241592868871788388858587948991909291
Rotate QRcode475693848973939887899691938990819379
Scan Object423891976766919495959691899291859584
Shake Bottle911009910010097100991001001009710010010010010099
Shake Bottle Horizontally96100100100100981009910010010099100100100100100100
Stack Blocks Three151692999195989781849998959777748780
Stack Blocks Two4856100100100989899999910098100100100100100100
Stack Bowls Three333572837987878391918683848185868689
Stack Bowls Two786692959898989799999498929893999795
Stamp Seal362376869392858186889697909489929194
Turn Switch5661658478504963654445615964685561
Average42.9843.8486.5085.3488.6687.0290.9090.0691.1091.2492.9091.5091.8891.7891.0690.4093.2092.12

Table A9. Per-task success rates (%). C/R: clean/random.

Per-task Results on All 50 Tasks

Table A9 summarizes the success rates of 9 models on all 50 tasks of RoboTwin 2.0. All results except ReRead and Fast-WAM†^\dagger are taken from the corresponding papers. We evaluate ReRead and Fast-WAM†^\dagger for 100 episodes per task and setting, with Fast-WAM†^\dagger using the checkpoint specified in Appendix D.1.

External Visual Branches

Architecture and visual inputs. Standard ReRead reads the frozen backbone’s native K/V. To test whether external visual features provide additional information for action correction, we add a frozen visual encoder and a trainable branch that writes a separate correction memory. The native K/V and the backbone’s three-camera input remain unchanged. The external branch reads four frames [t−6,t−4,t−2,t][t - 6, t - 4, t - 2, t] from the head camera at 384×384384 \times384 resolution, where tt indexes trajectory rows during training and executed actions during deployment. This short-term window is maintained separately from the caches of previous decisions. At the start of an episode, missing frames are filled with the earliest observation and excluded by a validity mask.

Conditioned K/V writer. With DINOv3, each frame yields 24×2424 \times24 normalized patch tokens of dimension 768. We retain all 2,304 patch tokens across four frames, excluding CLS and register tokens. Layer normalization and a linear projection map the tokens to width 1,024, followed by learned joint temporal and spatial position embeddings. Queries combine projected, normalized current action K/V, the frozen backbone’s state feature, and layer and action-position embeddings. The state feature reuses the backbone’s proprioceptive encoder and Action DiT context mapping. The four source layers and 32 action positions per layer give 128 queries. A single three-layer writer processes all queries, using pre-norm cross-attention and feed-forward residual updates with width 1,024, 16 heads, FFN width 4,096, and GELU. The visual tokens with position embeddings supply both keys and values. After output normalization, separate linear projections produce correction keys and values, each of shape 4×32×15364 \times32 \times1536.

Memory and gated reading. Both memories store records from the current and two previous decisions, with shared history-validity and dropout masks. Past correction records are detached before caching; the current record remains differentiable. Age encodings are added to the correction keys at each read. After query self-attention, each of the corrector’s five layers reads the native and correction memories separately. The two reads share the query projection and use separate key, value, and output projections and softmax normalizations. Using the query notation in § 4.2, the update is

qj′′=qj′+ojnative+tanh⁡(gj)ojcorr,q_j^{\prime\prime} = q_j^{\prime} + o_j^{\mathrm{native}} + \tanh(g_j)o_j^{\mathrm{corr}},

where ojnativeo_j^{\mathrm{native}} and ojcorro_j^{\mathrm{corr}} are the two attention outputs, and gjg_j is a scalar learned independently in each layer and initialized to zero. The feed-forward update follows, and the final output head predicts the action residual. With the backbone and visual encoder frozen, we train the writer, readers, gates, and output head using only the final action MSE.

Visual encoder variants. We compare DINOv3 (ViT-B/16), LingBot-Vision (distilled Base version), V-JEPA 2.1 (ViT-B/16), and C-RADIO (C-RADIOv3-B). All variants use the same causal frame sampling and correction memory interface. DINOv3, LingBot-Vision, and C-RADIO retain four per-frame feature slices; V-JEPA 2.1 uses a temporal tubelet size of 2 to produce two temporal slices. The four-frame DINOv3 variant adds 85,842,949 trainable parameters (85.84M) to standard ReRead.

K/V Sources and the No-K/V Control

The three configurations—reading both visual and action K/V, reading only action K/V, and reading only visual K/V—are trained independently and evaluated for 25 episodes per task and setting. The no-K/V control retains the candidate action, the current and past robot states, and the executed prefix.

Phase-ambiguous Task and Real-robot Experiments

Closed-loop Evaluation

Simulation. The training set contains 200 successful expert demonstrations, with 20% clean and 80% random. We first fine-tune the released Fast-WAM RoboTwin checkpoint for 2K steps with its native video and action objectives, then freeze the backbone and continue training ReRead for 2K steps from the corrector weights trained on all 50 RoboTwin 2.0 tasks using only MSE. Both stages use a global batch size of 8 and a learning rate of 10−510^{-5}. The instruction does not explicitly identify the current phase.

We evaluate on 50 paired scenes, with 25 scenes in each of the clean and random settings. Each model runs once in each scene, giving 100 episodes in total. Both use the same initial observations, instruction, and candidate denoising seed, with DD denoising steps and replanning after SS executed steps. Success requires completing the grasp, placement, gripper opening, and return to the initial pose. The episode must also pass checks on bottle lifting, position and orientation, return to the initial joint configuration, and gripper aperture. Fast-WAM succeeds in 1 episode (2%), and ReRead in 25 episodes (50%).

Real robot. The experiments use a Flexiv dual-arm robot. We train Fast-WAM and ReRead for 20K steps each using 200 demonstrations obtained through teleoperation and expert trajectory generation. The clean and random settings correspond to those in simulation.

Each model is evaluated for 25 episodes in each setting, 50 episodes in total, with a limit of 1600 steps per episode. An episode succeeds if the robot picks up the bottle, returns it upright to its original position, and returns the arm to its initial pose within this limit. Fast-WAM fails in all 50 episodes; ReRead succeeds in 18 episodes (36%).

Targeted Intervention on Phase History

We use the frozen Fast-WAM and ReRead weights after each has been trained for 2K steps on the bottle task, with DD denoising steps, replanning after SS executed steps, and action chunk length HH. The evaluation decisions come from 8 expert trajectories whose seeds do not overlap with those of the 200 training demonstrations; replacement trajectories come from the training set. At decision anchors spaced SS steps apart, we match pre-grasp approach decisions with post-place retreat decisions, requiring similar images, gripper states, and bottle states. This yields 7 scenes and 14 decisions.

Cross-trajectory replacements use the same active arm, bottle type, clean/random setting, and text instruction as the evaluation decision. Replacement trajectories are ranked by similarity in current pose and bottle position, with preference for trajectories whose past candidate MSE ratio between the pre-grasp and post-place phases is at most 2. We also swap the caches of the two phases within all 7 scenes and reuse these caches at both evaluation decisions of the same trajectory.

The directional metric uses the arm joints. For decision ww, the expert action of the current phase is assigned coordinate 0 and that of the other phase coordinate 1. The action coordinate along the phase direction and the directional shift after history replacement are defined as

cw(A)=⟨A−Aw⋆,dw⟩∥dw∥22,c_w(A) = \frac{\langle A - A_w^\star, d_w\rangle}{\lVert d_w\rVert_2^2},
Δcw=cw(A^wopp)−cw(A^wsame),(30)\Delta c_w = c_w(\hat{A}_w^{\mathrm{opp}}) - c_w(\hat{A}_w^{\mathrm{same}}), \tag*{(30)}

where dwd_w is the reference direction obtained by translating the other phase’s expert action displacement to the starting point of the evaluation decision.

As shown in Table A10, true history reduces the action MSE by 40.26% relative to the current-only readout; opposite-phase history from other trajectories increases the error 4.09-fold relative to same-phase history.

History conditionAction MSE
Native candidate379.79
True history149.73
Current only250.64
Cross-trajectory, same phase127.52
Cross-trajectory, opposite phase521.52
Same-scene, opposite phase519.45

Table A10. Action MSE on phase-ambiguous scenes (10−410^{-4}).

References

  1. [1]Wensi Ai, Christopher Luev, Karthik Dharmarajan, Evans Han, Yunfan Jiang, Stef Ren, Jianwen Xie, Jiajun Wu, Li Fei-Fei, and Ruohan Zhang. I3L: Iterative interactive imitation learning for whole-body mobile manipulation, 2026. arXiv:2610.17748.arxiv.org/abs/2610.17748
  2. [2]Hongzhe Bi, Hengkai Tan, Shenghao Xie, Zeyuan Wang, Shuhe Huang, Haitian Liu, Ruowen Zhao, Yao Feng, Chendong Xiang, Yinze Rong, Hongyan Zhao, Hanyu Liu, Zhizhong Su, Lei Ma, Hang Su, and Jun Zhu. Motus: A unified latent action world model. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 35101–35113, 2026.arxiv.org/abs/2512.13030
  3. [3]Collin Burns, Haotian Ye, Dan Klein, and Jacob Steinhardt. Discovering latent knowledge in language models without supervision. In International Conference on Learning Representations, 2023.arxiv.org/abs/2212.03827
  4. [4]Tianxing Chen, Zanxin Chen, Baijun Chen, Zijian Cai, Yibin Liu, Zixuan Li, Qiwei Liang, Xianliang Lin, Yiheng Ge, Zhenyu Gu, Weiliang Deng, Yubin Guo, Tian Nian, Xuanbing Xie, Qiangyu Chen, Kailun Su, Tianling Xu, Guodong Liu, Mengkang Hu, Huan-Ang Gao, Kaixuan Wang, Zhixuan Liang, Yusen Qin, Xiaokang Yang, Ping Luo, and Yao Mu. RoboTwin 2.0: A scalable data generator and benchmark with strong domain randomization for robust bimanual robotic manipulation. In Proceedings of the 43rd International Conference on Machine Learning, pages 13673–13699. PMLR, 2026.
  5. [5]Zelin Fu, Bin Tan, Changjiang Sun, Shaohui Liu, Kecheng Zheng, Yinghao Xu, Xing Zhu, Yujun Shen, and Nan Xue. Vision pretraining for dense spatial perception, 2026. arXiv:2607.05247.arxiv.org/abs/2607.05247
  6. [6]Dibya Ghosh, Homer Rich Walke, Karl Pertsch, Kevin Black, Oier Mees, Sudeep Dasari, Joey Hejna, Tobias Kreiman, Charles Xu, Jianlan Luo, You Liang Tan, Lawrence Yunliang Chen, Quan Vuong, Ted Xiao, Pannag R Sanketi, Dorsa Sadigh, Chelsea Finn, and Sergey Levine. Octo: An Open-Source Generalist Robot Policy. In Proceedings of Robotics: Science and Systems, Delft, Netherlands, 2024.arxiv.org/abs/2405.12213
  7. [7]Siddhant Haldar, Jyothish Pari, Anant Rai, and Lerrel Pinto. Teach a Robot to FISH: Versatile Imitation from One Minute of Demonstrations. In Proceedings of Robotics: Science and Systems, Daegu, Republic of Korea, 2023.arxiv.org/abs/2303.01497
  8. [8]Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of Statistical Learning. Springer New York, 2009.
  9. [9]Greg Heinrich, Mike Ranzinger, Hongxu Yin, Yao Lu, Jan Kautz, Andrew Tao, Bryan Catanzaro, and Pavlo Molchanov. RADIOv2.5: Improved baselines for agglomerative vision foundation models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 22487–22497, 2025.arxiv.org/abs/2412.07679
  10. [10]John Hewitt and Percy Liang. Designing and interpreting probes with control tasks. In Proceedings of EMNLP-IJCNLP, pages 2733–2743, 2019.arxiv.org/abs/1909.03368
  11. [11]Bingyi Kang, Saining Xie, Marcus Rohrbach, Zhicheng Yan, Albert Gordo, Jiashi Feng, and Yannis Kalantidis. Decoupling representation and classifier for long-tailed recognition. In International Conference on Learning Representations (ICLR), 2020.arxiv.org/abs/1910.09217
  12. [12]Polina Kirichenko, Pavel Izmailov, and Andrew Gordon Wilson. Last layer re-training is sufficient for robustness to spurious correlations. In International Conference on Learning Representations (ICLR), 2023.arxiv.org/abs/2204.02937
  13. [13]Myungkyu Koo, Daewon Choi, Taeyoung Kim, Kyungmin Lee, Changyeon Kim, Younggyo Seo, and Jinwoo Shin. HAMLET: Switch your vision-language-action model into a history-aware policy. In The Fourteenth International Conference on Learning Representations, 2026.arxiv.org/abs/2510.00695
  14. [14]Kenneth Li, Oam Patel, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. Inference-time intervention: Eliciting truthful answers from a language model. In Advances in Neural Information Processing Systems, pages 41451–41530, 2023.arxiv.org/abs/2306.03341
  15. [15]Lin Li, Qihang Zhang, Yiming Luo, Shuai Yang, Ruilin Wang, Fei Han, Mingrui Yu, Zelin Gao, Nan Xue, Xing Zhu, Yujun Shen, and Yinghao Xu. Causal world modeling for robot control, 2026. arXiv:2601.21998.arxiv.org/abs/2601.21998
  16. [16]Lorenzo Mur-Labadia, Matthew Muckley, Amir Bar, Mido Assran, Koustuv Sinha, Mike Rabbat, Yann LeCun, and Nicolas Ballas. V-JEPA 2.1: Unlocking dense features in video self-supervised learning. In Computer Vision – ECCV 2026, pages 671–689. Springer Nature Switzerland, 2026.
  17. [17]Tiago Pimentel, Josef Valvoda, Rowan Hall Maudslay, Ran Zmigrod, Adina Williams, and Ryan Cotterell. Information-theoretic probing for linguistic structure. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 4609–4622, 2020.arxiv.org/abs/2004.03061
  18. [18]Hao Shi, Bin Xie, Yingfei Liu, Lin Sun, Fengrong Liu, Tiancai Wang, Erjin Zhou, Haoqiang Fan, Xiangyu Zhang, and Gao Huang. MemoryVLA: Perceptual-cognitive memory in vision-language-action models for robotic manipulation. In The Fourteenth International Conference on Learning Representations, 2026.arxiv.org/abs/2508.19236
  19. [19]Tom Silver, Kelsey Allen, Josh Tenenbaum, and Leslie Kaelbling. Residual policy learning, 2018. arXiv:1812.06298.arxiv.org/abs/1812.06298
  20. [20]Oriane Siméoni, Huy V. Vo, Maximilian Seitzer, Federico Baldassarre, Maxime Oquab, Cijo Jose, Vasil Khalidov, Marc Szafraniec, Seung e un Yi, Michaël Ramamonjisoa, Francisco Massa, Daniel Haziza, Luca Wehrstedt, Jianyuan Wang, Timothée Darcet, Théo Moutakanni, Leonel Sentana, Claire Roberts, Andrea Vedaldi, Jamie Tolan, John Brandt, Camille Couprie, Julien Mairal, Hervé Jégou, Patrick Labatut, and Piotr Bojanowski. DINOv3, 2025. arXiv:2508.10104.arxiv.org/abs/2508.10104
  21. [21]Shaokai Wu, Yanbiao Ji, Qiuchang Li, Zhiyi Zhang, Qichen He, Wenyuan Xie, Guodong Zhang, Bayram Bayramli, Yue Ding, and Hongtao Lu. Dejavu: Towards expertise feedback learning for embodied intelligence. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 29578–29587, 2026.
  22. [22]Wei Wu, Fan Lu, Yunnan Wang, Shuai Yang, Shi Liu, Fangjing Wang, Qian Zhu, He Sun, Yong Wang, Shuailei Ma, Yiyu Ren, Kejia Zhang, Hui Yu, Jingmei Zhao, Shuai Zhou, Zhenqi Qiu, Houlong Xiong, Ziyu Wang, Zechen Wang, Ran Cheng, Yong-Lu Li, Yongtao Huang, Xing Zhu, Yujun Shen, and Kecheng Zheng. A pragmatic VLA foundation model, 2026. arXiv:2601.18692.arxiv.org/abs/2601.18692
  23. [23]Tianyuan Yuan, Zibin Dong, Yicheng Liu, and Hang Zhao. Fast-WAM: Do world action models need test-time future imagination? arXiv preprint arXiv:2603.16666, 2026.arxiv.org/abs/2603.16666
  24. [24]Xiu Yuan, Tongzhou Mu, Stone Tao, Yunhao Fang, Mengke Zhang, and Hao Su. Policy decorator: Model-agnostic online refinement for large policy model. In International Conference on Learning Representations (ICLR), 2025.arxiv.org/abs/2412.13630
  25. [25]He Zhang, Lingzhu Xiang, Haitao Lin, Zeyu Huang, Minghui Wang, Dingyuan Zhong, Yubo Dong, Yihao Wu, Yongming Rao, Dongsheng Zhang, Wanjia He, Ling Chen, Kai Huang, Jiah ao Chen, Sichang Su, Xumin Yu, Ziyi Wang, Chengwei Zhu, Xiao Teng, Yuchun Guo, Yufeng Zhang, Yuandong Liu, Rui Wang, Zisheng Lu, Han Hu, and Zhengyou Zhang. Hy-Embodied-0.5-VLA: From Vision-Language-Action Models to a Real-World Robot Learning Stack, 2026. arXiv:2606.14409.arxiv.org/abs/2606.14409
  26. [26]Qinfan Zhang, Yifan Luo, Haoyuan Shi, Guanlin Liu, Han Dong, Haozhe Shan, Yong Dai, Xiangcong Ren, and Xiaozhu Ju. GeoMem-VLA: Internalizing 3D Scene Understanding into Temporal Memory for Vision-Language-Action Models, 2026. arXiv:2610.29866.arxiv.org/abs/2610.29866

Paper details

vlnc:W_3vj6f4cu
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 5

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents