acceptodds
Under review as a conference paper at ICLR 2027

Act on the Low Frequencies: Prefix Execution of Vision-Language-Action Chunks

Abstract

Vision-language-action policies predict chunks of robot controls and ship every chunk in full, and how much of a chunk a robot needs to finish its task has remained unmeasured in closed loop. We introduce frequency-prefix execution (FPE), a training-free scheme that transforms each finished chunk into a temporal cosine basis, transmits a fixed number of its lowest-frequency rows, and lets the robot reconstruct and execute the whole chunk under the unchanged policy, horizon and replanning schedule. The basis makes the discarded detail exactly accountable: the reconstruction error of a prefix equals the energy of the omitted rows, and under a contraction condition the accumulated state deviation stays within the largest single-chunk residual. On the official LIBERO protocol with OpenVLA-OFT, two cosine rows keep 98.8% success on Spatial against 98.6% for quantized full codes at 54% of the native payload, and four rows keep 92.6% against 92.2% on LIBERO-10 at 72% of the payload, both passing a registered non-inferiority test. On Goal the tolerance to truncation follows the task, which motivates PairGap, a shortest-path certificate that bounds, at a single restored state, the regret of executing a prefix against the best option in a fixed bank of prefixes and full codes. Together they show that a robot can act on a fraction of each predicted chunk, and they identify the tasks and states that call for the full code.

Primary area:
applications to robotics, autonomy, planning
Keywords:
vision-language-action models, action chunking, action tokenization, discrete cosine transform, communication-efficient control, closed-loop evaluation, robot manipulation, certification

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_A4ShOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
3(+2)
Read review
Paper summary

In the robot execution of generated action chunks, this paper proposes a method called frequency-prefix execution, which transmits only low-frequency parts of chunks. Experimentally, this method archived a comparable success rate to sending full action chunks, while reducing payload, in LIBERO benchmark tasks.

update: The authors also propose PAIRGAP, an algorithm to determine which transmittion of actions can be reduced while maintaining success rate.

Critical strengths

A sufficient quantity of experiments has been conducted.

Critical weaknesses

The motivation is unclear:

  • If reducing communication cost is the objective, various prior works aimed at compressing the data to be transmitted, not limited to robot execution, should be taken into consideration. Experimental results should be compared to existing approaches. The fact that the success rate did not decrease may mean only that tasks are achievable even if actions are roughly approximated.
  • If the effect itself of limiting frequency of action chunks is the research topic, the authors should explain why this is important.

update: After update of the paper, practical effectivitiy of FPE, the proposed method, is experimentally validated. Thus, this issue is resolved. However, I'm hesitant to raise the rating significantly. While FPE is practical, it is questionable that it has sufficient impact when considering its fit to the field of the conference and its novelty. I know that subject areas of ICLR are not restricted to Representation Learning, but this paper is peripheral to VLA research and its results are not so much surprising. As a robotics research, it would be better to conduct a real-world experiment.

Also, there exist several points I did not understand. See questions for authors.

update: After discussion, I managed to understand the role of PAIRGAP. Howeover, the same question as the second weakness in the review by Reviewer 25AU raises. If the intention is to deploy the planned reduction in transmission to the real robots after computing the certificates on the simulator, it is necessary to verify that this actually works through experiments using the real robots.

Questions for authors
  • I did not quite understand the connection of Section 4 to the other parts of this paper.
    • Also, I did not understand the Section 5.5 and how to read Figure 6.
  • What is the single-decision test?
  • What does mean "Time prefix" row in Table 1?
6 comments
AuthorsOpenReview ↗

Response to Reviewer A4Sh (1/2)

Thanks for your review. Here are the replies. Line and figure numbers refer to the original submission, and Tables 22 to 28 refer to the revised PDF.

W1: If reducing communication cost is the objective, various prior works aimed at compressing the data to be transmitted, not limited to robot execution, should be taken into consideration. Experimental results should be compared to existing approaches.

