The growing complexity of visuomotor policies poses significant challenges for deployment with heterogeneous robotic hardware constraints. However, most existing model-efficient approaches for robotic manipulation are device- and model-specific, lack generalizability, and require time-consuming per-device optimization during the adaptation process. In this work, we propose a unified framework named Device-Conditioned Quantization-For-All (DC-QFA) which amortizes deployment effort with the device-conditioned quantization-aware training and hardware-constrained architecture search. Specifically, we introduce a single supernet that spans a rich design space over network architectures and mixed-precision bit-widths. It is optimized with latency- and memory-aware regularization, guided by per-device lookup tables. With this supernet, for each target platform, we can perform a once-for-all lightweight search to select an optimal subnet without any per-device re-optimization, which enables more generalizable deployment across heterogeneous hardware, and substantially reduces deployment time. To improve long-horizon stability under low precision, we further introduce multi-step on-policy distillation to mitigate error accumulation during closed-loop execution. Extensive experiments on three representative policy backbones, such as DiffusionPolicy-T, MDT-V, and OpenVLA-OFT, demonstrate that our DC-QFA achieves 2-3× acceleration on edge devices, consumer-grade GPUs, and cloud platforms, with negligible performance drop in task success. Real-world evaluations on an Inovo robot equipped with a force/torque sensor further validates that our low-bit DC-QFA policies maintain stable, contact-rich manipulation even under severe quantization.
Figures & tables
Figure 1: Overview of the proposed DC-QFA pipeline. In stage I (Quantized Supernet Training), we train a weight-sharing supernet with quantization-aware training. In stage II (Device-aware Subnet Search), we search subnets under device-specific latency and memory constraints by optimizing a multi-objective objective guided by measured costs. In stage III (Deployment), we export the selected subnet, calibrate/compile for the target backend, and perform low-bit inference on-device.
Figure 2: Experimental setups in simulation and the real world. (a) Push-T. (b) LIBERO. (c) CALVIN. (d) Real robot tasks, including object handling (egg) and tool use (brush).
Method
Bit-width
Model Size
LIBERO
Spatial
Object
Goal
Long
Avg ↑
OpenVLA-OFT
FP16
15.1 GB
97.6
98.4
97.9
94.5
97.1
w/ BatchQuant
FP8
7.5 GB
96.8
98.2
96.2
93.2
96.1
DC-QFA (Ours)
97.2
98.0
97.2
93.9
96.6
w/ SmoothQuant
W8A8
7.5 GB
94.8
93.1
93.4
90.7
93
w/ AWQ
94.7
93.5
93.8
91.1
93.3
Table 1: Performance of OpenVLA-OFT [ 16 ] on the LIBERO [ 19 ] benchmark. We compare FP16 and quantized variants at FP8/W8A8 and W4A4 using SmoothQuant [ 32 ] , AWQ [ 18 ] , SQIL [ 24 ] , and BatchQuant [ 3 ] . Metrics are success rates (%) on four subsets; Avg is the mean (higher is better). DC-QFA (ours) is highlighted and matches or surpasses SQIL at the same bit-width.
Method
Bit-width
Model Size
Success Rate ↑
DiffusionPolicy-T
FP16
38.48 MB
0.772 ± 0.039
w/ BatchQuant
FP8
19.24 MB
0.759 ± 0.021
DC-QFA (Ours)
0.770 ± 0.016
w/ SmoothQuant
W8A8
19.24 MB
0.729 ± 0.011
w/ AWQ
0.733 ± 0.022
w/ SQIL
0.766 ± 0.019
Table 2: Results of DiffusionPolicy-T [ 14 ] on the Push-T dataset, where we compare various quantization techniques and their impact on model size and success rate.
Method
Bit-width
Model Size
CALVIN
LIBERO
D → D ↑
ABC → D ↑
Spatial ↑
Object ↑
Goal ↑
Long ↑
Average ↑
MDT-V (FP16)
FP16
45.04 MB
4.52 ± 0.02
3.72 ± 0.06
77.9
87.5
75.4
65
76.5
w/ BatchQuant
FP8
22.52 MB
4.45 ± 0.10
3.65 ± 0.05
77.2
86.9
75.1
64.8
76.0
DC-QFA (Ours)
4.47 ± 0.07
3.67 ± 0.09
77.4
87.4
75.5
65.1
76.4
w/ SmoothQuant
W8A8
22.52 MB
4.23 ± 0.04
3.57 ± 0.09
72.8
81.9
71.5
62.1
72.0
w/ AWQ
4.21 ± 0.03
3.55 ± 0.06
72.8
82.1
72.2
62.9
72.5
Table 3: Results of MDT-V [ 25 ] on the CALVIN [ 21 ] and LIBERO [ 19 ] datasets, including performance metrics across various quantization methods and bit-widths. The table presents the model size, accuracy, and average performance (average length on CALVIN and success rate on LIBERO) for each method, highlighting the effectiveness of our DC-QFA when compared to other quantization methods.
Method
Bit-width
Model Size
CALVIN
D → D ↑
ABC → D ↑
MDT-V
FP16
45.04 MB
4.52 ± 0.02
3.72 ± 0.06
DC-QFA
FP8
22.52 MB
4.47 ± 0.07
3.67 ± 0.09
DC-QFA + OPD
4.51 ± 0.04
3.72 ± 0.07
DC-QFA
W8A8
22.52 MB
4.48 ± 0.11
3.64 ± 0.07
DC-QFA + OPD
4.50 ± 0.07
3.69 ± 0.09
Table 4: Long-horizon evaluation on the CALVIN [ 21 ] benchmark using MDT-V [ 25 ] . We compare the quantized policies trained with DC-QFA and DC-QFA+OPD under FP8, W8A8, and W4A4 settings. Metrics report the average rollout length on the D → D and ABC → D splits (higher is better). While DC-QFA preserves most of the full-precision performance under quantization, incorporating OPD further improves rollout stability and consistently recovers performance closer to the FP16 baseline in long-horizon tasks.
Metric
OpenVLA-OFT (T1)
OpenVLA-OFT (T2)
DiffusionPolicy-T (T3)
DiffusionPolicy-T (T4)
MDT-V (T3)
MDT-V (T4)
Base Model (FP16)
18
14
11
13
13
14
AWQ (W4A4)
10
8
5
5
4
6
DC-QFA (W8A8)
18
14
10
13
11
12
DC-QFA (W4A4)
15
13
10
13
11
12
Table 5: Real-world manipulation results on the Inovo robotic platform under different quantization settings. We evaluate four tasks including Task 1: sweeping coffee beans into a dustpan , Task 2: picking up eggs and placing them into a box , Task 3: inserting a red pepper into a cup , and Task 4: picking up a carrot and placing it into a bowl . Each task is evaluated over 20 trials. We compare FP16 base model, a PTQ baseline using AWQ [ 18 ] with W4A4 quantization, W8A8 policies, and our DC-QFA W4A4 policies. Results show that DC-QFA significantly improves the robustness of low-bit policies in real-world manipulation tasks.
Figure 3: Pareto curves of performance-parameter trade-offs based on the MDT-V W8A8 setting.
Figure 4: For mixed-precision deployment, the bit-widths blW and blA for each layer are sampled from {INT4,INT8} . DC-QFA achieves superior performance compared to fixed-precision baselines.
Metric
FP16
W8A8
W4A4
Memory (GB)
15.2
7.9
4
Reduction
–
1.92 ×
3.80 ×
Latency (ms)
644.74
297.84
217.38
Speedup
–
2.16 ×
2.97 ×
Table 6: Performance, runtime memory, memory reduction, latency, and speedup under different quantization bit-widths on the Jetson Orin NX.
Vision-Language-Action (VLA) models exhibit remarkable action generation for embodied intelligence, but their heavy compute make deployment on edge platforms impractical. Aggressive, sub-4-bit weight quantization is the natural solution, yet existing post-training quantization (PTQ) methods suffer severe performance degradation in this regime. To address this, we introduce ActQuant, an action-guided mixed-precision PTQ framework that operates in two stages: (1) an inter-tensor bit allocator that assigns each weight matrix a single bit-width based on how much it contributes to predicting the agent's actions; (2) an intra-tensor scale optimizer tunes per-block quantization scales using action-aware curvature, so that dynamic range is concentrated on the weights most influential for control. To deliver the on-device benefits of our aggressive quantization, we further introduce OmniModel.cpp, an agentic conversion pipeline that ports architectures into a native C/C++ runtime with efficient low-bit kernels. We evaluate ActQuant both in simulation and on a real-world 6-DoF UR3 arm, with all models deployed through OmniModel.cpp. On the LIBERO benchmark, ActQuant is the only method that operates at or below 3 bits-per-weight, retaining 95.0% on OpenVLA-OFT and 94.8% on π0.5. Pushed further, ActQuant reaches 2.5 bpw at 90.1% on OpenVLA-OFT, compressing the backbone from 14.3 GB to 2.7 GB (5.3×). On the physical UR3 arm, π0.5 quantized with ActQuant retains the baseline's success rate while reducing the memory footprint by 2.5×.
Arash Akbari, Arman Akbari, Masih Eskandar +11
1Northeastern University · University of Georgia · 3Cisco Systems
Research on robotic manipulation has developed a diverse set of policy paradigms, including vision-language-action (VLA) models, vision-action (VA) policies, and code-based compositional approaches. Concrete policies typically attain high success rates on specific task distributions, but limited generalization beyond it. Rather than proposing another monolithic policy, we propose to leverage the complementary strengths of existing approaches through intelligent policy routing. We introduce RoboRouter, a training-free framework that maintains a pool of heterogeneous policies and learns to select the best-performing policy for each task through accumulated execution experience. Given a new task, RoboRouter constructs a semantic task representation, retrieves historical records of similar tasks, predicts the optimal policy choice without requiring trial-and-error, and incorporates structured feedback to refine subsequent routing decisions. Integrating a new policy into the system requires only a lightweight evaluation and does not incur training overhead. Across simulation benchmark and real-world evaluations, RoboRouter consistently outperforms individual policies, improving the average success rate by more than 3% in simulation and 13% in real-world settings, while preserving execution efficiency. Our results demonstrate that intelligent routing across heterogeneous, off-the-shelf policies provides a practical and scalable pathway toward building more capable robotic systems.
Yiteng Chen, Zhe Cao, Hongjia Ren +9
South China University of Technology · Nanjing University · University of New South Wales +5
Computationally lightweight manipulation policies predict executable actions with low inference latency, but prediction errors can limit task success. Iterative generative policies can achieve higher task success rates, but repeated network evaluations increase inference latency. Refining action proposals from computationally lightweight policies can combine these strengths, but the amount of refinement needed varies across states. We introduce RAIN (Refine Actions If Needed), a framework that predicts action errors at different refinement levels to decide whether and how much to refine each executable proposal, before performing any refinement. We train an ensemble to predict these errors by comparing action proposals and their refined versions with expert actions from offline demonstrations, without requiring explicit labels of refinement needs. Calibration balances uncertainty, computation, and temporal consistency. We evaluate RAIN on eight ManiSkill tasks and four real-robot tasks. In simulation, our policy achieves 66.6% success, approaching the best evaluated diffusion-policy success rate with 5.71 times lower policy latency. On the real robot, success increases from 55.0% with Action Chunking with Transformers (ACT) to 72.5%, with comparable average successful completion time. Matched controls show that dynamic routing maintains the strongest observed fixed-refinement success level with 26.6% fewer refiner evaluations. Project page: https://rain-policy.github.io/.
Hanlin Liu, Zichen Zhou, Jiacheng Zhang +6
The Hong Kong University of Science and Technology (Guangzhou) · Beijing Institute of Technology · Shanghai Jiao Tong University +2