{"id":"1f9a8740-ab6f-4066-9d3a-8e2f948dbf8e","arxiv_id":"2512.01031","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"Conditioning a VLA on a forward-rolled future robot state, trained with temporal-offset augmentation, removes the prediction-execution delay in asynchronous control.","lead":"A system called VLASH lets robots run action-planning models in the background while still moving, by telling the model what the robot's body position will be when the next commands arrive. On simulated and physical robots it cuts reaction delay by up to roughly 17x and enables large vision-language-action models to play ping-pong, which synchronous inference cannot do.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Central mechanism unproven: gains may come from offset fine-tuning alone, not from conditioning on the rolled-forward future state.","rationale":"The reader identified the roll-forward identity as the weakest assumption. That is a legitimate concern, but I find a more load-bearing issue: the paper's own evidence that VLA state inputs are under-utilized, combined with the co-introduced offset fine-tuning, means the causal role of the future state is not established. Even a perfect roll-forward would be irrelevant if the policy ignores the state; and the offset augmentation alone could plausibly teach the model to compensate for delay using visual features, which would explain the async gains independently of the state channel. The concrete test isolates the state channel at inference while holding the offset augmentation fixed, which directly targets the central claim. This reinforces the reader's CONDITIONAL verdict: the method is plausible and may work, but the mechanism is not yet verified. A REJECT would be too strong because the empirical results might still hold irrespective of mechanism; an ACCEPT requires the missing ablation.","tokens_in":17623,"tokens_out":5255,"duration_ms":54183,"concrete_test":"Run the following ablation on LIBERO and Kinetix with π0.5 fixed: (A) VLASH exactly as reported (offset fine-tuning + rolled-forward state at inference); (B) identical offset fine-tuning but at both training and inference replace the state input with a constant zero vector (or omit state); (C) identical offset fine-tuning but at inference feed the current state s_t instead of s_{t+Δ}. If (B) or (C) matches or exceeds (A), the claimed future-state mechanism is not the source of improvement. Additionally, in simulation, compare (A) against feeding the ground-truth future state at execution start (oracle); if oracle outperforms rolled-forward by more than a small margin, the roll-forward identity itself is a limiting error source.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"VLASH's central claim is that conditioning on the rolled-forward future state s_{t+Δ} bridges the prediction–execution gap. But Sec. 4.2 states that π0.5 'largely relies on visual input and under-utilizes the robot state' and that fine-tuning without state input outperforms fine-tuning with state input on LIBERO. The paper then introduces temporal-offset fine-tuning to force state usage, yet never ablate the state channel at inference. The reported improvements over naive async (e.g., 30.5% on Kinetix) could therefore stem entirely from the offset augmentation—training the model to predict action chunks that start Δ steps in the future from a stale observation—rather than from the network actually using the future state input. The roll-forward identity s_{t+Δ}=s_t+Σ a_i (Sec. 4.1, Fig. 3c) is a second, related concern: it assumes deterministic additive state evolution with no dynamics, slip, or tracking error. But even if the roll-forward were perfect, the method would not work as advertised if the model ignores the state. Conversely, if the model does use the state, roll-forward error in contact-rich tasks could be substantial. The paper provides neither a causal isolation of the state channel nor a quantitative comparison of rolled-forward vs. true future state, leaving the core mechanism underspecified.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes VLASH, a framework for asynchronous inference of Vision-Language-Action models. The central idea is to condition the policy on a rolled-forward future robot state s_{t+Δ}, computed as the current state plus the remaining actions from the previously issued action chunk, after fine-tuning with temporal offsets on states and actions. This is intended to bridge the prediction–execution gap caused by inference delay. The paper also contributes an efficient shared-observation fine-tuning scheme and an action-quantization method for additional speed. Experiments on Kinetix and LIBERO report accuracy improvements over naive asynchronous inference (up to 30.5% on Kinetix), and real-world experiments on π0.5 report up to 2.03× task speedup and large reaction-latency reductions, including dynamic tasks such as ping-pong and whack-a-mole.","tokens_in":17891,"tokens_out":7344,"duration_ms":75783,"significance":"If the mechanism is validated, VLASH is practically significant: it offers a simple, low-overhead route to asynchronous VLA control and enables dynamic tasks that are infeasible with synchronous inference. The paper's strengths include a clean formulation, open-source code, real-hardware demonstrations, and a genuinely elegant shared-observation fine-tuning trick that gives a 3.26× training speedup. The core causal claim, however, is not yet isolated: the paper does not demonstrate that conditioning on the rolled-forward future state, rather than the temporal-offset fine-tuning alone, is responsible for the reported gains. The roll-forward identity is also unvalidated in settings with contact, slip, or low-level tracking error. Therefore, the significance is conditional on additional ablations and roll-forward-error quantification.","major_comments":[{"comment":"The central mechanism is not isolated. Section 4.2 states that π0.5 'under-utilizes the robot state' and that fine-tuning without state input outperforms fine-tuning with state input on LIBERO, and that simply feeding a future state at test time is insufficient. Yet the reported improvements over naive async (e.g., 30.5% at Δ=4 on Kinetix) are consistent with an alternative explanation: temporal-offset fine-tuning alone—training the model to predict action chunks shifted by Δ from a stale observation—could produce the gains, with the state channel contributing little. A minimal ablation set is needed: (a) offset fine-tuning with the current state at inference, (b) offset fine-tuning with the rolled-forward future state (VLASH), and (c) standard fine-tuning with future-state conditioning. Table 1 and Fig. 6 do not include these variants, so the paper's title-level claim that future-state","section":"§4.2, Table 1, Fig. 6"},{"comment":"The roll-forward identity s_{t+Δ}=s_t+Σ a_i assumes that executed actions are exact additive state deltas with no dynamics, slip, contact forces, low-level tracking error, or safety-layer modification during the inference interval. In contact-rich manipulation and dynamic tasks, the true state at execution start can differ materially from this open-loop prediction; conditioning on an inaccurate future state could degrade rather than improve stability. The manuscript reports no comparison between the rolled-forward state and the actual execution-start state, and no experiment comparing VLASH with the true future state (available in simulation) against the rolled-forward state. Such an experiment would quantify sensitivity to roll-forward error and is necessary to establish the mechanism.","section":"§4.1, Fig. 3(c)"},{"comment":"The speedup claim 'up to 2.03× with preserved accuracy' depends on the quantization factor q being chosen after observing task outcomes. The text says 'we select task-dependent quantization factors that maintain success rates close to the unquantized policy,' but no protocol is given for selecting q without access to test rollouts. Since q is a free parameter tuned to the reported data, the speed-accuracy trade-off is demonstrated but the 'preserved accuracy' speedup is not a predictive claim. Please report a fixed q per task chosen before evaluation, a validation-based selection rule, or a sweep with confidence intervals over held-out rollouts.","section":"§4.4, Fig. 7"}],"minor_comments":[{"comment":"The abstract as reproduced at the top of the manuscript reports 'up to 11.8×' reaction-latency reduction and '1.5-2.0× task completion speedup,' while the full-text abstract reports 'up to 17.4×' and '2.03×.' Please harmonize these numbers.","section":"Abstract"},{"comment":"The main text claims 'no architectural changes,' but Appendix §7.4 describes an optional state-projection layer for π0.5 that 'consistently improves control smoothness.' Please clarify whether the reported real-world results use this modification and soften the 'no architectural changes' claim accordingly.","section":"Abstract / §7.4"},{"comment":"Kinetix success rates are reported without error bars or confidence intervals, despite 1,024 rollouts per data point. Please include standard errors or confidence intervals to support comparisons between VLASH, RTC, and naive async.","section":"Fig. 6"},{"comment":"Kinetix experiments use a 4-layer MLP-Mixer policy rather than a VLA. This is reasonable as a general test of the method, but the paper should be explicit that this result does not directly evaluate a vision-language-action model.","section":"§5.1.1"},{"comment":"The reaction-latency comparison defines asynchronous latency as inference latency only. This is a worst-case assumption that should be stated more carefully: it presumes the event is captured at the start of an inference cycle and that the new action chunk can begin immediately upon completion of inference, with no additional scheduling delay.","section":"§5.2.2, Table 2"},{"comment":"There are minor typos, e.g., 'evalute' in §5.1.2 and 'additonal' in §2. Please proofread the manuscript.","section":"General"}],"recommendation":"major_revision","confidential_remarks":"The reader's central concern is well founded: the missing ablation separating offset fine-tuning from future-state conditioning is load-bearing and should be mandatory before publication. The roll-forward assumption also needs quantitative validation. I do not see grounds for rejection; the work is within scope for a robotics venue and the empirical demonstrations are compelling if the mechanism can be substantiated."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a genuinely useful engineering result, and the Kinetix numbers are real enough to take seriously. But the paper's headline mechanism—conditioning on the rolled-forward future state—is not the only thing that changed between baseline and method. They also introduced temporal-offset fine-tuning, and they never run the ablation that separates the two. So the \"future-state awareness\" story is plausible but unproven.\n\nWhat's new: rolling the robot state forward with the remaining actions from the chunk being executed is a simple, cheap way to estimate the state at the start of the next execution interval. The temporal-offset fine-tuning (offset state and actions, keep the observation fixed) is a sensible way to make a VLA state-aware, and the shared-observation attention that packs multiple offsets in one pass is a nice efficiency trick that gives a real 3.26x training-step speedup. The action quantization is simple aggregation of consecutive deltas; it works, and the speed-accuracy trade-off is honestly presented. The Kinetix and LIBERO results are solid: VLASH clearly beats naive async and RTC under larger delays, and the real-world speedups are plausible. Code is promised, which is good.\n\nThe soft spots are mostly about attribution. The stress-test concern is correct: Section 4.2 explicitly says π0.5 under-utilizes state and that fine-tuning without state input outperforms fine-tuning with state input on LIBERO, then they introduce offset training to force state use. But no experiment varies the state channel at inference. The reported gains over naive async could come entirely from offset augmentation—training the model to predict action chunks that begin Δ steps in the future from a stale observation—without the network ever using the future state. That is a real gap, and it is load-bearing for the paper's central claim. A single ablation (offset-trained model, same observation, compare current-state vs future-state input at inference) would settle it.\n\nSecond, the roll-forward identity s_{t+Δ}=s_t+Σa_i assumes deterministic additive state evolution. In the tested settings it's probably fine (small delays, delta actions, no heavy contact during the inference window), but they don't validate the rolled-forward state against the true future state, and contact-rich tasks could break it. That is a moderate concern, not a fatal one.\n\nThird, the real-world evidence is thin: 16 rollouts per condition, no error bars, and the ping-pong claim is video-only. That's standard for robot demos, but it limits confidence. Abstract says 11.8x while the body says 17.4x for reaction latency; minor editorial slip. And the appendix's optional state-projection layer for π0.5 slightly undercuts the \"no architectural changes\" claim, though it's zero-init and described as optional.\n\nWho this is for: anyone working on deploying VLA policies under latency constraints. It deserves peer review—the system is novel and the results are strong enough to warrant referee time. But the revision needs to isolate the state channel before the mechanism claim is accepted.","headline":"A clean, promising async-inference system whose named mechanism—future-state conditioning—is not actually isolated from the co-introduced offset fine-tuning, so the paper's causal story is under-supported even though the engineering is solid.","tokens_in":18424,"tokens_out":3872,"would_cite":true,"duration_ms":40184,"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":"This paper claims that asynchronous vision-language-action robot control becomes accurate and stable when the policy is fed the robot state at the moment its new actions will actually start executing, a future state computed by rolling the","keywords":["asynchronous inference","vision-language-action","action chunking","future state","temporal offset","action quantization","robot control","latency"],"falsifier":"A concrete experiment: run the same VLASH deployment on a robot with known low-level tracking error—for example, a compliant arm or one with friction—and measure the distance between the computed future state s_{t+Δ} and the measured state at execution start. If that distance exceeds roughly the magnitude of a single action step, the claimed accuracy improvement should reverse. Alternatively, ablate by using a future state computed from random actions or from measured executed actions; if accuracy against naive async collapses when the rollforward is inaccurate, the load-bearing premise is con","tokens_in":1461,"feed_emoji":"🤖","tokens_out":2533,"duration_ms":57626,"temperature":0.7,"pith_summary":"Vision-language-action models (VLAs) that plan robot actions are usually run synchronously: the robot freezes while the model thinks, causing stalls and slow reactions. Running the model in the background while the robot moves fixes latency but creates a mismatch: by the time the model's new action chunk is ready, the robot is in a different state than the one the model saw. VLASH argues this mismatch can be closed without extra computation or architecture changes by feeding the model the future robot state at the start of the next execution interval, computed by rolling the current state forward with the actions still being executed. The paper shows this future-state conditioning, aided by a temporal-offset fine-tuning trick and optional action quantization, preserves or improves accuracy while cutting reaction latency up to 17.4x and task time up to 2.03x. If true, it would let large VLAs handle dynamic, physically interactive tasks that synchronous pipelines cannot.","feed_headline":"Robot AI reacts 17x faster by acting on its future state","feed_subtitle":"Conditioning vision-language-action models on the state at the next execution interval removes prediction lag without extra compute.","key_machinery":"The load-bearing identity is s_{t+Δ} = s_t + sum_{i=t}^{t+Δ-1} a_i: the robot state at the start of the execution interval equals the current state plus the actions from the previous chunk that will still be running during the inference delay. This rollforward is computed with no extra model call and fed to the policy as the conditioning state. The second piece is temporal-offset augmentation: during fine-tuning, the same observation is paired with states and actions shifted by δ steps, and attention is masked so each offset branch attends only to the shared observation and its own tokens, making the model learn to use the future state while reusing the observation encoding (3.26x faster per","core_discovery":"The central claim is that under asynchronous inference, the VLA's prediction-execution gap is primarily a robot-state gap, not just a sensory gap: while the model computes, the robot keeps executing the previous action chunk, so the state at execution start is fully determined by the current state plus those pending actions. VLASH computes that future state s_{t+Δ} = s_t + sum of the remaining actions and conditions the policy on the pair (observation at inference start, future state) instead of (observation, current state). Because large VLAs under-use state input, the paper adds a temporal-offset fine-tuning scheme that trains the model on pairs (o_t, s_{t+δ}, a_{t+δ...}) with a fixed obse","pith_inferences":["The rollforward identity is deterministic and additive; on robots with low-level tracking error, slip, contact forces, or safety-layer modifications, the computed future state will drift from the true state. A natural extension would feed a state estimate from a forward model or use measured executed actions instead of assuming exact kinematics.","Because the method forces the model to rely on state input, the same offset trick could compensate for other sources of delay, such as network latency in cloud robotics, by conditioning on a predicted state after transmission.","The paper keeps observations fixed during offset training and never predicts future visual input; extending the idea to forecast observations, or to handle occlusions, remains an open direction that the paper does not address.","The 17.4x reaction-latency figure assumes model inference is the only latency source; on systems where execution time is short relative to inference, the end-to-end speedup will be smaller and the accuracy-versus-speed trade-off will shift."],"forward_implications":["Asynchronous inference can be made accurate without architectural changes or per-step runtime overhead, so VLAs can be deployed on dynamic, fast-reaction tasks that were previously infeasible.","Reaction latency drops to roughly the model inference time, up to 17.4x faster than synchronous inference, because the robot never waits for the model.","Quantizing groups of fine-grained micro-actions into coarser macro-actions yields 1.5-2.0x task speedup with minimal accuracy loss, with the trade-off tunable by the quantization factor.","Temporal-offset fine-tuning makes the model robust across different inference delays and preserves synchronous performance, so a single deployment works on hardware with different compute budgets.","Large VLAs can achieve physically interactive behaviors like ping-pong rallies, which the paper demonstrates for the first time."],"fun_headline_variants":["Future-state conditioning lets robot AI react 11.8x faster","Robot AI reacts 11.8x faster by using its future state","Async inference with future state: 11.8x faster robot reactions","VLASH: acting on next state makes robot AI real-time","Future-state aware async inference slashes robot lag 11.8x"],"cache_read_input_tokens":19712,"weakest_assumption_plain":"The method assumes the robot state during the inference delay evolves by exact additive application of the previously issued actions, with no dynamics, slipping, contact forces, tracking error, or safety-layer modification changing that trajectory.","fun_headline_variants_meta":{"raw":{"variants":["Future-state conditioning lets robot AI react 11.8x faster","Robot AI reacts 11.8x faster by using its future state","Async inference with future state: 11.8x faster robot reactions","VLASH: acting on next state makes robot AI real-time","Future-state aware async inference slashes robot lag 11.8x"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000855,"raw_usage":{"total_tokens":3604,"prompt_tokens":853,"completion_tokens":2751,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":597,"completion_tokens_details":{"reasoning_tokens":2668}},"tokens_in":597,"tokens_out":2751,"duration_ms":21249,"temperature":1.0,"reasoning_tokens":2668,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-03T19:17:43.732664+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"A concrete experiment: run the same VLASH deployment on a robot with known low-level tracking error—for example, a compliant arm or one with friction—and measure the distance between the computed future state s_{t+Δ} and the measured state at execution start. If that distance exceeds roughly the magnitude of a single action step, the claimed accuracy improvement should reverse. Alternatively, ablate by using a future state computed from random actions or from measured executed actions; if accuracy against naive async collapses when the rollforward is inaccurate, the load-bearing premise is con","supporting_citations":[],"review_version":1}