acceptodds
Under review as a conference paper at ICLR 2027

Stage-Wise Deterministic Inference for Vision-Language-Action Models

Abstract

Batched inference improves the efficiency of vision-language-action (VLA) models in shared serving, parallel evaluation, and policy-learning rollouts. However, changes in batch context can affect tensor shapes and kernel selection, altering the order of floating-point accumulation. Action outputs can therefore differ even when request inputs and sampling noise remain fixed, leading to divergent robot trajectories and changes in task outcomes. To address this reproducibility issue, we propose stage-wise deterministic inference (Stage). Stage groups and pads requests at independently selected fixed widths for vision encoding, language encoding, and action generation, allowing each stage to balance batching efficiency and padding overhead. This organization supports autoregressive decoding, parallel regression, and iterative generation, and extends to dynamic batching with fixed stage widths and per-request noise. Experiments with four VLA models show that Stage maintains byte-identical action outputs across the tested batch contexts. Stage achieves to LLM-42 throughput at batch size and to the throughput of the standard batched inference implementation (Native) with stage widths selected for the target batch size, while maintaining comparable task success rates in closed-loop evaluation.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Vision-Language-Action Models, Deterministic Inference, Dynamic Batching

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_TdQMOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies inconsistencies in VLA inference caused by changes in batch size, request order, and batch composition. Stage assigns independent fixed execution widths to vision encoding, language encoding, and action generation, and uses request-specific noise to preserve action outputs within a fixed deployment. Experiments on four VLAs evaluate byte-level consistency and throughput, with additional closed-loop evaluation on π0.5.

Critical strengths

The main value of this work is the connection between numerical reproducibility and robot task outcomes. Section 2 shows that batch-dependent numerical differences can accumulate during closed-loop execution and change whether a task succeeds. This provides a convincing motivation for the problem. The method is clearly described. Independent stage widths account for the different computational characteristics of vision, language, and action generation, and the ablation in Section 4.2 supports this choice. The four models cover autoregressive, parallel-regression, and iterative generation. The paper explicitly discusses the assumptions behind determinism, possible output differences between configurations, and performance losses in dynamic serving.

Critical weaknesses

Performance under a varying workload with one fixed configuration remains insufficiently evaluated. The near-Native results in Section 4.3 use different configurations selected for B=1 and B=8, whereas deployment requires the configuration to remain fixed. Section 4.4 further reports 0.83–0.89× Native throughput and 1.32–1.50× Native P99 latency under burst arrivals. An analysis that selects and evaluates a single configuration for a workload distribution would make the practical efficiency claim more convincing. In particular, the compromise configuration identified in Section 4.2 deserves comparison with those selected for specific batch sizes. The LLM-42 comparison needs more information about tuning. Appendix C.2 provides three candidates evaluated on π0.5, but does not sufficiently explain how these choices transfer to the other models. Since execution width substantially affects throughput, whether the baseline was tuned per model matters when interpreting the speedups. The evaluation also has a limited scope. Four-model consistency tests use episode first frames, closed-loop and serving experiments concentrate on π0.5, and all experiments use one RTX 4090. The results establish consistency for the tested configurations, but provide less evidence about other models in closed-loop operation or sensitivity to the inference environment.

Questions for authors
  1. The paper states that execution widths should be selected for the target workload. When batch sizes vary over time, how should the workload distribution and throughput/latency requirements guide the choice of one fixed configuration? How does the compromise configuration from Section 4.2 perform under the arrival patterns in Section 4.4?
  2. Beyond the two LLM-42 configurations selected on π0.5 in Appendix C.2, were independent searches conducted for the other models? If so, please report the search ranges and results. Otherwise, can the authors assess whether per-model tuning changes the performance gap to Stage?
3 comments
AuthorsOpenReview ↗

Response to Reviewer TdQM

We thank the reviewer for the detailed review and for recognizing the link between numerical reproducibility and task outcomes, the stage-width ablation in Section 4.2, and the coverage of three generator types. We address each concern below.

Weakness 1 and Question 1: One fixed configuration under varying workloads, and the compromise configuration

