Poke &Wiggle
Papers
Paper

OAT

OAT: Ordered Action Tokenization

Claim tested: OAT improves real-robot task success over QueST with full-token decoding.

Tested

Paper
arXiv⁠ (opens in a new tab)
Code
GitHub⁠ (opens in a new tab)
Venue
RSS 2026
Authors
Chaoqi Liu et al.
Farm tasks
3
Evaluation
540 episodes (270 for baseline, 270 for method)

Result

Improvement over baseline

Not replicated

Reported
+33 pts
Ours
−16 pts
−200+20+40+60
  • Gain vs baseline
  • 95% CI, −28 pts to −2 pts
  • Paper's reported gain
  • No difference

Success rate

Reported
80%
Ours
23%
0%20%40%60%80%100%
  • Measured on our stations
  • 95% CI, 16%–33%
  • Reported in the paper

Across iterations

  1. Iteration 1vs QueST+3 pts
  2. Iteration 2vs QueST−8 pts
  3. Iteration 3vs QueST−16 pts
−200+20+40+60

By task

TaskBaselineQueSTMethodOATImprovement
e01Clamp electrical component0%0/300%0/300 pts−11 to +11
e02Place loaded boxes in container (bimanual)37%11/300%0/30−37 pts−54 to −18
e03Pour screws into the funnel80%24/3070%21/30−10 pts−31 to +12
All tasks39%35/9023%21/90−16 pts−28 to −2
Reported in the paper48%80%+33 pts

Rollouts

One clip per environment from this entry's evaluation, beside where each evaluation episode placed the environment's objects, coloured by its rating. Use the button beside each environment to open its evaluation dataset in the dataset viewer.

  1. e03Pour screws into the funnel
  2. Held-out benchmark environment
    e01Clamp electrical component
  3. Held-out benchmark environment
    e02Place loaded boxes in container (bimanual)

Implementation Details

What we changed

We implemented OAT and QueST on the paper’s shared autoregressive backbone, ported from the authors’ code. The two arms differ only in the action tokenizer, and both decode all 16 tokens. Differences from the paper:

  • Token budget. Both tokenizers compress each chunk into 16 tokens over the paper’s 1,000-entry codebook instead of 8, doubling the token budget because our policy controls two arms instead of the paper’s one. QueST halves its temporal downsampling to produce the 16 tokens.
  • Pretrained visual encoder. Both arms use an ImageNet-pretrained ResNet-18 with BatchNorm and ImageNet input normalization, instead of the paper’s randomly initialised ResNet with GroupNorm. This follows review feedback after the first round, in which both arms rarely succeeded.
  • One observation frame. Both arms see one frame instead of two, because station serving sends one observation per request.
  • Two arms and three cameras. Actions are 20-D end-effector poses for two arms at 30 Hz with three cameras, instead of a 7-D single arm with one webcam.
  • Chunk-relative actions. Positions and rotations in each chunk are expressed relative to the current end-effector pose, while gripper widths stay absolute.
  • Larger crop. Random crops keep 116 of 128 pixels instead of 76.
  • Checkpoint selection. Both arms hold out every tenth demonstration, train for at most 8,000 steps and serve the checkpoint with the lowest held-out position error of sampled actions, instead of selecting checkpoints by simulated success.
  • Blend execution. Both arms run on the station’s blend runtime, which crossfades overlapping chunks, instead of executing 16 of 32 actions and replanning synchronously.
  • QueST loss. QueST’s reconstruction loss is computed on normalized actions.

See the code changes on GitHub⁠ (opens in a new tab)

Prompt summary

Scale the token budget with action dimensionality for both arms, since both tokenizers were under-capacity for 20-D chunks. Run tokenizer-only sweeps (16 and 32 tokens with a 1000-entry codebook), then train policies at 16 tokens x 1000 codebook (FSQ [8,5,5,5]). Select checkpoints on held-out sampled position error; run one full-decoding eval per policy and no prefix-decoding evals.

Response summary

QueST vs OAT: pour 24/30 vs 21/30, boxes 11/30 vs 0/30, clamp 0/30 vs 0/30; OAT −15.6 pp success (p = 0.002), −11.8 pp progress (p = 0.003). Held-out action error nearly identical for both arms.

Conclusion

Not reproduced: QueST ahead, mainly on boxes; more tokens helped QueST more than OAT. OAT most likely performs worse because of the short action chunk (32 steps at 30 Hz), which only captures about 1 s of motion and leaves its ordered coarse-to-fine tokens little long-horizon structure to exploit. Concluded.