Answer: The original submission already compares FPE with the standard compression of VLA action chunks. Section 5.4.1 (lines 428–430) reads "Priced at 11 bits per token of the released FAST+ vocabulary, a two-row prefix saves 22% of the full LaRA-VLA stream". FAST+ is the action tokenizer of current VLA policies, and it applies the two standard steps of data compression, a discrete cosine transform followed by entropy coding. The review names no specific prior work, so to cover general data compression the revision also runs five general-purpose lossless coders (deflate, LZMA2, bzip2, zstd, Brotli) on the same OpenVLA-OFT calls (Table 28).

Bits per callFull codeTwo rows (FPE)Saved by FPE
Uncoded44811275%
Best general-purpose coder1319924%
FAST+1047429%

Lossy transform coding, as in image and audio codecs, also drops high-frequency coefficients, and it chooses how many by reconstruction error. FPE chooses that number by closed-loop task success, which reconstruction error does not predict (see W3). The table shows why FPE and lossless compression are two different tools. A lossless coder must deliver every number in the chunk, so it can only shorten how those numbers are written. FPE selects which numbers the robot needs to receive, and the coder then compresses what remains. For this reason, the saving holds across every coder in the table, and two uncoded rows are already smaller than the full code under the best general-purpose coder. Prior work on rate-limited control [1] and task-oriented communication [2] derives a code from a model of the plant, channel, or task, and concurrent work on VLA policies compresses the camera observations sent to the cloud [3]. None of these works measures how much of a finished action chunk the robot needs to complete its task, which is the quantity our paper reports.

W2: The fact that the success rate did not decrease may mean only that tasks are achievable even if actions are roughly approximated.

Answer: No. This conjecture makes a prediction that we can test. If the tasks tolerated rough actions, then any rough approximation of the chunk at the same size would keep closed-loop task success. The paper's experiments, which the review finds sufficient in quantity, test this prediction directly and show the opposite (Table 22). The registered non-inferiority test, fixed before the runs, asks whether a loss of two points can be ruled out.

CodeBits per callSpatial success (%)Goal success (%)Registered non-inferiority test
Quantized full code44899.097.0reference
Two cosine rows (FPE)11298.897.2passes on both suites
Two waypoints with interpolation11297.295.8fails on both suites
2-bit binning of every step11288.040.0fails on both suites

All three codes spend the same 112 bits, and only the cosine rows pass the registered test on both suites. Binning ran on the first 10 initial states of each task. Rounding the cosine coefficients coarsely also fails all 20 paired Goal episodes, and keeping a single row fails the test on three suites. The tasks are therefore sensitive to how an action chunk is approximated. The tasks need the low-frequency rows delivered precisely and tolerate dropping the high-frequency rows, which is the finding stated in our title.

Reference

[1] S. Tatikonda and S. Mitter. Control Under Communication Constraints. IEEE Transactions on Automatic Control 2004.

[2] D. Gündüz et al. Beyond Transmitting Bits: Context, Semantics, and Task-Oriented Communications. IEEE Journal on Selected Areas in Communications 2023.

[3] B. Liu et al. ComVLA: Communication-Aware Split Inference for VLA Models in 6G-Connected Robotics. IEEE GLOBECOM 2026.

AuthorsOpenReview ↗

Response to Reviewer A4Sh (2/2)

W3: If the effect itself of limiting frequency of action chunks is the research topic, the authors should explain why this is important.

Answer: The original submission states the question in the first sentence of its abstract (lines 011–013), "how much of a chunk a robot needs to finish its task has remained unmeasured in closed loop". Its introduction (lines 039–044) gives the reason and concludes "Closeness of reconstruction and success on the task are therefore separate questions, and the second one has not been measured under a fixed execution protocol." The question matters for three reasons.

  1. Reconstruction error does not predict task success. Existing VLA action codes are judged by how closely they reproduce a chunk offline. A robot acts in closed loop, where each small deviation changes the next camera image and the next prediction, so success has to be measured on whole episodes. Across the 20 OpenVLA-OFT Spatial and Goal tasks, the energy that two rows drop shows no rank correlation with the change in task success (Spearman ρ = 0.05).

  2. The result is directly usable. Without any retraining, two cosine rows keep task success on Spatial, Object and Goal, and four rows keep it on LIBERO-10, on released OpenVLA-OFT and π0.5 checkpoints.

  3. Frequency truncation saves bits without extra policy calls. The familiar way to send less per call is to execute fewer steps of each chunk, and it forces the robot to query the policy more often. On LIBERO-10, executing four of eight steps per call requires 2.15 times the policy calls and loses 5.6 points of success, and four cosine rows keep task success at the native call count.