A fixed configuration should be chosen from the tested batch-size distribution. We evaluated all 27 fixed configurations, including the compromise (1,1,4), under the loads of Section 4.4.

  • Selection rule. The cost model in Appendix B.2 adds up the time of the three stages for one batch size. Averaged over the tested batch-size distribution, the total is still the sum of the three stage times, so each stage takes the width with the lowest average stage time.
  • Fixed configurations under varying load. We re-ran all 27 configurations (V, P, C ∈ {1, 4, 16}) and Native in one session, and all 27 are byte-identical in every schedule. Over 90% of batches contain 16 requests, so the rule selects C = 16, and throughput indeed depends mainly on C. The configuration of Section 4.4, (16,4,16), performs best, at 0.96–1.04× the throughput and 0.91–1.10× the P99 latency of Native. The compromise (1,1,4) reaches 0.88–0.96× and 1.08–1.18×, because a batch of 16 requests needs four action calls instead of one. It is intended for workloads in which batch sizes vary widely (Section 4.2).

Weakness 2 and Question 2: Tuning LLM-42 for each model

We now tune LLM-42 separately for each model, and Stage keeps its speedups. We ran the three candidates of Appendix C.2, (K, W, G) ∈ {(1,2,1), (2,4,2), (4,8,2)}, on every model at B ∈ {1, 2, 4, 8}, and compared Stage with the best candidate for each model and batch size.

  • Per-model tuning. The new candidate (4,8,2) becomes the best for OpenVLA at B ∈ {4, 8} and for OpenVLA-OFT at B = 8, but improves on the previous best by only 0.2–2%. At B = 8, Stage reaches 2.02×, 2.66×, and 2.05× the throughput of the best LLM-42 on OpenVLA, OpenVLA-OFT, and RDT-1B, so the range over all four models stays 1.32–2.66×.
  • Upper bound. LLM-42 runs the Native batched path and then verifies and corrects its outputs, so its throughput stays below Native. Across all 16 model and batch-size settings, the best LLM-42 reaches at most 0.93× the throughput of Native, whereas Stage reaches 0.99–1.03× the throughput of Native at its target batch size.

Weakness 3: Evaluation scope (first frames, closed loop, and hardware)

We added a second closed-loop model and a second hardware platform.

  • Closed loop and later frames. On OpenVLA-OFT on LIBERO-10, changing B from 1 to 8 under Native inference changes all 500 trajectories and 2.2% of outcomes, whereas Stage keeps all 500 episodes byte-identical. These runs cover every frame after the first. First frames are also a valid test on their own, because byte identity depends on execution shapes, which are the same for all frames.
  • Hardware. We use one RTX 4090 because a VLA policy is usually served from one GPU, and π0 and OpenVLA also report their latency on an RTX 4090. For edge deployment, we also ran Stage on an NVIDIA Jetson Thor (Blackwell GPU, CUDA 13.0) with a π0.5 policy fine-tuned for an AgileX PiPER arm. On every observation of one real pick-and-place episode, Stage gives byte-identical actions at B = 1 and B = 4, whereas Native never does. We are still measuring the throughput of Stage on Thor and will add the results later in the discussion period.

Thank you to the authors for their point-by-point response to the review comments. The supplementary experiments and clarifications are reasonably thorough and have addressed most of my concerns. However, some issues remain only partially resolved, so I will maintain my score.

AuthorsOpenReview ↗

Update on Weakness: throughput on Jetson Thor

We repeated the forward-throughput experiment of Section 4.3 for π0.5 on the NVIDIA Jetson AGX Thor with the same 500 LIBERO-10 first frames, and evaluated all candidate configurations of each method on Thor.

  • Byte identity. Every Invariant Kernels, LLM-42, and Stage configuration stays byte-identical to its own B = 1 reference at every batch size.
  • Throughput. Stage (1,1,1) reaches 0.98× the throughput of Native at B = 1. At B = 8, the fastest Stage configuration on Thor is (8,1,8), which reaches 1.08× the throughput of Native, 1.50× the throughput of the best LLM-42, and 2.13× the throughput of Invariant Kernels. On the RTX 4090 the fastest is (8,4,8), so the stage widths are selected for each device.

Forward throughput of π0.5 in samples/s on 500 LIBERO-10 episode first frames on one Jetson AGX Thor. Labels give Stage (V,P,C) and LLM-42 (K,W,G).

