RoboTTT: Context Scaling for Robot Policies

Yunfan Jiang, Yevgen Chebotar, Ruijie Zheng, Fengyuan Hu, Yunhao Ge, Jimmy Wu, Tianyuan Dai, Scott Reed, Li Fei-Fei, Yuke Zhu, Linxi "Jim" Fan

RoboTTT scales robot policy context to 8K timesteps using test-time gradient updates, enabling long-horizon task completion.

How can we enable robot policies to learn from and execute over long-horizon (8K timestep) trajectories instead of being limited to short-history visuomotor context?

Robot foundation models typically rely on single-step or short-history observations, causing them to fail on long-horizon tasks where progress must be tracked over minutes. RoboTTT integrates Test-Time Training (TTT) into robot policies, using fast weights updated by gradient descent during deployment to compress long histories into parameter space without increasing inference latency. This approach enables robots to complete complex, multi-stage assembly tasks that baselines cannot finish, while unlocking one-shot imitation from human video demonstrations.

Paper Primer

RoboTTT treats the robot's history as a stream of data that updates a small, internal neural network (the "fast model") via gradient descent. This mechanism acts like a dynamic memory: it encodes salient features of the past into the fast weights while discarding redundant information, allowing the policy to condition on thousands of timesteps without the memory growth associated with standard attention mechanisms.

Scaling context length to 8K timesteps significantly improves closed-loop performance on long-horizon manipulation tasks.

RoboTTT-8K achieved a 63% higher task completion score than the same model pretrained with 1K-timestep context and outperformed the best short-context baseline by 57%. 87% improvement in overall task performance over single-step baselines.

The training recipe uses "sequence action forcing" and truncated backpropagation through time (TBPTT) to stabilize learning over long sequences. By masking the loss on human demonstration videos, the model learns to extract task configurations from video context, enabling one-shot imitation of unseen assembly tasks.

Why use test-time gradient updates instead of just increasing the attention window?

Standard attention inference costs grow with history length, even with caching. RoboTTT's fast weights maintain a fixed-size recurrent state, keeping inference latency constant regardless of how long the context becomes.

What is the role of "DAgger Distillation" in this architecture?

It is a meta-learning procedure that uses both suboptimal robot actions and human corrections as context to train the fast weights, teaching the policy to recognize its own failures and apply corrections on the fly.

The Long-Horizon Bottleneck

We expose why short‑history robot policies fail and introduce RoboTTT to break the context barrier.

Current robot foundation models are limited to short‑history visuomotor context, creating a “short‑history bottleneck” that prevents them from handling multi‑stage, long‑horizon tasks. To overcome this, we propose Test‑Time‑Training Robot Policies (RoboTTT), a model that expands context to 8 K timesteps—three orders of magnitude beyond the state‑of‑the‑art—while keeping inference latency constant. This long‑context capability unlocks new behaviours such as one‑shot imitation from a single human video, on‑the‑fly policy improvement, and robust execution of a five‑minute, ten‑stage assembly task.

**Figure.** Better Long Horizon Task Performance (Duration = 5 Minutes)

Current robot models fail at multi‑stage tasks due to limited context windows.

RoboTTT Architecture and Training

We describe the RoboTTT architecture, its test‑time‑training mechanism, and the training recipe that enables long‑context robot policies.

RoboTTT augments a vision‑language backbone with fast‑weight Test‑Time‑Training (TTT) layers that run across time while the original attention layers stay per‑step.

At $t=1$, the inputs are $R_1$, $q_1$, $\tilde{A}_1$, and $Φ_1$; attention produces $O_{\text{attn}}^{(1)}$.

The attention outputs are concatenated: $X = [R_1, q_1, \tilde{A}_1, R_2, q_2, \tilde{A}_2]$.

TTT layers receive $X$, compute a gradient step on the fast‑weight loss, and update $W_0 arrow W_1$.

At $t=2$, attention uses the updated fast weights $W_1$, producing $O_{\text{attn}}^{(2)}$.

The final action chunks $A_1$ and $A_2$ are generated from the combined outputs.

The register tokens let the model propagate visual context across timesteps without re‑encoding the full image at each step.

Why are TTT layers placed after the attention layers instead of before them?

Placing TTT after attention lets the pretrained attention process the raw per‑step tokens first, preserving the learned spatial and cross‑modal relationships. The subsequent TTT layer then aggregates information across time using fast weights, so the new temporal modeling does not disturb the already‑trained attention weights.

At every timestep the model takes a gradient step on a flow‑matching loss to update a set of fast weights, which are then used to influence the next predictions.

Compute the gate: $\tanh(\alpha) \approx [0.001, 0.001]$.

Assume $O_{\text{TTT}} = [0.5, -0.3]$ and $O_{\text{attn}} = [0.2, 0.4]$.

Blend: $O = \tanh(\alpha) \odot O_{\text{TTT}} + O_{\text{attn}} = [0.001\cdot0.5+0.2,\;0.001\cdot(-0.3)+0.4] \approx [0.2005,\;0.3997]$.

The tanh gate keeps the TTT contribution tiny initially, allowing the model to rely on the well‑trained attention output while the fast weights learn.

Why use a tanh gate instead of a fixed scalar weight?

The tanh function is bounded and learnable, so the model can automatically increase the TTT influence as training progresses without risking overflow. A fixed scalar would either be too large (destabilizing early training) or too small (preventing the TTT layer from ever contributing).

TBPTT splits a long trajectory into short segments, back‑propagating gradients only inside each segment while carrying the fast weights across segment boundaries.

Segment 1 (steps 1‑3): compute forward pass, accumulate loss, back‑propagate gradients through steps 1‑3.

At the boundary after step 3, detach the computational graph (stop gradient).