Q1 & Q2: I did not quite understand the connection of Section 4 to the other parts of this paper. Also, I did not understand the Section 5.5 and how to read Figure 6.

Answer: Section 3 uses one row count for a whole episode, Section 4 asks the same question at one state, and Section 5.5 with Figure 6 measures what an answer at one state costs. The link is the result of Section 5.2, where two rows keep task success on Spatial and miss the test on LIBERO-10. One row count for a whole episode therefore sends too many bits at easy states or too few at hard ones, and Section 4 sets the row count state by state. Section 4 opens (lines 238–240) with "The every-chunk scheme of Section 3 holds one row count for a whole episode, and the cost of a prefix depends on the state the robot occupies. A controller that faces one state at a time benefits from a bound on the regret of executing a prefix there." Figure 6's caption (lines 466–467) reads "(A) One chunk, every depth, as success change against the full code. (B) What a certificate costs at tolerance 0.10." Panel A plots "Success change (pp)" against "Payload (bits)", so a point on the zero line is a prefix that matches the full code. Panel B plots "Certified states (of 8)" against "Rollouts per decision" for five certification rules, so a rule that sits higher certifies more states with the same number of rollouts.

Q3: What is the single-decision test?

Answer: It isolates the closed-loop effect of a single truncated chunk. Section 5.1 (lines 290–291) defines "the single-decision tests, which restore a state, truncate its first chunk, and resume the standard policy".

Q4: What does mean "Time prefix" row in Table 1?

Answer: It is the time-truncation control. Section 3.1 (line 146) defines it in one sentence, "The time-truncation control executes the leading d steps before replanning." Table 1 sets d = 4 and Figure 1B draws this schedule, in which the robot executes 4 of the 8 predicted steps and then calls the policy again. The revised Table 1 labels the row "Time truncation", the name the text and Figure 1B use.

We're happy to address any further valid and substantive questions you may have.

Thank you for your detailed response!

Table 22 is what I wanted to see. If I may make one more suggestion, I think these results should be extended to two-dimensional graphs for various bit lengths as Figure 4(a). The important thing is a tradeoff of communication cost and success rate, and I want to see the curves of success rate with respect to communication cost. In addition to various k values for FRE, the results for various number of waypoints and various quantization step size will provide more informative evidence of effectiveness.

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

The authors propose frequency-prefix execution (FPE). Each VLA action chunk is DCT-transformed along time, only the k lowest-frequency rows are transmitted, and the receiver reconstructs and executes the full chunk. A second contribution, PAIRGAP, decides per state whether a prefix can be executed safely. It bounds the prefix's regret against a bank of alternatives using shortest paths over evidence from rollouts in a restored simulator. The authors establish theoretical justification for FPE, and empirically show that FPE compression preserves task success rate.

Critical strengths
  • Showing that VLA action chunks can be compressed substantially without sacrificing task success is an interesting finding.
  • A clean, paired closed-loop evaluation on the official protocol, with a quantized-full control that separates truncation from quantization.
  • A pre-specified non-inferiority test, with failures reported honestly (Goal, and LIBERO-10 with two rows).
  • A useful empirical observation: OpenVLA-OFT chunks are effectively low-pass, with about 99.7% of the energy in two rows.
Critical weaknesses
  • The motivation is not established. The savings are a few hundred bits per 166-byte message. Latency is not measured in any experiment. So there is no setting where bandwidth is limited.
  • PAIRGAP needs a restorable simulator, so the certification cannot be deployed on a real robot.
  • Improvements are in thousandths of percentage points (table 1). Since no measure of latency is given, the significance of this change cannot be determined.
  • The theory is messy and hard to follow