MethodB = 1B = 2B = 4B = 8
Native5.917.167.398.04
Invariant Kernels3.644.064.084.06
LLM-42 (1,2,1)3.545.794.134.22
LLM-42 (2,4,2)1.632.162.475.78
LLM-42 (4,8,2)0.971.321.521.68
Stage (1,1,1)5.775.865.935.94
Stage (8,4,8)1.432.835.677.70
Stage (8,1,8)2.233.876.138.66
Stage (8,8,8)1.011.994.017.99
Stage (1,8,8)1.112.184.228.00
Stage (4,8,8)1.062.124.248.02

We hope these results, together with our earlier response, address your concerns. If they do, we would be grateful if you could consider raising your score. If any concern remains, please let us know, and we will address it before the discussion period ends.

Reviewer_dBQdOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper investigates numerical reproducibility in batched VLA inference, showing that changes in batch size can alter robot trajectories and task outcomes. It proposes Stage, which fixes execution widths across vision encoding, language encoding, and action generation to ensure batch-invariant outputs while maintaining competitive inference efficiency.

Critical strengths

The paper identifies a reproducibility issue in VLA inference: changes in batch context can alter numerical outputs and robot trajectories, with some tasks changing from success to failure and others from failure to success.

Critical weaknesses
  1. The motivation and experimental emphasis are not fully aligned. Although the paper reports byte-level consistency checks, the experimental analysis focuses more extensively on throughput and serving efficiency, while Stage’s closed-loop reproducibility is examined only for π0.5 on LIBERO-10.
  2. The evaluation does not include real-world robot deployments.
Questions for authors
  1. The paper extends execution-shape control through independently selected stage widths, grouped language encoding, and support for different action generators. Relative to CoRun, could the authors clarify the main technical challenges addressed by these extensions and explain which aspects require more than a straightforward adaptation of fixed-shape execution to VLA models?
  2. Do the outputs stay byte-identical across GPU types, driver versions or library versions? Reproducibility across machines is what many users would need in practice.
  3. Appendix B.1 discusses multimodal prefixes, separate image and text encoders, and different action-generation architectures. Could the authors further clarify the architectural requirements for independently executing and regrouping the three stages? In particular, how would Stage apply to VLA architectures without clearly separable vision, language, and action-generation boundaries, and would additional modifications be required?
1 comment
AuthorsOpenReview ↗

Response to Reviewer dBQd

We thank the reviewer for the careful reading and for recognizing that batch context can change numerical outputs, robot trajectories, and task outcomes in both directions. We address each point below.

Weakness 1: Alignment between motivation and experiments

The paper first shows that batch context changes VLA trajectories, and then improves the throughput of batch-invariant inference.

  • Impact of batch context on VLA trajectories. With all seeds fixed, changing only the batch size changes 10–11% of π0.5 outcomes over 500 LIBERO-10 episodes (Section 2). We added OpenVLA-OFT, where changing B from 1 to 8 under Native inference changes all 500 trajectories and 2.2% of outcomes, whereas Stage keeps all 500 episodes byte-identical.
  • Throughput improvement. Invariant Kernels and LLM-42 are also byte-identical on all four models, but at a higher throughput cost. Stage guarantees byte identity by design (Appendix B.1), and every experiment verifies it. At B = 8, Stage reaches 1.32–2.66× the throughput of LLM-42 and 1.58–13.47× the throughput of Invariant Kernels. At its target batch size, Stage reaches 0.99–1.03× the throughput of Native.

Weakness 2: Real-robot evaluation

We added a real-robot evaluation on an AgileX PiPER arm, serving a π0.5 policy fine-tuned for this arm with SGLang on an NVIDIA Jetson Thor. We recorded one complete pick-and-place episode with external and wrist cameras, and reran every observation along it (836 in total) at B = 1 and B = 4 with fixed per-request noise.

  • Native changes the predicted actions at every step, by up to 0.043 rad in joint targets, and would flip the gripper open/close decision at 46 steps.
  • Stage reproduces every prediction byte for byte, including all regrouped, reordered, and cross-process controls.

On real robot inputs, batch context alone is enough to change what the arm would do, and Stage removes this effect.

Question 1: Technical challenges beyond adapting CoRun

