{"id":"115db209-8d0d-4e17-bbc0-03e4f2614c9d","arxiv_id":"2608.09138","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"A learned speed policy adds state-dependent speed control to a frozen imitation policy, achieving over 2.4x faster execution while preserving task success.","lead":"SpeedTuning is a reinforcement learning method that teaches a robot to speed up or slow down the actions of an already-trained imitation policy, without collecting new demonstrations. The method reports over 2.4x faster task completion on dynamic tasks such as pouring, throwing, and picking, while keeping success rates close to the original policy.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Eq. 9 does not implement linear temporal interpolation; the extra 1/v factor distorts non-integer speeds, undermining the mapping between speed multiplier and actual time scaling.","rationale":"The reader identified interpolation over action chunks as the load-bearing component and worried about whether physical dynamics make time-scaling invalid. The present concern is more immediate and more specific: the interpolation formula as written is not linear time scaling, even in the frictionless, kinematic sense. This is an internal inconsistency rather than a disagreement with consensus, so it directly threatens the soundness of the mechanism. The experiments may have been run with code that implements the intended formula, but the paper's formal definition is then wrong, or the code reproduces Eq. 9 and the reported speed multipliers do not mean what the text claims. Either way, the central claim should not be accepted without a correction and a re-run on at least one representative task to confirm that the empirical conclusions are unchanged. I keep the reader's CONDITIONAL verdict because the issue is checkable and potentially fixable; if the re-run shows materially worse speed-up or success, the verdict would move toward REJECT.","tokens_in":10330,"tokens_out":14399,"duration_ms":149002,"concrete_test":"Recompute the accelerated action sequences in Section III-F using the standard time-scaling formula g(i) = (1 - frac(v*i)) * f(floor(v*i)) + frac(v*i) * f(floor(v*i)+1) for all non-integer speeds, and rerun the fixed-speed baselines and SpeedTuning on at least Simulated Tea Bag Transfer. If the success-versus-speed curves change materially, or if the 2.4x speed-up point moves outside the reported error bars, then the extra 1/v factor in Eq. 9 is a substantive error affecting the central claim rather than a harmless typo.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The load-bearing assumption in Section III-F is that linear temporal interpolation over action chunks executes the same underlying trajectory in 1/v of the time. As written, Eq. 9 does not implement this. For a time-scaled sequence, the accelerated action at step i should be f(v*i), with fractional interpolation weight (v*i - floor(v*i)) between f(floor(v*i)) and f(floor(v*i)+1). Eq. 9 instead uses weight (v*i - floor(v*i))/v. Example: with f(i)=i, v=1.5, and i=1, the correct interpolant is 1.5, while Eq. 9 gives 1 + 0.5/1.5 = 1.333. Thus for every non-integer speed, including the fixed-speed baseline sweeps at 0.1 intervals in Fig. 4 and any learned fractional speed, the speed multiplier v does not correspond to uniform time scaling of the base policy. The claim that a speed-v chunk is executed in (k+1)/v steps (Eq. 11) is only partially true: the step count shrinks, but the trajectory is distorted in a way that depends on v. Because the speed-modulation mechanism and the interpretation of the success-versus-speed Pareto plots rest on this mapping, the central claim is not internally well-defined until Eq. 9 is corrected or the paper explicitly specifies the non-uniform mapping being used.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces SpeedTuning, a reinforcement learning framework that trains a discrete-action speed policy on top of a frozen imitation learning policy. The speed policy outputs a speed multiplier, and action chunks from the base policy are linearly interpolated in time according to that multiplier. The combined reward is a weighted sum of a speed reward and the task success reward, and the speed policy is trained with Rainbow DQN. The authors evaluate the method on three simulated and three real-world ALOHA manipulation tasks, reporting over 2.4x speed-ups with preserved success rates relative to the original policy and to a fixed-speed interpolation baseline, and they provide ablation studies over the task policy, image observations, speed reward exponent, and frame skip.","tokens_in":10620,"tokens_out":7079,"duration_ms":66607,"significance":"If the central claim holds, SpeedTuning offers a practical way to retrofit existing imitation-learned policies with faster execution without collecting new demonstrations, and the paper would make a useful contribution to the growing literature on efficient robot manipulation. The work has several concrete strengths: the method is clearly described, the RL formulation is standard, code and videos are promised, and the ablation studies cover important design choices. The reported result that a learned adaptive speed policy can outperform a fixed-speed baseline on dynamic and precise tasks is interesting and plausible. However, the correctness of the reported speed-ups depends on a precise and correct mapping between the speed multiplier and actual time scaling, and this part of the manuscript currently contains a technical error that needs to be resolved before the claims can be accepted.","major_comments":[{"comment":"Equation (9) does not implement linear temporal interpolation as claimed. Standard time scaling of a function f at speed v evaluates f(vt), with fractional interpolation weight vt - floor(vt) between f(floor(vt)) and f(floor(vt)+1). The extra division by v in Eq. (9) gives weight (vt - floor(vt))/v instead. For f(i)=i, v=1.5, and i=1, the correctly time-scaled value is 1.5, whereas Eq. (9) yields 1 + 0.5/1.5 = 1.333. Consequently, the multiplier v in Eqs. (10)-(11) does not correspond to uniform time scaling of the base action chunk. Moreover, the number of executed steps in Eq. (11) is floor((k+1)/v)+1, which is larger than (k+1)/v for non-integer v, so the effective speed-up is smaller than v. Because the speed reward and the fixed-speed baseline sweep in Fig. 4 both rely on interpreting v as an actual speed multiplier, this issue is load-bearing for the central claim. Please correct the interpolation formula or explicitly define the non-uniform mapping actually used, and re-derive the effective speed-up and the Pareto plots accordingly.","section":"Section III-F, Eq. (9)"},{"comment":"The headline claim of \"over 2.4x speed-up\" is never precisely defined. It is unclear whether speed-up is measured as total episode wall-clock time, total number of environment steps, average selected speed multiplier, or the ratio of original episode length to accelerated episode length. Equations (9)-(11) suggest a step-count reduction per chunk, but the episodic speed-up also depends on how non-integer speeds and the final partial chunk are handled. Please state the exact formula used to compute the reported speed-ups and clarify whether results are based on environment steps or physical time. Without this definition, the reader cannot verify the central quantitative claim.","section":"Section IV-C and Fig. 4"},{"comment":"The method's core assumption is that linearly interpolating the joint-position action chunk at speed v faithfully produces the same underlying task trajectory in 1/v of the time. This assumption is not verified in the paper, and it is especially nontrivial for contact-rich and dynamic tasks where physical dynamics, friction, and control frequency can make time-scaled action sequences invalid. Even after correcting Eq. (9), the authors should provide direct evidence for this assumption, for example by comparing the interpolated action execution against executing the original action sequence at a higher hardware command rate, or by measuring the actual trajectory achieved under both schemes. If the assumption fails, the speed policy cannot fully compensate, since it only selects multipliers over interpolated actions.","section":"Section III-F and Section IV-C"}],"minor_comments":[{"comment":"The introduction states that the method is compared \"against reinforcement learning from scratch and a naive speed-up baseline,\" but the experiments only report the fixed-speed interpolation baseline. Either add the RL-from-scratch comparison or revise the introduction to remove the unfulfilled promise.","section":"Section I vs. Section IV"},{"comment":"The phrase \"requires no extra data-collection\" is misleading: training the speed policy with reinforcement learning requires collecting environment interaction samples. The intended meaning is presumably \"no additional human demonstrations.\" Please clarify this in the text.","section":"Section I and Section III"},{"comment":"The caption notes that the real-world speed policy was not trained to full convergence. This is an important limitation that should appear in the main text as well, and the abstract's claim of demonstrating \"robustness in real-world robotic manipulation\" should be moderated accordingly.","section":"Fig. 4 caption"},{"comment":"The main experiments use beta=2 and frame skip=10, which are selected via ablations on Simulated Tea Bag Transfer. Please state explicitly whether the same hyperparameters were used across all six tasks, and report the sensitivity of the main results to this choice.","section":"Section V and Fig. 6"}],"recommendation":"major_revision","confidential_remarks":"The principal technical issue is the interpolation formula in Eq. (9), which affects the meaning of every reported speed-up. If the authors confirm that the implementation actually matches the corrected time-scaling formula and rerun or re-analyze the experiments accordingly, the paper is likely salvageable. The missing RL-from-scratch comparison and the undefined speed metric should also be addressed, but they are not the main obstacle to publication."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"SpeedTuning is a clean, practical idea—train a lightweight RL policy to choose execution speeds for a frozen imitation policy—and the paper's experiments are broad enough that it deserves a serious referee. But it has a technical bug in the interpolation equation that needs fixing before the speed claims are fully trustworthy.\n\nThe core contribution is genuinely new: instead of fine-tuning the base policy, they train a separate speed policy on a discrete set of multipliers and use action-chunk interpolation to time-scale the base policy's outputs. That's a neat decoupling, and the ablations (choice of task policy, image observations, speed reward exponent, frame skip) give real insight. The simulated and real-world tasks cover a useful range, and the results show meaningful speed-ups with maintained success.\n\nNow the soft spots. The load-bearing one is Eq. 9. As written, the interpolation weight is (vt - floor(vt))/v, not (vt - floor(vt)). For any non-integer speed, this means the action sequence is not actually the linear temporal interpolation of the original chunk at the claimed speed factor. The fixed-speed baseline sweeps use speeds at 0.1 and 0.25 intervals, so all those points are distorted. The learned speed policy might also select non-integer speeds. This doesn't kill the approach—the RL policy could in principle adapt to the distorted mapping—but it breaks the paper's central interpretation that a speed multiplier v uniformly shortens the trajectory by 1/v. The equation needs to be corrected or the mapping explicitly defined.\n\nTwo other gaps: the introduction promises a comparison against reinforcement learning from scratch, but the experiments never show it; and the speed-up metric is never defined precisely (episode steps? wall-clock? success rate? all of these?). Also, the real-world RL is admittedly under-converged, so those results are preliminary. The Pareto improvement over the fixed-speed baseline is partly by construction—the speed policy can choose any constant speed—but that's not a fatal flaw; it's just something to frame honestly.\n\nIf I were editing, I'd send this to peer review with a request to fix Eq. 9, add or remove the RL-from-scratch promise, and define the speed metric. The idea is solid; the execution needs cleanup.","headline":"SpeedTuning is a clean, practical idea—train a lightweight RL policy to choose execution speeds for a frozen imitation policy—and the paper's experiments are broad enough to warrant serious review, but a technical error in the interpolation equation and a missing promised baseline need fixing first.","tokens_in":11126,"tokens_out":6607,"would_cite":false,"duration_ms":59996,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"SpeedTuning speeds robot policies 2.4x without collecting new demonstrations.","keywords":["SpeedTuning","imitation learning","reinforcement learning","robot manipulation","action chunking","temporal interpolation","policy acceleration","speed policy"],"falsifier":"Run the same base policy on a contact-rich task at the episode-average speed SpeedTuning chooses, replacing the speed policy with a fixed multiplier of that value; if success matches SpeedTuning, the claim that state-dependent speed selection is necessary would fail. More directly, compare the rollout from executing an interpolated action chunk at 2x against the original chunk at 1x under identical dynamics; if contact forces or control frequency cause the 2x rollout to diverge from the underlying planned trajectory, the time-scaling premise fails.","tokens_in":10104,"feed_emoji":"🤖","tokens_out":4627,"duration_ms":47546,"temperature":0.7,"pith_summary":"SpeedTuning claims that an imitation-learned manipulation policy can be run much faster by adding a lightweight, reinforcement-learned speed policy that chooses how fast to execute each chunk of actions. The speed policy is trained on top of a frozen task policy, using a reward that combines task success with a speed incentive, so it learns to slow down for contact-rich or dynamic phases and speed up during less demanding stages. The paper reports over 2.4x speed-ups across six simulated and real tasks while preserving adequate success rates, beating both the original policy and a fixed-speed interpolation baseline.","feed_headline":"SpeedTuning speeds robot policies 2.4x without new demos","feed_subtitle":"A reinforcement-learned speed policy slows down for hard steps and rushes easy ones, beating fixed-speed interpolation.","key_machinery":"The central machinery is the speed policy $\\pi_\\varphi(v_t|s_t)$ coupled with linear temporal interpolation over action chunks (Eqs. 9-11). The base policy emits a chunk of joint-position actions; the speed policy selects a discrete speed multiplier; the chunk is re-sampled in time by interpolation, effectively shrinking the chunk length to $(k+1)/v$. This single scalar re-tempos the frozen task policy, and the reinforcement-learning objective $r_{ST} = \\alpha v^{\\beta} + r_{task}$ gives the speed policy a task-sensitive speed schedule.","core_discovery":"The paper's central claim is that execution speed can be treated as a controllable action dimension on top of a frozen imitation policy, without retraining the task policy or collecting new demonstrations. SpeedTuning factorizes the policy into a task policy and a speed policy, and uses linear temporal interpolation over action chunks to convert the speed policy's chosen multiplier into accelerated joint-position commands. The speed policy observes RGB images, joint positions, and joint speeds, outputs a multiplier from a discrete set, and is optimized with Rainbow DQN; it deliberately lowers speed at critical moments such as grasping, pouring, or synchronizing with a swinging tea bag, and raises it during less critical phases. Across cube transfer, peg insertion, tea bag transfer, tea bag disposal, food preparation, and almond pouring, the paper reports over 2.4x speed-up with success comparable to the base policy and better than uniform acceleration.","pith_inferences":["Inference: The same speed-policy interface could accelerate other chunked visuomotor policies, such as diffusion-based policies, without retraining, making SpeedTuning a general post-hoc accelerator for imitation-learned manipulation.","Inference: Co-training the speed policy jointly with the task policy might recover success in contact-rich settings where pure interpolation distorts the planned trajectory, because the task policy could adapt its actions to the selected tempo.","Inference: The speed policy's reliance on image observations suggests it is learning phase detection; a cheaper task-progress estimator could potentially replace the RL-trained component and yield similar speed-ups, separating 'when to go fast' from 'how to go fast'.","Inference: The $\\alpha$ and $\\beta$ reward parameters define a tunable speed-success frontier, so a practical deployment could automatically select these weights to meet a target success-rate constraint."],"forward_implications":["Existing imitation policies can be accelerated at deployment time without recollecting demonstrations or retraining the base policy.","State-dependent speed selection improves the speed-success Pareto frontier, especially on dynamic tasks where fixed multipliers fail.","The method applies across different chunked task-policy architectures and transfers from simulation to real-world manipulation.","The learned speed policy effectively segments a task into critical and non-critical phases, yielding interpretable slow-down and speed-up behavior."],"supporting_citations":[{"why":"Supplies the ACT task policy, the action-chunking formulation, and the ALOHA hardware setup used across all experiments.","marker":"[1]"},{"why":"Grounds the assumption that modern imitation policies emit action chunks that can be temporally interpolated.","marker":"[9]"},{"why":"Supplies Rainbow DQN, the off-policy reinforcement learning algorithm used to train the speed policy.","marker":"[34]"}],"fun_headline_variants":["SpeedTuning: 2.4x faster manipulation without new data","RL speed policy boosts robot execution 2.4x","Imitation policies get a speed multiplier via RL","SpeedTuning accelerates robot policies adaptively","Faster robot manipulation with learned speed control"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The base policy's action chunks can be faithfully accelerated by linear temporal interpolation, so executing the time-warped action sequence at speed $v$ actually produces the same task-relevant trajectory in $1/v$ of the time.","fun_headline_variants_meta":{"raw":{"variants":["SpeedTuning: 2.4x faster manipulation without new data","RL speed policy boosts robot execution 2.4x","Imitation policies get a speed multiplier via RL","SpeedTuning accelerates robot policies adaptively","Faster robot manipulation with learned speed control"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000243,"raw_usage":{"total_tokens":1520,"prompt_tokens":926,"completion_tokens":594,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":542,"completion_tokens_details":{"reasoning_tokens":518}},"tokens_in":542,"tokens_out":594,"duration_ms":5850,"temperature":1.0,"reasoning_tokens":518,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T04:16:10.367540+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the same base policy on a contact-rich task at the episode-average speed SpeedTuning chooses, replacing the speed policy with a fixed multiplier of that value; if success matches SpeedTuning, the claim that state-dependent speed selection is necessary would fail. More directly, compare the rollout from executing an interpolated action chunk at 2x against the original chunk at 1x under identical dynamics; if contact forces or control frequency cause the 2x rollout to diverge from the underlying planned trajectory, the time-scaling premise fails.","supporting_citations":[{"cited_title":"Rainbow: Combining improvements in deep reinforcement learning,","cited_arxiv_id":null,"evidence_quote":"Supplies Rainbow DQN, the off-policy reinforcement learning algorithm used to train the speed policy."}],"review_version":2}