Questions for authors
  1. Is there a concrete deployment where per-call bandwidth is the binding constraint?
  2. How does FPE compare with simple baselines at equal bits, such as raw quantized actions with a minimal header, or subsampling followed by interpolation?
  3. Is there any setting where PAIRGAP's paired or depth edges certify a state that cannot be certified by the single-option bound?
4 comments
AuthorsOpenReview ↗

Response to Reviewer 25AU (1/3)

Thank you for a thorough and insightful review. You describe the result as "an interesting finding" supported by a "clean, paired closed-loop evaluation", and your questions ask where the saving matters and how the prefix compares with simpler codes. We ran each experiment you asked for under the paper's protocol. Here are our replies.

W1, Q1 and W3 (latency): The saving is a few hundred bits per call and latency is not measured, so is there a deployment where per-call bandwidth binds?

Answer: Yes. The saving binds whenever the policy runs off the robot and the link is slower than about 21 kbit/s. To see where this number comes from, follow one policy call. The server computes a chunk, sends it across the link, and the robot executes it. Across all 119,038 calls of the new runs, the first step takes a median of 62 ms, and our encoder and decoder add 0.31 ms. The second step takes the message bits divided by the link rate, and at 21 kbit/s the 1,328-bit full code needs the same 62 ms. On any slower link, the robot waits longer for the message than for the policy (Table 29 in the revision). These deployments are common in practice. Frontier VLA policies run on remote servers [1, 2], and field robots work over links of a few kbit/s, such as underwater acoustic modems at 5,400 bit/s or less [3].

Link rateFull code (1,328 bits)Two rows (720 bits)Link time saved per call
2.4 kbit/s553 ms300 ms253 ms
9.6 kbit/s138 ms75 ms63 ms
64 kbit/s20.8 ms11.3 ms9.5 ms

A second case holds at every link rate. When a fleet shares one channel, the channel capacity is split across the bits each robot receives, so two rows let the same channel serve 1.8 times as many robots. The code also degrades gracefully, because each shorter message is an exact prefix of every longer one. A sender on a weakening link can stop at a row boundary, and our measurements show which boundary keeps task success. The measurement itself holds on any link. How much of a chunk a robot needs is a property of the policy and the task, and the link rate sets how much time that saving buys. Concurrent work compresses the camera observations on the uplink [2], and FPE shortens the action message on the downlink, so the two compose.

W3 (Table 1): The differences in Table 1 are tiny, so their significance cannot be determined.

Answer: Table 1 tests whether a prefix keeps task success, and small differences are what retention looks like. Because the paper claims that a prefix keeps task success at a smaller payload, the right statistical question is whether a loss of two points can be ruled out, and the registered paired non-inferiority test answers that directly. The differences are fractions of a point because one of the 500 episodes per suite equals 0.2 points. A test that always passed would prove little, so the table below also shows the same paired design catching a real loss on LIBERO-10. What changes in Table 1 is the payload, dropping from 1,328 to 720 bits at the same number of policy calls, and the link table above turns that bit saving into time.

SuiteArm against its referenceChange in successPaired test
Spatial (Table 1)Two rows+0.2 pointssuccess kept (P = 0.0117)
Spatial (Table 1)Four rows+0.2 pointssuccess kept (P = 0.0020)
LIBERO-10Four rows+0.4 pointssuccess kept (P = 0.0020)
LIBERO-10Two rows−2.2 pointstest failed
LIBERO-10Four of eight steps per call−5.6 points at 2.15 times the callsloss detected (P = 1.8 × 10⁻⁴)

Reference

[1] Gemini Robotics Team. Gemini Robotics: Bringing AI into the Physical World. arXiv 2025.

[2] B. Liu et al. ComVLA: Communication-Aware Split Inference for VLA Models in 6G-Connected Robotics. IEEE GLOBECOM 2026.