Fixed execution shapes alone do not make VLA inference faster. Stage solves three problems that a direct port of CoRun leaves open.

  • Batched prefix. CoRun isolates prefill per request because LLM prompts vary widely in length. VLA visual tokens have fixed length and instructions are short, so Stage pads and batches the prefix, which is 1.53× faster than a per-request prefix at B = 8 (Section 2.4).
  • Independent stage widths. The stages respond very differently to width: at B = 8, widening only the action stage adds 61.0% throughput, while widening only language changes it by −0.3% (Section 4.2). Each width is therefore set independently and selected from the expected batch-size distribution (Appendix B.2).
  • Multiple action generators. CoRun targets autoregressive decoding. VLAs also generate actions by parallel regression and by diffusion or flow sampling, which Stage supports with per-request noise and sampler state (Appendix B.1), evaluated on four models.

Question 2: Byte identity across GPU types and library versions

Like other deterministic inference methods, including the deterministic modes of vLLM and SGLang, LLM-42, and CoRun, Stage guarantees batch invariance under a fixed hardware and software configuration (Section 3.1). Byte identity across GPU types or library versions is a different property: kernels and accumulation orders change, so even Native outputs at B = 1 differ.

Question 3: Architectural requirements and VLAs without clear stage boundaries

Stage boundaries determine efficiency rather than correctness.

  • Requirements (Appendix B.1). Each call has a fixed execution shape at which every operator gives a request the same result regardless of its position in the batch and the other requests in the batch, and the output of each stage can be split by request. Accordingly, the sampler must draw noise for each request separately, and if the inputs of a stage differ in length across requests and cannot be padded to one length, that stage must process one request at a time.
  • Architectures without clear boundaries can be partitioned into fewer stages, down to a single stage, which preserves invariance at the cost of the efficiency gained from independent widths. For example, Cosmos3 Edge DROID generates future video and actions in one network, which Stage executes as a single stage.
Reviewer_aeN1OpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper investigates batch-dependent numerical nondeterminism in VLA inference, where changes in batch size or request scheduling may lead to different action outputs and robot trajectories. The authors propose Stage, a deterministic inference framework that uses independently configured fixed execution widths for vision encoding, language encoding, and action generation. Experiments across four VLA models demonstrate batch-invariant action outputs while maintaining competitive inference throughput.

Critical strengths

The paper identifies a genuine numerical reproducibility issue in VLA inference, with a clear problem formulation and reasonable mathematical definitions. The authors propose a practical engineering solution and demonstrate its effectiveness across several VLA architectures.

Critical weaknesses

1. Limited VLA-specific contributions and experimental validation.

The core problem addressed in this paper is numerical nondeterminism in batched neural network inference, which is not specific to VLA models. Although the authors demonstrate its effects on simulated robot trajectories and task outcomes, the proposed solution primarily operates at the inference-system level, without introducing techniques specific to robotic manipulation. Furthermore, the paper lacks real-world robotic experiments and qualitative visualizations of manipulation trajectories, making it difficult to assess the practical implications for embodied tasks.

2. Insufficient justification of the practical significance.

The motivation of the paper relies heavily on the observation that changing batch configurations can alter task outcomes in simulation. However, realistic robotic evaluation may involve multiple sources of variability, including environment stochasticity, policy sampling, and sensitivity to small action perturbations. The paper does not establish how significant batch-induced numerical variability is relative to these other factors. Consequently, it remains unclear whether eliminating this particular source of variability provides meaningful practical benefits.

3. Exact reproducibility does not necessarily imply reliable policy evaluation.

An important distinction should be made between exact reproducibility, where identical inputs produce byte-identical outputs, and statistical reliability, where policy performance estimates and relative rankings remain statistically consistent across evaluation conditions.

The proposed method primarily addresses the former, whereas VLA benchmarking is often more concerned with the latter. Exact reproducibility can facilitate debugging and controlled comparisons, but it is neither sufficient nor always necessary for statistically reliable evaluation. In particular, policy evaluation generally aims to assess performance across diverse conditions rather than merely reproduce a single deterministic execution. The paper does not demonstrate whether its proposed determinism improves the reliability of policy comparisons or benchmark conclusions.

4. Limited technical novelty.

The proposed method mainly combines existing techniques, including fixed-shape execution, padding, and request regrouping. These techniques are not fundamentally new, and similar principles have already been explored in deterministic LLM inference. Although the authors adapt them to different VLA architectures, the technical contribution beyond this adaptation appears limited. The paper would benefit from a clearer demonstration of why independent stage-wise execution widths are necessary and what substantial advantages they provide over simpler fixed-width batching strategies.

