acceptodds
Under review as a conference paper at ICLR 2027

Accelerating Robotic Policies with Cross-Cycle Batching

Abstract

Recent generative robot policies produce action chunks through a sequence of dependent network forward passes. Each pass processes only a short action sequence, which can leave the GPU underutilized. Processing several updates together could use this spare capacity to reduce latency. However, successive updates of the same chunk must remain sequential. Overlapping prediction windows allow future chunks to begin sampling before their execution cycle. We use this overlap to develop Cross-Cycle Batching, a training-free inference schedule for pretrained flow policies. It staggers full-horizon chunks across control cycles, allowing their next updates to be batched under the latest observation. This reduces sequential calls per cycle in steady state while using the same per-chunk sampling budget as serial. Because each chunk retains the policy’s standard input form, the weights, architecture, and update rule remain unchanged. Experiments show up to a 3.1× denoising speedup while preserving task success, with benefits across policy architectures and in real-robot deployment.

Primary area:
generative models
Keywords:
cross-cycle batching, robot learning, flow policies, inference acceleration, action chunking

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_zHGJOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes Cross-Cycle Batching, an inference schedule for flow-based robot policies that requires no additional training. It distributes the denoising steps of each action chunk across multiple control cycles and batches updates from chunks at different denoising stages using the latest observation. This reduces sequential model calls per cycle while keeping the same number of denoising steps per chunk. Unfinished chunks are shifted and padded at the tail to stay aligned with the updated prediction window. Experiments on RoboTwin 2.0, LIBERO, and four real-robot tasks show reduced inference latency across several policy models, with success rates close to serial sampling and denoising speedups of up to 3.1×.

Critical strengths
  1. Speeding up existing policies without retraining is a practical strength. The method reduces sequential calls per cycle by rescheduling denoising updates across action chunks, without changing the model weights or architecture or reducing the number of denoising steps per chunk. This makes it relatively straightforward to apply to existing pretrained policies.

  2. The evaluation goes beyond a single model or a small set of tasks. The authors test several policy models across all 50 RoboTwin 2.0 tasks, LIBERO, and four real-robot tasks. Across these settings, inference latency decreases while success rates remain close to full-budget serial sampling. This gives me more confidence in the method’s applicability beyond a particular model.

Critical weaknesses
  1. I am still unclear about the specific gap in prior work that this paper addresses. The motivation to reduce serial denoising latency is clear, but the contribution beyond existing rolling-sampling and pipelining methods needs to be explained more concretely. The experiments do not directly compare against StreamDiffusion, Streaming Diffusion Policy, or FASTER, nor do they sufficiently explain why these methods would be unsuitable for the current setting. The mixed-progress baseline is particularly unclear: the original model takes a single flow time for the entire action chunk, while this baseline assigns different flow times to different positions. How this is implemented with the frozen model needs clarification. Without this detail, it is difficult to tell whether its lower success rate comes from the sampling approach itself or a mismatch with the pretrained model. This limits my ability to assess the improvement over the closest prior work. RTC is already used in the real-robot deployment, but its contribution and that of the proposed method also need to be distinguished more clearly.

  2. The experiments do not directly address whether early denoising under older observations affects the policy’s ability to respond to changes in the environment. A chunk’s early updates use observations from previous cycles, leaving only a limited number of updates when its execution cycle arrives. My main concern is whether these remaining updates can sufficiently revise the earlier prediction when, for example, the target moves or the robot encounters a disturbance. The overall success rates across tasks show that the method works under the tested conditions, but they do not resolve this question. I would like to see tests involving changes during execution, along with success rates and response behavior across different cross-cycle spans. Otherwise, it remains unclear whether the speedup comes at a cost when actions need to be adjusted quickly.

Questions for authors
  1. Could you clarify the specific gap in existing work that motivates this method? The paper does not clearly explain which unresolved problem in prior approaches it aims to address.

  2. When the environment changes, could intermediate states formed under older observations hinder the policy’s ability to adjust? Are the remaining denoising steps sufficient to correct the earlier predictions?

  3. Could you explain why the experiments do not include direct comparisons with related methods such as StreamDiffusion, Streaming Diffusion Policy, FASTER, and RTC?

  4. What is the main improvement over existing rolling-sampling methods? In particular, how is the mixed-progress baseline implemented without modifying the pretrained model, given that the model takes a single flow time for the entire action chunk while this baseline assigns different flow times to different positions? Without this clarification, it is difficult to tell whether its lower success rate comes from the sampling approach itself or a mismatch with the pretrained model. Could you clarify this implementation and explain the differences from the closest prior methods more concretely?

Reviewer_RB3kOpenReview ↗
Rating
1(−1)
Confidence
3(+1)
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes Cross-Cycle Batching (CCB), a training-free runtime scheduling method for flow-matching robot policies using receding-horizon action chunking. Instead of completing all denoising steps for a single action chunk within one control cycle, the controller takes advantage of overlapping prediction windows across consecutive cycles to keep multiple future chunks in flight at staggered stages of denoising. Across simulated benchmarks (RoboTwin 2.0, LIBERO) and a physical Franka robot, the proposed batching schedule achieves inference-time speedups without changing the pretrained weights.

Critical strengths
  • The scheduling method is simple and can be applied directly at test time to run pretrained policies.
  • The method is evaluated across diverse robotic simulation benchmarks and real-world manipulation tasks.