[3] J. McConnell et al. DRACo-SLAM: Distributed Robust Acoustic Communication-efficient SLAM for Imaging Sonar Equipped Underwater Robot Teams. IROS 2022.

AuthorsOpenReview ↗

Response to Reviewer 25AU (2/3)

Q2: How does FPE compare at equal bits with raw quantized actions under a minimal header and with subsampling followed by interpolation?

Answer: On Spatial and Goal the cosine prefix is the only code tested that keeps closed-loop task success at equal bits, and on LIBERO-10 it is the smallest coded message tested that keeps it (Tables 22 and 23 in the revision). We ran both baselines as you specified, using the same header across codes so that they differ only in their coefficient bits, as under any minimal header, and pairing every arm against the quantized full code on the same initial states.

CodeCoefficient bits per callSpatial success (%)Goal success (%)Registered test
Quantized full code44899.097.0reference
Two cosine rows (FPE)11298.897.2passes on both suites
Two waypoints, linear interpolation11297.295.8fails on both suites
Raw actions, 2-bit binning11288.040.0fails on both suites

The three codes spend the same bits, and what separates them is where each one puts its error. Binning leaves four levels per joint at every step. Waypoints replace the motion between samples with straight segments. The cosine prefix drops only the high-frequency rows that, as your review notes, hold about 0.3% of the chunk energy. Binning ran on the first 10 initial states per task under a pre-specified rule that extends an arm to all 50 states once it comes within 5 points of two rows.

We repeated the comparison on LIBERO-10 at its operating point of four rows.

LIBERO-10 codeCoefficient bits per callSuccess (%)Registered test
Quantized full code44891.8reference
Four cosine rows (FPE)22492.2passes
Four waypoints22490.2fails
4-bit binning22494.4passes
3-bit binning16890.4fails
2-bit binning11233.0fails

4-bit binning also keeps task success. Its bin indices compress poorly and take 192 bits per call under the best lossless coder, against 106 for four cosine rows. Four cosine rows form the smallest coded message tested that keeps LIBERO-10 success.

AuthorsOpenReview ↗

Response to Reviewer 25AU (3/3)

W2: PairGap needs a restorable simulator, so the certificate cannot be deployed on a real robot.

Answer: The two contributions run in different places. FPE needs no simulator, and its encoder and decoder run on any physical robot in 0.31 ms per call. PairGap asks a counterfactual question, namely what would have happened from this exact state under a different action, and a physical robot cannot return to the same state twice. Every guarantee of this kind therefore needs a restorable simulator. PairGap runs offline before deployment, in the role that simulated evaluation already plays for real manipulation policies [1]. For each evaluated state, its output marks whether two rows suffice or the full chunk is needed. Section 4 of the revision states this offline role in its first paragraph.

Q3: Do the paired or depth edges ever certify a state that the single-option bound cannot?

Answer: Yes. Every FPE deployment faces one comparison, between the received prefix and the chunk's unreceived full code. In that comparison, the depth edge certifies states that the single-option bound leaves open (Table 25 in the revision).

Panel, one candidateTolerance εCertified by the single-option boundCertified by the graph with its depth edge
LaRA-VLA0.050 of 8 states8 of 8 states
Flex-π, LIBERO-100.100 of 40 states40 of 40 states
OpenVLA-OFT with Gaussian noise, Goal0.100 of 10 states10 of 10 states

The two bounds answer different questions. The single-option bound limits how often the prefix fails, so a state where the task itself often fails can never be certified. The depth edge limits the gap between the prefix and its full code. This gap stays small because the two share seeds and fail on largely the same ones. At OpenVLA-OFT task 3, the prefix fails on 57 of 64 seeds and the depth edge lowers the bound from 0.955 to 0.076, because those failures stem from the state and receiving the rest of the chunk would not prevent them. We report this one-candidate bank as a secondary analysis fixed after inspecting the first OpenVLA-OFT state. On held-out seeds, one certified state measures 0.109 at ε = 0.10 and none exceeds 0.15. Against four sampled rival chunks, which disagree with the prefix on up to 34 of 64 seeds, no rule certifies a state at ε ≤ 0.20, and the graph lowers the bound at 8 of 10 states (Tables 26 and 27 in the revision).