Questions for authors
  1. Can the authors provide empirical evidence that batch-invariant inference improves practical VLA benchmarking, policy comparison, RL training, or robotic deployment, beyond merely achieving byte-identical outputs?

  2. How significant is batch-induced variability compared with other sources of variation, such as environment stochasticity, sampling noise, and initial-state differences? Does eliminating batch-induced variability lead to more statistically reliable policy evaluations?

  3. Since a fixed Stage configuration may experience substantial throughput degradation at non-target batch sizes, how should the configuration be selected in practical deployments? What are the throughput and latency trade-offs under dynamic workloads with varying batch sizes?

3 comments
AuthorsOpenReview ↗

Response to Reviewer aeN1

We thank the reviewer for the detailed review and for recognizing the reproducibility issue in VLA inference, the clear problem formulation, and the practical solution across several VLA architectures. We address each concern below.

Weakness 1: VLA-specific contribution and real-robot experiments

Batch-dependent numerical differences are not specific to VLAs, but their effect on robot actions cannot be inferred from LLM results. The paper therefore first shows that the problem exists in VLAs and is caused by batch context (Section 2).

  • Continuous actions. In an LLM, a numerical difference matters only if it changes the selected token. OpenVLA, which outputs discrete action tokens, behaves the same way. Under Native inference at B = 8, its logits differ from B = 1 on all 500 first frames, but only 12% of them get a different action token. Continuous action heads pass every difference on to the action. For OpenVLA-OFT and RDT-1B, every request gets a different action at B ∈ {2, 4, 8}. In closed loop, these differences grow. With all seeds fixed, changing only the batch size changes 10–11% of π0.5 outcomes.
  • Real robot. On an AgileX PiPER arm with π0.5 served on an NVIDIA Jetson Thor, we reran every observation of one complete real pick-and-place episode at B = 1 and B = 4. Native changes every prediction, by up to 0.043 rad in joint targets, whereas Stage reproduces all of them byte for byte.

Stage also builds on VLA structure. Visual tokens have fixed length and instructions are short, so the prefix can be padded and batched instead of run per request.

Weakness 2: Practical significance of batch-induced variability

Seeds control environment randomness, sampling noise, and initial states, but not batch context. With all seeds fixed, batch context alone changes 10–11% of π0.5 outcomes.

  • Comparison with other sources of variation. Two B = 1 runs of π0.5 with the same seeds agree on all 500 LIBERO-10 episodes, and with 500 sampled initial states, the success rate has a standard error of about 1.6%. Changing only the batch size moves success between 84.6% and 86.6% (Table 4). Small action changes can change task outcomes. This is how batch context affects results, not a separate source.
  • Sampling noise. OpenVLA-OFT has no sampling noise, yet changing B from 1 to 8 under Native inference changes all 500 trajectories and 2.2% of outcomes. Sampling noise is intended and set by seeds, whereas batch context is neither. LLM engines draw the same line. vLLM and SGLang offer batch-invariant modes that are used together with per-request seeds, even though a new seed changes outputs far more than batch context does. Stage's per-request noise plays the role of the seed.

Without batch effects, outcomes depend only on the model, initial states, and seeds. This allows paired comparison and failure replay in evaluation, rollouts that match the trainer's computation in policy learning, and actions that do not depend on the load of other robots in shared serving.

Weakness 3: Exact reproducibility and reliable policy evaluation

Batch context leaves aggregate success rates nearly unchanged, because success-to-failure and failure-to-success flips largely cancel (Table 1). It still affects statistical reliability in two ways.

  • Results under fixed seeds. With the same checkpoint, initial states, and noise, success varies from 84.6% to 86.6% across batch sizes (Table 4), similar to the standard error of about 1.6% from sampling 500 initial states. Comparing policies on the same initial states removes this sampling error, but not the variation from batch size.
  • Paired policy comparison. We compared BF16 and FP8 π0.5 on the same 500 LIBERO-10 episodes under Native inference at B ∈ {1, 2, 4, 8, 16}. The difference is not significant at any batch size, and its sign flips. FP8 is 0.6% higher at B = 1 and 1.6% lower at B = 8. The two models disagree on 11–15% of episodes, about as often as one model disagrees with itself across batch sizes, so per-episode differences cannot be attributed to the precision change. Under Stage (8,4,8), both models are byte-identical to their B = 1 outputs at every B ≤ 16, so the comparison no longer depends on batch size.