Critical weaknesses
  • The authors motivate their cross-cycle buffering by claiming that reducing sequential forward passes requires sacrificing sampling quality unless one relies on costly retraining. However, recent one-step flow-map and one-step flow policies such as FQL (Park et al., 2025), MVP (Zhan et al., 2026), and FMQ (Ziakas et al., 2026), solve this exact bottleneck directly at the modeling level by learning a two-time flow map and a distilled one-step flow generator, A one-step policy generates actions in a single forward pass at batch size one which is faster in wall-clock latency (6.5 ms vs. 9.0 ms in Table 2), avoids multiplying activation memory across a batch, and does not rely on overlapping receding horizons.
  • Scheduling staggered diffusion states across a batch or rolling window lacks novelty.

References:

  • Park et al., "Flow Q-Learning", ICML 2025.
  • Zhan et al., "Mean Flow Policy with Instantaneous Velocity Constraint for One-Step Action Generation", ICLR 2026
  • Ziakas et al., "Aligning Flow Map Policies with Optimal Q-Guidance", NeurIPS 2026.
Questions for authors
  • Why not use a one-step policy? How does your approach compare to one-step flow and flow-map policies like FMQ (Ziakas et al., 2026), FQL (Park et al., 2025), and MVP (Zhan et al., 2026)?
  • Does this work beyond robotics? How can your method be applied to other domains like text or protein generation?
  • What is the core algorithmic novelty and theoretical justification of your scheduler?
Reviewer_LANFOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes Cross-Cycle Batching, a training-free inference schedule for pretrained flow-based robotic policies. It maintains S=H/bS=H/b overlapping full-horizon action chunks at staggered sampling stages, where HH is the prediction horizon and bb is the number of actions executed per control cycle. Each cycle performs D=K/SD=K/S batched denoising calls under the latest observation, completing the most advanced chunk while continuing the remaining chunks across subsequent cycles. A shift-and-pad operation maintains the prediction horizon, using an extrapolated tail constructed without an additional model evaluation.

The method preserves the checkpoint's scalar-time input interface and the nominal sampling budget while reducing sequential calls per cycle in steady state. Experiments report lower inference latency with comparable aggregate success across RoboTwin 2.0, LIBERO, several policy architectures, and four real-robot tasks.

Critical strengths
  1. Table 2 provides substantial evidence across all 50 RoboTwin 2.0 tasks under clean and randomized settings. For example, Cross-Cycle Batching achieves 90.4% overall success at 39.2 ms, compared with 89.8% at 54.6 ms for four-step serial sampling. Its advantage is not limited to comparison with one-step sampling: the reported three-step serial configuration achieves 89.1% at 48.0 ms. These results support the practical value of the proposed schedule.

  2. Table 4 reports comparable success and lower inference latency across three additional policies, while Table 3 demonstrates integration with real-time chunking on a physical robot. Section 5.1 also separates denoising from observation-prefill costs, helping explain why denoising acceleration translates into smaller end-to-end inference gains. Together, these results make the contribution more persuasive than an isolated demonstration of scheduling.

Critical weaknesses
  1. In Sections 4.1–4.2, a chunk is refined across multiple observations and undergoes intermediate shift-and-pad operations. For the block executed in cycle nn, only the final D=K/SD=K/S updates use the current observation ono_n; earlier updates use observations from preceding cycles. The final updates therefore begin at

τ(S−1)D.\tau_{(S-1)D}.

This differs from running all KK updates under ono_n, even though the checkpoint, the scalar-time interface, and the number of updates remain unchanged. Architectural compatibility alone does not establish that these shifted intermediate states follow the distribution encountered during standard sampling.

The aggregate success results are encouraging, but the paper does not directly isolate responsiveness to changes occurring after a chunk has entered the pipeline. The tail diagnostic in Section 4.3 holds the observation and retained positions fixed, so it does not resolve this concern. Consequently, I view preservation of performance as an empirical finding for the evaluated settings, rather than an established property of the schedule. The paper should state this limitation explicitly and clarify whether existing evaluations or failure analyses reveal sensitivity to changes in observations.

  1. The method is specified primarily in steady state, without a clear description of how the staggered stages are populated at episode initialization or after a reset. This matters for time-to-first-action and for understanding whether initialization costs are excluded from the reported timings.

Appendices A and B are repeatedly referenced but are absent from the PDF available to me. In particular, the main text does not provide the real-robot sampling budget KK, the per-cycle update count DD, the complete configurations for Table 4, or sufficient hardware and timing details to reproduce the measurements. The real-robot stage count is inferable as S=64/16=4S=64/16=4.

Furthermore, the reported end-to-end latency covers observation prefill and sampling; it does not establish a corresponding reduction in task completion time or disturbance-response latency. The real-robot evaluation contains 25 trials per task per method, so the increase from 63% to 66% overall success is limited evidence of a success improvement. These points do not invalidate the measured inference acceleration, but they constrain the strength of the deployment conclusions. If the referenced appendices are available separately, please reassess this concern using them.

Questions for authors
  1. How are the staggered sampling stages initialized at episode start and after resets? What computation occurs before the first action, and which initialization or warm-up costs are excluded from the reported timings?

  2. Do the existing evaluations or failure analyses provide evidence about cases where observations change substantially after a chunk enters the pipeline? Please distinguish what the current results establish from responsiveness claims that would require additional evaluation.

  3. Where can the referenced appendices be accessed? Please identify the (H,b,S,K,D)(H, b, S, K, D) settings for Tables 3–4, the profiling hardware, and whether the timing includes shift-and-pad operations, batch preparation, and synchronization.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.