W4: The theory is hard to follow.

Answer: Each theoretical result supports one experiment, and the revision opens Section 3.3 with this roadmap.

ResultWhat it statesWhere it is used
Propositions 2 and 3The exact bits per call and calls per episode of every armTable 1, Figure 2
Lemma 1A prefix's reconstruction error equals the energy of the omitted rowsSection 5.4
Proposition 1Under a contraction condition, the closed-loop deviation stays within the largest one-chunk residualSection 5.2
Theorem 1, Propositions 4 and 5The certificate is an exact shortest path, valid at level δ, with a stated condition for which evidence can decideSection 5.5

Thank you again for questions that each identified the exact experiment a careful reader would ask for. Their answers appear in the revision as Tables 22, 25 and 29 and the roadmap opening Section 3.3.

We're happy to address any further questions you may have.

Reference

[1] X. Li et al. Evaluating Real-World Robot Manipulation Policies in Simulation. CoRL 2024.

AuthorsOpenReview ↗

Follow-up before the discussion closes

As the discussion period draws to a close, we'd like to thank you again for your thorough review and the time you've given our paper.

We'd be very grateful if you could share your views on our rebuttal before the discussion ends. Your feedback would help us understand whether our responses have addressed your concerns, and it would also give the AC a more complete picture of the discussion for the meta-review. If our responses have resolved your concerns, we'd also appreciate it if you would consider raising your rating. If any concern remains, we'd be glad to address it right away.

Thank you very much for your time and your valuable comments.

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

This paper proposes frequency-prefix execution (I will refer to it as FPE throughout the review). This is a training-free scheme in which a finished VLA action chunk is transformed along time into a cosine basis, only the first k low-frequency rows are transmitted, and the receiver zero-fills the remaining coefficients, reconstructs the full L-step chunk, and executes all of it under the unchanged policy, horizon, and replanning schedule. The main contributions are the FPE scheme with explicit bit accounting for its wire format, a lemma showing the reconstruction error of a prefix equals the energy of the omitted rows, and PAIRGAP, a shortest-path certificate over a difference-constraint graph that bounds the regret of executing a prefix at one restored state against a bank of alternative prefixes and full codes. The authors validate FPE on the official LIBERO protocol with OpenVLA-OFT. Extensive appendices compare PAIRGAP's rollout cost against best-arm-identification rules on logged populations.

Critical strengths

The core closed-loop experiment is simple, well-specified, and properly run and reported. The operating-point finding (that two rows suffice on short-horizon suites and four are needed on LIBERO-10), is a usable result.

Critical weaknesses
  1. The 54% payload reduction in the abstract is measured against the authors' own codec, whose fixed header and band overhead inflate the full-code size. Against FAST+ entropy coding, which the paper also reports and which is what the cited tokenization work actually uses, the same two-row prefix saves only ~22%, I think because entropy coding already makes the high-frequency rows cheap. That is roughly 600 bits per policy call, and the paper never says where that would matter. Since the motivation is bandwidth, I am not convinced the headline figure reflects a meaningful saving.

  2. The only panel where PAIRGAP is evaluated the paired and depth edges never bind and every guarantee comes from the absolute edge alone. The graph therefore reduces to a Clopper-Pearson bound on the executed option, which needs no graph. The authors attribute this to the panel being saturated, which is plausible, but then I feel the third contribution is untested in any regime where it could do something.

Questions for authors
  1. Why is the authors' fixed-overhead codec, rather than FAST+, the primary baseline for the payload claim? It would be good if the authors could report the 22% figure as the headline.
  2. What deployment setting motivates saving on the order of 600 bits per call?
  3. Do the Spatial and LIBERO-10 non-inferiority results hold under a second OpenVLA-OFT seed?
5 comments
AuthorsOpenReview ↗

Response to Reviewer JTSk (1/3)