Carry the fast‑weight state $W_3$ forward to step 4 unchanged.

Segment 2 (steps 4‑6): repeat forward pass and back‑propagation inside this segment.

Only the gradients from segment 2 affect parameters of steps 4‑6; the earlier segment’s gradients do not flow beyond step 3.

Even though gradients are truncated, the fast‑weight state still integrates information from the entire 6‑step trajectory, enabling long‑range learning with modest memory.

What would happen if the fast‑weight state were also detached at segment boundaries?

If $W$ were detached, the model could not propagate any temporal information across segments, effectively breaking the long‑context learning objective. The fast‑weight updates would be confined to each segment, defeating the purpose of TTT.

During training, both the robot’s suboptimal actions and the human corrections update the fast weights, but the loss is computed only on the corrections, teaching the model to map failures to fixes.

Step 1: robot executes $A_1^{\text{robot}}$, fast weights update $W_0 arrow W_1$ using $A_1^{\text{robot}}$ (no loss computed).

Step 2: human provides correction $A_2^{\text{human}}$, fast weights update $W_1 arrow W_2$ using $A_2^{\text{human}}$ and compute flow‑matching loss on $A_2^{\text{human}}$.

The gradient from the loss only back‑propagates through the update that produced $W_2$, teaching the model how to adjust fast weights in response to the failure observed at step 1.

By keeping the robot’s failed actions in the fast‑weight history, the model learns to anticipate and correct similar failures without explicit supervision on the failures themselves.

How does using robot actions as context differ from standard DAgger which discards them?

Standard DAgger treats robot actions as irrelevant for learning and only fine‑tunes on the human corrections. DAgger Distillation retains the robot actions as part of the fast‑weight state, allowing the model to encode the failure pattern and later generate corrective behavior autonomously.

Sample a trajectory $\xi$ from the dataset $\mathcal{D}$.

Initialize fast weights $W_0$ (learned meta‑parameter).

For each timestep $t=1\ldots T$:

Inference loop for RoboTTT

**Figure 2.** **RoboTTT model architecture, training, and inference.** TTT layers are added after the attention layers in the DiT action head: attention operates within each timestep, while TTT layers operate across timesteps. Training uses a sequence flow-matching loss with sequence action forcing, sampling the noise level independently per action chunk. Inference starts from the learned initialization $W_0$, updating fast weights on each observation and propagating them forward.

Empirical Evaluation and Scaling

RoboTTT delivers higher task scores and scales with longer context.

RoboTTT outperforms all baselines, achieving an 87 % higher task completion score than the best short‑context baseline.

Table 1 shows RoboTTT’s average score of 79 % versus 42 % for GR00T N1.7 and 56 % for GDN.

**Figure 5.** **Evaluation tasks.** Three long-horizon assembly tasks on a YAM bimanual setup; each row shows one rollout. **Top, Pup Go Car:** toy vehicle assembly, 2-minute average episodes. **Middle, Circuit:** target configuration specified by a language prompt or a one-shot human video demonstration; 1-minute episodes. **Bottom, Gear Bot:** ten-stage assembly spanning five minutes, our longest-horizon task.

**Figure 7.** Main evaluation: task completion scores on three assembly tasks. Scores are rubric-based, reported in percent; higher is better.

**Figure 8.** Closed-loop performance scales with pretraining context length. Average task completion score across the three tasks as pretraining context length grows from 128 to 8K timesteps. RoboTTT improves steadily, surpassing the best short-context baseline from 1K onward with no sign of saturation; GDN does not benefit from longer context. Single-Step Context and Short Context denote GR00T N1.7 and GR00T N1.7 Hist.. All evaluations in this figure predate the DAgger training used for Pup Go Car in the main results.

**Figure 9.** **One-shot imitation from an in-context human video.** Continuous footage: a human demonstrates an unseen configuration (frames 1–3), the scene is reset (frame 4), and RoboTTT reproduces the assembly (row 2). The prompt is identical across configurations, so the target is identifiable only from the video.

**Figure 10.** DAgger Distillation results on Pup Go Car. Task completion after fine-tuning on a pool of 100 DAgger trajectories (50 collected with RoboTTT, 50 with GR00T N1.7). DAgger Distillation applies to the sequence models RoboTTT and GDN.

**Figure 11.** **On-the-fly recovery learned through DAgger Distillation.** While tightening the roof screw on Pup Go Car, RoboTTT misses the screw (frames 1–3), raises the arm and re-attempts, getting closer but missing again (frames 4–5), then re-adjusts once more and succeeds (frames 6–8).

**Figure 12:** **Ablation results on the Pup Go Car task.** We ablate sequence action forcing and the fast-model architecture (MLP vs. linear), and trace each component added during development (state tokens, action tokens, register tokens). GR00T N1.7 with register tokens is included for a matched-token comparison.

RoboTTT scales performance with context length, outperforming short‑context baselines.

Implementation and Task Details

Key implementation details, task definitions, and ablation confirmations.

This appendix records the concrete model, training, and deployment choices that support the ablation study, and it lists the robot manipulation tasks used for evaluation.

**Figure A.1.** Trajectory length distribution of the pretraining mixture.

**Figure A.2:** The “Pup Go Car” task. The robot assembles the roof and first wheel of a model car across multiple stages, including screwing, drilling, bimanual handoffs, and a car flip.

**Figure A.3:** The “Gear Bot” task. The robot installs gears and wheels on both sides of the chassis, flips it twice, attaches the robot head, and drives it with a remote.

**Figure A.4.** The “Circuit” task. The robot assembles two or three circuit components on a board and powers the circuit on when a switch or button is present.

Ablation results confirm that removing sequence‑action forcing or omitting the specially designed token types degrades task success, indicating both are essential for maintaining coherent long‑horizon behavior.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers