When a robot moves to grab or follow an object, there can be roughly two scenarios – everything remains static, or the system becomes dynamic and the position of the object or the scene changes. Often a robot is halfway through a reach when the object moves. By the time the next action comes back, the camera frame it was based on is already old. How much of that delay came from the model, and how much came from the way we asked the robot to wait for it?
We’ve already covered how Vision-Language-Action models work and what happens around them in an embodied harness. This time, let’s see what we can do with those milliseconds when working with VLA robots. Some methods cut work inside the model, some generate actions in fewer steps. Others let the robot keep moving while the model works, or keep a network round trip out of its way.
Here’s how to tell those approaches apart, with 25 methods and links to the papers, projects, and code where available.
TL;DR: Start with where the robot is losing time: processing the observation, generating an action chunk, waiting between chunks, or talking to another device. Faster inference, faster reactions, and shorter tasks are three different results.
VLA robot acceleration methods at a glance
We’ve grouped each method by where its main saving shows up. Several change more than one part of the pipeline.
Method | Where it helps | What changes | What to look at |
|---|---|---|---|
APS-VLA | Inside the model | Learn which visual tokens the policy needs | Shorter policy inference |
ActPrune | Inside the model | Drop image patches before vision encoding | Less vision work; model-dependent gains |
EfficientVLA | Inside the model | Prune layers and visual tokens; cache action features | Lower inference latency |
VLA-Cache | Inside the model | Reuse visual keys and values across frames | Less repeated vision-language work |
QuantVLA | Inside the model | Lower precision in selected linear layers | Smaller model memory footprint |
SmolVLA | Inside the model | Smaller backbone, fewer visual tokens | Less work per observation |
Real-Time Chunking (RTC) | While the robot is moving | Overlap inference with motion; fix the committed prefix | Less waiting between chunks |
Training-Time RTC (TT-RTC) | While the robot is moving | Train on action prefixes and simulated delays | Cheaper handoff between chunks |
SR-VLA | While the robot is moving | Predict the next observation and repair the cache if needed | Less waiting between action chunks |
DASH | While the robot is moving | Run the vision-language backbone and action head on separate clocks | The action loop doesn’t wait for the backbone |
Path-preserving Time Scaling (PTS) | While the robot is moving | Move faster along the same path between replans | More completed tasks per unit time |
RAVEL | While the robot is moving | Keep partially denoised actions in a rolling buffer | First usable action arrives sooner |
VLASH | While the robot is moving | Predict from where the robot will be when the chunk arrives | Shorter reaction delay |
A2C2 | While the robot is moving | Adjust the current action using fresh observations | Keep reacting during a slow model call |
Zora | When generating actions | Retrieve likely action tokens, then verify in batches | Less serial decoding |
VSpark | When generating actions | Draft and verify several action tokens in parallel | Faster autoregressive decoding |
Urgency-Aware Denoising (UAD) | When generating actions | Release the actions needed now and refine the rest | Shorter wait for executable actions |
OpenVLA-OFT | When generating actions | Predict a continuous chunk in parallel | Faster chunk generation |
SnapFlow | When generating actions | Distill several flow steps into one | Fewer action-head evaluations |
FlashVLA (streaming action decoding) | When generating actions | Denoise neighboring chunks in a rolling buffer | Steady action-chunk delivery |
VLA-ULAP | Between the robot and the server | Alternate remote VLA calls with a small local predictor | Fewer calls across the network |
Robion | Between the robot and the server | Schedule VLA stages and prioritize requests near their deadlines | More robots served within latency budgets |
VLA Handover | Between the robot and the server | Run a small policy locally; escalate predicted failures | Fewer server requests |
CloudEdgeVLA | Between the robot and the server | Keep fresh perception and control local; get semantic features remotely | Keep moving without a blocking round trip |
ComVLA | Between the robot and the server | Choose which visual tokens to send at the split | Less data crosses the link |
25 Ways to Make VLA Robots Faster
Inside the model
Start here if the robot is waiting on a single model call. You can shrink the backbone, reuse work from the last camera frame, or change how much precision the GPU needs to carry.
1. APS-VLA
APS-VLA learns which visual tokens to keep from robot demonstrations, without changing the VLA backbone. During training, the selector also learns which tokens help predict what the robot will see next. That extra predictor is removed at deployment. Across five physical tasks on two dual-arm platforms, average policy inference fell from 137.25 to 93.25 ms, with 61% average success versus 60% without pruning.
2. ActPrune
ActPrune uses the previous action chunk to decide which image patches to encode. The fixed camera keeps patches along the planned gripper path. The wrist camera can drop patches that look unchanged once you account for the camera’s own motion. On LIBERO, OpenVLA-OFT ran 1.61× faster at 25% token retention. For π0.5, there is just 1.03× despite a 38% FLOP reduction. The flow-based action head still has work to do.
3. EfficientVLA
EfficientVLA looks for work the policy can skip in three places: similar language-model layers, redundant visual tokens, and intermediate features that change little across denoising steps. It keeps task-relevant and visually diverse tokens. On CogACT in SIMPLER, the authors measured 1.93× faster inference on an NVIDIA A40, with average success down 0.6 percentage points.
EfficientVLA Paper
4. VLA-Cache
If a camera sees the same tabletop twice, the model doesn't need to process every patch from scratch. VLA-Cache reuses cached keys and values for nearly unchanged visual tokens and refreshes regions that are changing or matter to the task. It works without additional training. The reported profit is up to 1.7× faster CUDA inference in the tests, while the reported increase in control frequency was 15% (remember that these are different clocks).
5. QuantVLA
QuantVLA compresses linear layers in the language backbone and action transformer at the same time keeping attention projections in floating point. It calibrates the scales so quantization doesn't throw off the attention or residual updates. In its π0.5 W4A8 configuration, the reported memory for those two modules dropped from 4.27 GB to 1.28 GB. That's a memory result. Whether it also saves time depends on the kernels and hardware doing the work.
6. SmolVLA
SmolVLA starts with a smaller model instead of trying to make a big one fit later. It limits each image to 64 visual tokens, reads from the earlier layers of its vision-language backbone, and uses a lightweight action expert. The whole policy has about 450M parameters. Its asynchronous runner can help too, but that is a separate saving: the runner changes when the model works, while the smaller backbone changes how much work there is.
While the robot is moving: Execution-Time Latency Optimization
With asynchronous execution, the model prepares the next set of actions while the robot carries out the current one. The model call can take just as long, but the robot spends less time waiting. PTS saves time in a different way: it changes how fast the arm moves along the planned path.
7. Real-Time Chunking (RTC)
RTC starts the next prediction before the current chunk runs out. It keeps the actions the robot will already have committed to by the time the answer comes back, then fills in the rest so the transition stays smooth. In the authors' physical π0.5 experiments, the model call itself went from 76 to 97 ms before network overhead. The robot still made faster task progress under added delay because it didn't have to stop for every new chunk.
Real-Time Chunking (RTC) Paper
8. Training-Time RTC (TT-RTC)
TT-RTC lets the model see committed actions during training, so inference no longer needs the original RTC guidance step to keep those actions fixed. In the researchers' real-robot comparison with π0.6 on a remote H100, mean end-to-end latency per inference request was 108 ms versus 135 ms with inference-time RTC, with similar task success and duration. The training delay range really matters when taking it to another setup.
Training-Time RTC (TT-RTC) Paper
9. SR-VLA
This option starts the next VLA call before the next camera frame arrives. It predicts what the camera and robot sensors will see, then prepares a tentative action chunk. When the real inputs arrive, it can keep the chunk or selectively update the attention cache. In simulated LIBERO, π0.5’s average wait per query fell from 128 to 48 ms. That is the wait left after overlapping work, not the duration of the whole model call.
SR-VLA Paper
10. DASH
DASH lets the slower vision-language model (VLM) update its context separately from the fast action head. The head reads a fresh camera image alongside the latest available backbone features, so it doesn’t have to wait for the backbone on every tick. In latency-aware RoboTwin simulation, DASH held 20 Hz across 0.8B to 8B backbones. The synchronous version fell from 9.7 to 4.1 Hz over the same range.
DASH Paper
11. Path-preserving Time Scaling (PTS)
A robot can lose time when it isn’t waiting for inference. PTS changes how quickly the arm follows a path, keeps the normal pace during gripper movements, and joins each replanned path at the progress already covered during inference. With the same one-step decoder in LIBERO simulation, it improved completed-task throughput by 28% for π0.5 and 38% for SmolVLA versus normal-speed asynchronous execution.
Path-preserving Time Scaling (PTS) Paper
12. RAVEL
RAVEL works ahead on future actions and keeps them at different stages of denoising. To release the next action, it needs one more denoising step rather than a full restart. The action worker can also read recent vision while the slower backbone updates its context. In the paper’s synchronous simulation evaluation, where the simulator pauses during inference, median time from observation to first available π0.5 action fell from 272.86 to 93.45 ms on one RTX 4090. This measures action availability, not physical reaction time.
RAVEL Paper
13. VLASH
When a VLA starts processing the request, the arm is already on its way somewhere. VLASH estimates where the arm will be when inference finishes using the actions still in the queue, and trains the policy to handle that time offset. On an H100, both setups took 23.2 ms per model call. Using these measured times and a 500 ms action chunk, the authors calculated a worst-case reaction delay of 46.4 ms for VLASH versus 546.4 ms for synchronous execution.
VLASH Paper
14. A2C2
This method improves control under inference delay. A small correction head can use the latest observation while a slower base policy supplies the plan. That’s why the robot can adjust an action without waiting for an entirely new chunk. On simulated LIBERO Spatial with a 40-step executed horizon and 10-step injected delay, it raised success from 64.4% to 84.2% versus asynchronous execution.
A2C2 Paper
When generating actions
Once the model has seen the scene and read the instruction, it still has to turn that information into motion. At this moment a policy can spend time emitting tokens one by one or refining the same action chunk several times. RAVEL, from the previous section, also saves time here: it can release the next action while later actions are still being refined.
15. Zora
Instead of running a second neural model to draft actions, Zora looks up what happened next in similar past trajectories. It uses motion and agreement checks to accept some drafts and batches model verification for others. The software-only path was up to 3.4× faster in the researchers' NVIDIA Thor tests. The larger 7.6× figure includes a proposed hardware accelerator evaluated in simulation.
Zora Paper
16. VSpark
In a VLA that emits action tokens one at a time, a draft model can suggest several tokens for the main model to check together. VSpark keeps some of the main model’s predictions from rejected branches and offers them again under a corrected prefix. Tokens still have to pass the main model’s check. Across four autoregressive VLAs on LIBERO, average decoding speedups ranged from 1.28× to 2.10× versus token-by-token decoding.
VSpark Paper
17. Urgency-Aware Denoising (UAD)
The robot needs the first movements in a chunk now. The later ones can wait. UAD releases the early part after fewer denoising steps, then keeps refining the tail while the robot starts moving. With SmolVLA in LIBERO-Plus simulation, average action availability latency fell from 21.6 to 11.4 ms and average success increased from 35.3% to 36.5% compared to the tuned full-denoising baseline.
Urgency-Aware Denoising (UAD) Paper
18. OpenVLA-OFT
OpenVLA originally spells out actions one token at a time. OFT fine-tunes it to predict a chunk of continuous actions together in one forward pass. In the single-image LIBERO comparison, parallel decoding and action chunking with continuous L1 regression increased action-generation throughput by 26× and cut latency from 239.6 to 72.9 ms. The final configuration with an additional wrist-camera image and proprioceptive inputs achieved 71.4 actions/s and 112 ms latency. One call now produces several actions, so the gain per generated action is much bigger than the gain per call.
19. SnapFlow
A flow-based policy usually starts with noise and refines it into an action chunk over several steps. SnapFlow teaches the action head to take a shortcut using targets from its own two-step predictions. On LIBERO, one-step π0.5 model from this study scored 98.75% versus 97.75% for its ten-evaluation teacher. The revised paper reports about 3.3× lower batch-one model latency. The interesting catch is that simply running the original π0.5 model with one denoising step already achieved a 3.4× speedup, but success dropped to 96.75%. SnapFlow raised it to 98.75% at roughly the same inference speed. Ten action-head evaluations going down to one doesn’t make image processing ten times faster.
SnapFlow Paper
20. FlashVLA (streaming action decoding)
This one keeps neighboring action chunks in a buffer at different noise levels. It updates them together, releases the cleanest one, and adds a noisy chunk to the back. After the buffer fills, each decoding step can deliver a chunk while the next ones are already taking shape. In real-world deployment, FlashVLA sustained at least 30 Hz control on a single GPU. Note that it is not the time it takes to fill the buffer.
Two quick checks before changing the action head. FAST fits an action chunk into fewer tokens, but its headline 5× gain was in training; π0-FAST still runs slower at inference than flow-matching π0. And the authors of When One Step Is Enough found that some well-trained flow VLAs already handle one-step sampling fairly well. Try the simple baseline before adding a distillation stage.
Between the robot and the server
A remote GPU may run the model faster and still make the robot wait longer. The delay can come from sending data back and forth or from waiting in the server’s queue. Some methods cut the number of round trips; Robion changes how a shared server batches and schedules requests.
21. VLA-ULAP
VLA-ULAP lets a small local model fill in between calls to the remote VLA. It predicts complete action chunks from fresh camera frames, robot state, and recent actions without needing hidden states from the remote model. It cut remote calls per successful episode by 70–72% at the tested placements in a physical SO-101 glue-stick task, with no observed drop in success. That figure counts calls, not wall-clock task time.
VLA-ULAP Paper
22. Robion
A shared GPU server can be fast for one robot and still leave a fleet waiting in line. Robion overlaps the vision-language stage of one batch with the action stage of another and prioritizes requests closest to their deadlines. In a serving experiment using simulated robot traffic, four GPUs served requests from up to 64 simulated robots across eight models while meeting 98% of request deadlines. That measures serving capacity.
Robion Paper
23. VLA Handover
VLA Handover gives a small on-robot policy the first shot. A failure predictor can hand the episode over to a larger server model instead of paying for a round trip on every chunk. On three simulated LIBERO suites, SmolVLA with a π0.5 handover made 49–77% fewer server requests than server-only control, with success 2–4 percentage points lower. LIBERO-Long was much less forgiving: handover reached only 63.6% success versus 93.2% for server-only control, while reducing server requests by just 34%. So the 49–77% reduction applies to the other three suites.
VLA Handover Paper
24. CloudEdgeVLA
This one splits one policy across devices. The local action head uses a fresh image and the latest semantic features it has received from the cloud, even if those features are a little old. In a small physical test with a Franka arm and one second of added round-trip delay, it put a toy bear into a box in 7 of 10 trials where the box was moved mid-reach; VLASH got 0 of 10 in that setup. The takeaway is about that specific division of work, not a guarantee that stale features always suffice.
25. ComVLA
ComVLA runs vision locally, then selects which visual tokens to send to the remote model based on the communication budget. At 32 tokens, ComVLA reached 95.4% average success on LIBERO, compared with 96.9% for the 512-token OpenVLA-OFT model. Within ComVLA, cutting the token budget reduced transmission and FLOPs, but compute latency stayed around 42–43 ms across tested budgets. That's still about 22% below the full OpenVLA-OFT baseline's 54.8 ms. These figures exclude network transmission time.
ComVLA Paper
What should we actually measure?
VLALagBench asks what happens when you add delay to a working policy. Even 100 ms nearly halved success on some moving-target tasks in its experiments. Other tasks were less sensitive. Asynchronous execution recovered some of the loss, but could also mean more inference requests.
VLA-Triage looks at the other end of the problem: where inference time goes across seven VLAs and four GPU families. It’s useful when deciding whether pruning, quantization, compilation, or CUDA graphs will help on the hardware you use. A technique that helps on its own may add little once another optimization is already in place.
If you try one of these methods, note the hardware, action-chunk length and execution mode. Then report three numbers together: time from a camera observation to an action that uses it, total task time, and success rate. For a remote setup, include the network conditions and look at slow requests as well as the average.
FAQ
What is a VLA model?
A vision-language-action model turns observations and instructions into robot actions. It can predict one action or a chunk of future actions; a robot controller then executes them.
Does faster VLA inference make a robot react faster?
Sometimes. Inference is only one step. The robot may still be executing an older chunk, waiting for a network response, or waiting for the controller to accept a new command. Measure when fresh observations actually change the motion.
Do you need to retrain a VLA to speed it up?
Not always. VLA-Cache reuses computations at inference, and the original RTC can be applied to compatible policies without retraining. OpenVLA-OFT and SnapFlow change how the policy generates actions and require fine-tuning or distillation.
When does it make sense to run a VLA remotely?
When the extra compute is worth the round trip and the robot can handle late replies. Some systems keep action generation local and ask the cloud for features; others run a smaller local model and call a larger one only when necessary.