Thank you for a thorough review of our main text and appendices. You judge the core experiment "simple, well-specified, and properly run and reported", and your questions ask which saving belongs in the headline and whether the certificate is tested where it can matter. Answering them under the same protocol sharpened our headline and tested our certificate in the regime you identified. Our replies follow.

W1 (headline) & Q1: The 54% is measured against the authors' own fixed-overhead codec, and the saving under FAST+ should be the headline.

Answer: We adopt this suggestion and now lead the revised abstract with the 29% saving under FAST+. The table below gives each accounting method on the every-chunk OpenVLA-OFT streams (Table 28 in the revision).

Accounting, bits per callFull codeTwo rowsSaved by two rows
FAST+ at 11 bits per token1047429%
Best general-purpose lossless coder1319924%
Fixed-length wire codec1,32872046%
Coefficient payload alone44811275%

Two details clarify this table, and both favor FPE. The 22% figure in the submission came from the single-decision LaRA-VLA bank, and the every-chunk OpenVLA-OFT streams give 29%. Both the prefix and the full code pay the fixed header, so the header lowers the fixed-length saving below the saving on the coefficients alone, as the last two rows show. Entropy coding lowers it further, which is why the FAST+ figure now leads. The 54% in the abstract is the two-row cost as a share of the full code, which equals a 46% saving.

Your reasoning is exact and explains why the two stages work together. Lossless entropy coding must send every row, and FPE drops rows that closed-loop execution does not use, so the 29% removed after FAST+ is motion that the task does not need. We keep the fixed-length code as our accounting baseline because its packet size does not depend on the chunk's content (Proposition 2), which fits links with fixed time slots. Closed-loop performance is identical across coders because the robot reconstructs and executes the chunk from the same rows.

W1 (deployment) & Q2: Where does a saving of about 600 bits per call matter?

Answer: It matters when the policy runs on a remote server over a narrow or shared link, a standard setup for frontier VLA policies [1, 2]. We timed all 119,038 calls in the new runs. The policy takes a median of 62 ms per call, and our encoder and decoder take 0.31 ms. The link adds the message bits divided by its rate, so below about 21 kbit/s the robot waits longer for the full code than for the policy (Table 29 in the revision). The table uses the fixed-length code because its size is the same on every call, which is what a slotted link schedules. Under FAST+ both columns shrink and the prefix takes 29% less airtime.

Link rateFull code (1,328 bits)Two rows (720 bits)Link time saved per call
2.4 kbit/s553 ms300 ms253 ms
9.6 kbit/s138 ms75 ms63 ms
64 kbit/s20.8 ms11.3 ms9.5 ms

On a shared channel across a fleet, the saving holds at every rate because two rows let the same channel serve 1.8 times as many robots. The saving itself comes from the policy and the task, since it is motion that no lossless coder can remove, and the link rate sets its value in time. Concurrent work compresses the camera observations on the uplink [2], and FPE shortens the action message on the downlink, so the two compose.

Reference

[1] Gemini Robotics Team. Gemini Robotics: Bringing AI into the Physical World. arXiv 2025.

[2] B. Liu et al. ComVLA: Communication-Aware Split Inference for VLA Models in 6G-Connected Robotics. IEEE GLOBECOM 2026.

AuthorsOpenReview ↗

Response to Reviewer JTSk (2/3)

Q3: Do the Spatial and LIBERO-10 results hold at a second OpenVLA-OFT seed?

Answer: Yes, both hold at a second seed (Table 21 in the revision). Each released checkpoint comes from one training run, so we read the question as a second evaluation seed. Setting the evaluation and environment seeds to 8 perturbs object placements within each official initial state, and we reran every code for 500 episodes under a rule fixed before the run.