AuthorsOpenReview ↗

Response to Reviewer aeN1

Weakness 4: Technical novelty and the need for independent stage widths

Independent widths are needed because the three stages respond very differently to width. With one width for all stages, the best choice keeps as little as 58.7% of the best throughput at some batch size, whereas the independent widths (1,1,4) keep at least 86.4% at every batch size.

  • Independent stage widths. At B = 8, widening only vision, language, or action changes throughput by +2.7%, −0.3%, and +61.0% (Section 4.2). The cost model in Appendix B.2 lets each width be chosen separately.
  • Batched prefix. CoRun runs prefill one request at a time because LLM prompts vary widely in length. VLA visual tokens have fixed length and instructions are short, so Stage pads and batches the prefix, which is 1.53× faster than a per-request prefix at B = 8 (Section 2.4).
  • Multiple action generators. CoRun targets autoregressive decoding. VLAs also generate actions by parallel regression and by diffusion or flow sampling, which Stage supports with per-request noise and sampler state (Appendix B.1), evaluated on four models.

Question 1: Practical benefits beyond byte-identical outputs

Under Native inference, batch context changes benchmark results, policy comparisons, and real robot actions, and it makes RL rollouts depend on concurrent requests. Stage removes these effects.

  • Benchmarking and policy comparison. With fixed seeds, one checkpoint's success rate varies from 84.6% to 86.6% across batch sizes, and the sign of the BF16 vs. FP8 difference flips. Under Stage, neither depends on batch size.
  • Deployment. On real observations from an AgileX PiPER arm, batch context alone changes the joint targets of Native by up to 0.043 rad and would flip the gripper open/close decision at 46 steps of one episode. Stage keeps every prediction byte-identical, so a recorded observation rerun alone gives the action computed under batching.

Question 2: Batch-induced variability compared with other sources of variation, and evaluation reliability

With all seeds fixed, batch context changes 10–11% of π0.5 outcomes, a variation comparable to initial-state sampling, and removing it makes policy comparisons independent of batch size.

  • Comparison with other sources of variation. Two B = 1 runs of π0.5 with the same seeds agree on all 500 episodes, so the environment adds no variation here. Changing only the batch size moves success between 84.6% and 86.6%, close to the 1.6% standard error from sampling 500 initial states. Sampling noise is intended and set by seeds, and batch context still changes 2.2% of outcomes on OpenVLA-OFT, which has no sampling noise.
  • Reliability of policy evaluation. Under Native inference, the success difference between BF16 and FP8 π0.5 changes sign with batch size, from 0.6% higher for FP8 at B = 1 to 1.6% lower at B = 8. Under Stage, both models are byte-identical to their B = 1 outputs at every B ≤ 16, so the comparison gives the same result at any batch size.

Question 3: Configuration choice and throughput/latency trade-offs under dynamic workloads

A fixed configuration should be chosen from the batch-size distribution of the deployment. We evaluated all 27 fixed configurations under the varying loads of Section 4.4.

  • Selection rule. A width larger than most batches wastes work on padding, and a smaller width needs more calls per batch. The cost model in Appendix B.2 adds up the time of the three stages, so after weighting each batch size by how often it occurs, each stage takes the width with the lowest average time.
  • Throughput and latency under varying load. We re-ran all 27 configurations (V, P, C ∈ {1, 4, 16}) and Native in one session, and all 27 are byte-identical in every schedule. Over 90% of batches contain 16 requests, so the rule selects C = 16. The configuration (16,4,16) performs best, at 0.96–1.04× the throughput and 0.91–1.10× the P99 latency of Native. The compromise (1,1,4) reaches 0.88–0.96× and 1.08–1.18×, because a batch of 16 requests needs four action calls instead of one. It is intended for workloads in which batch sizes vary widely (Section 4.2).

Thank you for the detailed rebuttal. While the additional experiments strengthen the evidence for batch-dependent numerical inconsistencies, my main concern remains unresolved.

The proposed method ensures inference consistency but does not demonstrate improvements in actual robotic manipulation performance. The real-robot experiment only replays recorded observations, without showing improvements in closed-loop task success, action smoothness, or control robustness.

Overall, the work addresses a numerical reproducibility issue, but its practical significance for robotic manipulation remains unclear, particularly given the limited technical novelty.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.