- Rating
- 4(+1)
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 3
Read review
Paper summary
Through a systematic empirical study, this paper investigates whether discrete action representations can achieve performance comparable or even superior to continuous action representations in robotic manipulation. The authors compare four policy formulations including CR, CF, DR, and DF, finding that simple uniform quantization suffices to achieve competitive task success rates. Further analysis reveals that discrete policies better capture temporal action variations and state responsiveness, although independent token prediction may introduce factorization errors, while iterative refinement and classifier free guidance help mitigate this issue. Moreover, empirical results indicate that sophisticated tokenization methods and explicit geometric constraints fail to outperform the best uniform quantization scheme. Through experiments on RoboMimic, RoboCasa, LIBERO, and real world robots, combined with analyses of action prediction error, temporal variation, and prediction consistency, the authors validate the effectiveness and potential advantages of discrete action representations.
Critical strengths
None
Critical weaknesses
None
Questions for authors
-
On RoboCasa, the performance gap between DF (53.9 ± 1.2%) and CF (52.7 ± 3.4%) is relatively small. Meanwhile, the two methods differ substantially in the number of generation steps across several experiments; for instance, in RoboMimic, DF uses 100 steps whereas CF uses only 9 steps. However, the paper lacks a comparison of actual inference time. Could the authors provide the inference latency of different policies on identical hardware and analyze the trade-off between task success rate and computational overhead? If DF incurs significantly higher inference costs, its marginal performance gain over CF may be of limited practical value in real-world robot control.
-
The authors attribute the primary challenge of discrete policies to Factorization Error and explain the effectiveness of iterative refinement and CFG through the reduction of token-level multimodal ambiguity. However, multimodality within a single token is not directly equivalent to joint inconsistency across temporal steps or action dimensions. Furthermore, as noted in Appendix E.1, varying the NFE also alters the flow time corresponding to the final prediction. Could the authors further clarify how the existing experiments disentangle the effects of improved joint consistency, reduced distribution entropy, and changes in the final prediction flow time? Additionally, Appendix F.1 shows that with frequency (quantile) bins, DR achieves a 49.8% success rate even without CFG, despite its factorized prediction structure remaining unchanged. This suggests that tokenization itself may have a substantial impact on performance. Please explain this phenomenon and further clarify the relative contributions of Factorization Error and tokenization to performance.
-
The paper validates the effectiveness of discrete action representations on three real-world robot tasks, but the description of the experimental protocol is rather brief, and the results are only presented as a small subplot in Fig. 1(b). Could the authors provide additional details, including the number of evaluation trials per task, the exact success rates, and the source and scale of the training datasets?
-
The main experiments adopt 512 uniform quantization bins, demonstrating that discrete actions are highly competitive under this setting. However, the relationship between quantization resolution and control precision has not been systematically investigated. We suggest that the authors analyze task success rates and action prediction errors across different numbers of bins, particularly on high-precision tasks such as Tool Hang, to illustrate when quantization error becomes a performance bottleneck.
5 comments
Joint consistency, entropy, flow time; quantile-bin DR
Q2. Joint consistency, entropy, flow time; quantile-bin DR
Joint consistency rather than single tokens. We measure factorization error at the chunk level: the number of ambiguous tokens within one chunk (Fig. 4(b), Fig. 9(a)). We also measure incompatible decoded chunks directly in Push-T. From a symmetric start, the pusher should go around the T block either on the left or on the right, and a chunk that switches between the two plans runs into the block (Fig. 5). In that setting we decode 500 chunks per head and count the chunks whose planned path enters the block:
| DR CFG 0 | DR CFG 2 | DF NFE 1 | DF NFE 2 | DF NFE 5 | DF NFE 10 | CF (NFE 10) | CR | |
|---|---|---|---|---|---|---|---|---|
| Incompatible chunks (%) | 18.4 | 12.6 | 15.0 | 10.2 | 3.6 | 3.2 | 2.8 | 8.8 |
Guidance lowers incompatible chunks for DR from 18.4% to 12.6%, and refinement lowers them for DF from 15.0% at NFE 1 to 3.6% at NFE 5, close to CF (2.8%).
Entropy and joint consistency. These are not separate effects: lower token entropy is how joint consistency improves. A token with a sharp distribution rarely keeps mass on more than one mode, so as entropy falls, fewer tokens in a chunk are ambiguous. A chunk can only mix modes if at least two of its tokens are ambiguous, so fewer ambiguous tokens means a lower chance of factorization error. Formally, for a chunk , the error of decoding it from per-token marginals is , which goes to zero as the token entropies do. Refinement lowers token entropy because each step conditions on the tokens already committed. Guidance lowers it by sharpening each token's distribution against the unconditional one. Both reduce the ambiguous tokens per chunk (Fig. 4(b), Fig. 9(a)) and the incompatible chunks in Push-T (table above).
Why guidance matters for uniform bins. With uniform bins, the training actions are spread very unevenly over the bins. On each translation axis, 10–14% of all training values fall in the two bins around zero motion, 11–15 times the average share of the 222 bins in use.
This imbalance shapes the ambiguous tokens. A typical ambiguous token has two modes: a narrow spike at the zero-motion bin, inherited from the frequent zero-motion actions, and a broad peak over the bins of the intended motion. The broad peak can hold more total mass, but it is spread over many bins, so each of its bins is lower than the spike. Argmax picks the single highest bin, so it often lands in the spike. Calling the mode with more total mass the heavier mode, at CFG 0 the argmax lands in the heavier mode for only 44% of ambiguous tokens. Because each token decides on its own, the chunk often combines choices from different modes.
Guidance divides out the unconditional distribution, which carries the zero-motion spike. At CFG 2, the argmax lands in the heavier mode for 61% of ambiguous tokens, fewer chunks mix modes, and uniform-bin DR rises from 27.1% to 49.2%.
Why it matters less for quantile bins. With equal-frequency bins, every bin holds the same share of the training actions, so the background is close to uniform from the start. Ambiguous tokens are about half as common (4.2% of translation tokens, against 7.7% for uniform bins), and the argmax already falls in the heavier mode more often (56% against 44%). Guidance has little left to correct, because ambiguity within the chunk is already low.
Relative contributions. For one-pass argmax decoding, tokenization and guidance act on the same mechanism: a biased background distribution turns token ambiguity into incompatible chunks. Quantile bins remove the bias in the representation, and guidance removes it at decoding time. This is also why quantile bins do not help DF (46.0% vs. 53.9% with flat bins; reply to twnJ-Q3): iterative decoding already removes most of the factorization error.
Final flow time. The sentence in App. E.1 contains a typo: is the share of committed tokens at the last query, , not the flow time. The final flow time depends on the scheduler. Our DF uses the cubic scheduler with steps that are uniform in , so the last query is at : 0.93, 0.97, and 0.98 at NFE 5, 10, and 20. Over this range the final flow time barely changes, while ambiguous tokens per chunk fall from 1.50 to 0.22. The drop in ambiguity therefore does not come from a later final prediction. We correct the sentence in the revision.
Real-robot protocol & Bin count and control precision
Q3. Real-robot protocol
We add the protocol and a per-task table to App. A.3. The real-robot experiments use a bimanual setup with two 6-DoF arms and three cameras (one base and two wrist cameras, 224×224). Actions are 14-D: joint targets for both arms relative to the current state, plus absolute gripper commands, predicted in chunks of 24 steps. All four heads start from the base weights [Black et al. 2025], are pre-trained on a large in-house multi-task bimanual teleoperation corpus (about 250K episodes over more than 150 tasks, recorded at 30 Hz), and are fine-tuned per task on 50 demonstrations of that task, with the same recipe for every head. Each head is evaluated for 10 trials per task with randomized object placement. A trial counts as a success when every bottle ends fully inside the bin and the bin stays upright (throw bottles), when the cap is fully separated from the pen and both rest on the table (open pen cap), or when the mug ends upright and straight (turn mug up).
| Task | DF | CF | DR | CR |
|---|---|---|---|---|
| Throw bottles into bins | 9/10 | 9/10 | 8/10 | 6/10 |
| Open pen cap | 7/10 | 7/10 | 4/10 | 4/10 |
| Turn mug up | 8/10 | 7/10 | 5/10 | 3/10 |
| Total | 24/30 | 23/30 | 17/30 | 13/30 |
With 10 trials per cell the intervals are wide, so we read these results as consistent with the simulation ranking rather than as separate evidence: over the three tasks, the flow heads (DF 24/30, CF 23/30) lead the regression heads (DR 17/30, CR 13/30), and DR matches or beats CR on every task.
Q4. Bin count and control precision
We train DF and DR on Tool Hang and Transport with bins in two action spaces (relative and absolute end-effector actions), keeping everything else fixed. Each cell is success rate / EEF error (mm).
Tool Hang
| Bins | DF relative | DF absolute | DR relative | DR absolute |
|---|---|---|---|---|
| 64 | 0.82 / 13.0 | 0.38 / 12.2 | 0.08 / 16.5 | 0.05 / 10.0 |
| 128 | 0.82 / 9.4 | 0.44 / 9.5 | 0.11 / 10.9 | 0.08 / 6.6 |
| 256 | 0.85 / 7.5 | 0.53 / 6.5 | 0.12 / 6.6 | 0.09 / 7.6 |
| 512 | 0.87 / 8.5 | 0.53 / 8.7 | 0.16 / 9.0 | 0.12 / 4.1 |
| 1024 | 0.83 / 7.7 | 0.50 / 7.7 | 0.20 / 9.5 | 0.15 / 5.9 |
Transport
| Bins | DF relative | DF absolute | DR relative | DR absolute |
|---|---|---|---|---|
| 64 | 0.50 / 8.1 | 0.50 / 8.5 | 0.20 / 10.9 | 0.16 / 13.7 |
| 128 | 0.63 / 5.6 | 0.56 / 6.0 | 0.40 / 7.7 | 0.30 / 8.3 |
| 256 | 0.60 / 5.3 | 0.56 / 5.8 | 0.43 / 5.6 | 0.37 / 7.7 |
| 512 | 0.66 / 4.9 | 0.56 / 6.7 | 0.47 / 5.3 | 0.40 / 5.9 |
| 1024 | 0.63 / 5.6 | 0.60 / 7.7 | 0.48 / 5.2 | 0.42 / 6.0 |
The tables show three trends. (1) On Tool Hang, the number of bins matters more in the absolute action space than in the relative one: for DF, success rises from 0.38 to 0.53 with more bins in the absolute space but stays at 0.82–0.87 in the relative space. (2) It matters more for DR than for DF: DR success grows steadily with the number of bins on both tasks (relative actions: 0.08 to 0.20 on Tool Hang, 0.20 to 0.48 on Transport), while DF changes much less. (3) For DF, success levels off above a moderate number of bins: from at most 256 bins in every setting, so our default of 512 bins lies on this plateau.
The EEF error mostly follows the same pattern as success. It depends less on the number of bins for DF than for DR (e.g. Transport, relative actions: 8.1 to 4.9 mm for DF, 10.9 to 5.2 mm for DR), and it mostly stops decreasing beyond 256 bins. Bin resolution is not what limits DR: with absolute actions on Tool Hang, DR has a lower EEF error than DF at 512 bins (4.1 vs. 8.7 mm) but much lower success (0.12 vs. 0.53). The gap comes from one-pass decoding, not from quantization.
References
- [Black et al. 2025] K. Black, N. Brown, D. Driess, et al. : A Vision-Language-Action Flow Model for General Robot Control. RSS 2025.
Inference latency and the success/compute trade-off
We thank the reviewer for the detailed questions on cost, mechanism, the real-robot protocol, and bin count.
Q1. Inference latency and the success/compute trade-off
On RoboCasa, DF and CF use the same action head (about 370M parameters) on the same backbone, so their cost per step is the same and the comparison comes down to the number of steps. We evaluate the same checkpoint of each head at every NFE (success in %, mean ± SD over five evaluation seeds, 500 episodes each):
DF does not need more steps than CF. Without guidance, both plateau at NFE 5. With guidance, DF reaches 52.4% already at NFE 2, while CF needs NFE 10 for the same result (0.3% at NFE 2).
We time the same checkpoints on one real RoboCasa observation (one H200, bf16, batch 1, no compilation; median of 20 runs after warm-up). The backbone pass is shared by all heads and takes 23 ms. Action-head time per chunk, in ms:
One pass: DR 7.3 ms (CFG 0), 11.7 ms (CFG 2); CR 4.9 ms.
A network pass costs about the same in both heads (4.8 vs. 4.4 ms), and guidance doubles it. Under guidance, DF is 2.5× faster than CF at the same success: DF reaches 52.4% in 45 ms per chunk (23 ms backbone + 22 ms head), while CF needs 111 ms. Guided DR takes 35 ms for 49.2%. All of these finish long before a 24-step chunk ends.
In RoboMimic, 100 steps is our default setting for DF. We re-evaluated DF policies trained with the recipe of the paper at each NFE, with the same 256 episodes for every setting (chunk time at batch 1 on one L40S, fp32, without compilation):
As in RoboCasa, success changes little beyond NFE 10, while the chunk time grows linearly with NFE. One network pass costs about 8–9 ms in both flow heads, and the one-pass heads take about 9 ms per chunk (DR 8.8 ms, CR 8.5 ms). In the revision we change the default for DF in RoboMimic to NFE 9 to match CF.