Suite, codeSeed 7 (%)Seed 8 (%)Registered test at seed 8Both seeds pooled
Spatial, quantized full98.698.0referencereference
Spatial, two rows98.899.0passes (P = 0.0020)passes (P = 3.8 × 10⁻⁵)
Spatial, four rows98.897.8passes (P = 0.0156)passes (P = 5.7 × 10⁻⁵)
LIBERO-10, quantized full92.291.8referencereference
LIBERO-10, four rows92.692.2passes (P = 0.0010)passes (P = 1.9 × 10⁻⁶)
LIBERO-10, two rows90.090.6fails (P = 0.32)fails (P = 0.40)

Two rows fail on LIBERO-10 at both seeds, confirming four rows as its operating point. Goal was the boundary suite in the submission, so we evaluated it at two additional seeds, registering each before its run and the third after seeing the second (Table 23 in the revision).

Goal, codeSeed 7 (%)Seed 8 (%)Seed 9 (%)Three seeds pooled
Quantized full97.697.095.8reference
Two rows96.696.497.0passes (P = 0.0015)
Four rows96.896.696.0passes (P = 1.0 × 10⁻⁵)

A second policy family gives a check across training runs. On π0.5, two rows keep task success on Spatial, Object and Goal and four rows keep it on LIBERO-10, pooled over two seeds (Table 24 in the revision).

At seed 8 alone, two rows sit 0.6 points below the quantized full code and miss the test (P = 0.17), and at seed 9 they pass. Pooled across the three seeds, both prefixes keep Goal task success, and the submitted seed's losses are concentrated on a few tasks, matching the state dependence that PairGap certifies.

AuthorsOpenReview ↗

Response to Reviewer JTSk (3/3)

W2: On the submitted panel the paired and depth edges never bind, so the certificate reduces to a Clopper-Pearson bound and the third contribution is untested where it could matter.

Answer: The depth edge binds in the one comparison that every FPE deployment faces, between the received prefix and its own unreceived full code. Your reading of the submitted panel is exact. On a saturated panel, the Clopper-Pearson absolute bound already forms the shortest path in Theorem 1. A depth edge matters at states where a prefix and its full code both fail often. The new panels test that regime (Table 25 in the revision).

Panel, one candidateTolerance εCertified by the absolute boundCertified by the graph with its depth edge
LaRA-VLA (8 states)0.0508
LaRA-VLA0.1068
Flex-π, LIBERO-10 (40 states)0.10040
Flex-π, LIBERO-100.153440
OpenVLA-OFT with Gaussian noise, Goal (10 states)0.10010
OpenVLA-OFT with Gaussian noise, Goal0.20010

The two edges answer different questions. The absolute edge bounds how often the prefix fails, so at 32 seeds even a zero-failure bound is 0.109, and a state where the task itself often fails can never be certified. The depth edge bounds the gap between the prefix and its full code, which stays small because the two share seeds and fail on largely the same ones. At the hardest Flex-π state, both fail on the same 31 of 32 seeds. PairGap certifies the prefix at 0.010 against an absolute bound of 0.999, because those failures stem from the state and the remaining chunk brings no gain. At every certified state, the robot executes the received prefix and skips the remaining rows, using 720 bits per decision on Flex-π versus 1,328 for the full code. We report this one-candidate bank as a secondary analysis specified after inspecting the first OpenVLA-OFT state, with even seeds certifying and odd seeds auditing. On the held-out seeds, one certified state measures 0.109 at ε = 0.10 and none exceeds 0.15.

With four sampled candidates, the bank also tests whether a rival chunk improves on the prefix (Tables 26 and 27 in the revision). On OpenVLA-OFT Goal, rivals disagree with the prefix on up to 34 of 64 seeds, so no rule certifies a state at ε ≤ 0.20. The graph lowers the bound at 8 of 10 states, from 0.955 to 0.375 at task 3. On Flex-π, the relational edges certify no state beyond the absolute bound. The receipt rule certifies 34 states at ε = 0.15 using 3,488 bits versus 32 states and 5,312 bits for receiving every full code.

Thank you again for insightful questions that sharpened both the headline and the certificate analysis. These updates appear in the revision across the entropy-coded headline of the abstract, Tables 21, 23 and 25, and the certificate results in Section 5.5.

We're happy to address any further questions you may have.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.