OpenVLA at ~15 ms: how OpenVLA-OFT reaches high-frequency control

Quick facts

Base OpenVLA (LIBERO, A100)

4.2 Hz · 240 ms/step

OpenVLA-OFT (LIBERO, A100)

109.7 Hz · 73 ms/chunk

Action representation

Discretized tokens (base) / continuous L1 (OFT)

Chunk size (OFT)

K = 8 timesteps per forward pass

Per-action budget cleared

~9 ms << 15 ms real-time control loop

Data implication

Contiguous action chunks, camera-proprioception sync

Comparison

The short answer: base OpenVLA isn't 15 ms — OpenVLA-OFT is

If you searched "openvla 15 ms" expecting the base model to run that fast, it doesn't. Stock OpenVLA is a 7B-parameter policy that decodes one action per forward pass, and on an NVIDIA A100 it measures 4.2 Hz — about 240 ms between actions^[1]. That is fine for slow pick-and-place and far too slow for anything with contact dynamics.

The single-digit-millisecond number belongs to OpenVLA-OFT (Optimized Fine-Tuning), a follow-up recipe from the same lab. On the LIBERO suite, OFT clocks 109.7 Hz — roughly 73 ms to produce an 8-step action chunk, which works out to about 9 ms per executed action^[1]. That is the figure that clears a real-time control budget: a 100 Hz loop leaves you 10 ms per tick, and OFT fits inside it with headroom. So the honest answer to "how does OpenVLA hit ~15 ms" is: the base model doesn't, but the OFT variant beats it comfortably, and it does so without swapping the backbone or the training corpus.

One correction worth stating up front, because it circulates in secondhand summaries: OpenVLA does not use a diffusion action head. It emits discretized action tokens^[2]. The latency win in OFT comes from how those outputs are decoded, not from switching to a diffusion sampler.

Why base OpenVLA is slow: autoregressive discrete action tokens

OpenVLA borrows its output scheme from RT-2-style action tokenization. Each 7-DoF action (x, y, z, roll, pitch, yaw, gripper) is discretized into 256 bins per dimension, and the model predicts those seven tokens the same way a language model predicts words: one token at a time, each conditioned on the last^[2]. Seven sequential decoder passes produce one action.

That sequential dependency is the whole cost. If you want to predict a chunk of D future actions, autoregressive decoding needs K·D forward passes; the transformer never gets to amortize work across tokens^[1]. On a 7B model each pass is a full forward through the stack, so 240 ms per step is not a tuning failure — it is the arithmetic of decoding seven tokens in series on a large network. This is also why naively "just run it faster" advice (smaller batch, better kernels) tops out quickly: the bottleneck is the number of dependent forward passes, not raw FLOPs.

How OFT cuts latency 26x: parallel decoding, chunking, continuous actions

OpenVLA-OFT changes three things about decoding and leaves the pretraining alone^[1].

Parallel decoding. Instead of predicting the seven action tokens autoregressively, OFT swaps the causal mask for bidirectional attention and emits all of them in a single forward pass. One pass, not seven. That change alone is where most of the 26x throughput gain originates.

Action chunking. OFT predicts a chunk of K = 8 future timesteps at once rather than a single action, so one forward pass yields eight actions the controller can execute open-loop before the next inference call. Chunking multiplies effective throughput K-fold with almost no added per-call latency.

A continuous action head. OFT drops the 256-bin discretization for a continuous head trained with L1 regression, which removes the token-by-token structure entirely and pairs cleanly with parallel decoding.

Stacked, these take LIBERO inference from 4.2 Hz to 109.7 Hz (240 ms to 73 ms per chunk) and — the part that matters for anyone weighing speed against quality — raise average LIBERO success from 76.5% to 97.1%^[1]. Faster and better, not a trade. On the bimanual ALOHA setup the same recipe (reported as OFT+) moves a 14-DoF policy from 1.8 Hz to 77.9 Hz, a 43x gain^[1].

What ~100 Hz control actually demands from your training data

Here is the part the spec sheets skip, and it is where an inference number turns into a data-sourcing problem. Action chunking predicts eight consecutive actions in one shot, so the model can only learn a coherent chunk if the training demonstrations contain eight consecutive actions recorded close together in time. A trajectory logged at 5–10 Hz and up-sampled to look like 100 Hz gives you interpolation, not motion — the intra-chunk dynamics the policy is supposed to imitate were never captured. If you plan to deploy at ~100 Hz, the demonstrations should carry an action stream at a commensurate control rate.

Two more requirements follow. First, synchronization: the camera frame and the proprioceptive/action reading at each timestep have to share a clock, because a few milliseconds of skew between what the policy sees and what it did trains the wrong correspondence — and skew that is invisible at 5 Hz becomes decisive at 100 Hz. Second, format: the chunked, per-timestep action deltas and timestamps need to survive delivery intact, which is exactly what RLDS and the LeRobot schema are built to preserve.

This is the sourcing wedge behind the whole page. High-frequency VLA policies are gated less by model architecture — OFT is public — than by whether anyone captured demonstrations at the rate and sync tolerance the architecture assumes. If you are commissioning capture rather than reusing a public corpus, specify the control frequency, the sync budget, and the chunk-friendly action format in the brief, then route it through the VLA training data pipeline. See the VLA fine-tuning guide for how that data feeds an OFT run end to end.

Related pages

Use these to move from category-level context into specific task, dataset, format, and comparison detail.

External references and source context

1. Fine-Tuning Vision-Language-Action Models: Optimizing Speed and Success

   OpenVLA-OFT recipe: parallel decoding, action chunking (K=8), continuous L1 action head. LIBERO base 4.2 Hz / 240 ms vs OFT 109.7 Hz / 73 ms (26x throughput), success 76.5% to 97.1%; ALOHA base 1.8 Hz vs OFT+ 77.9 Hz (43x). Base OpenVLA emits 7 discrete action tokens per timestep autoregressively; K*D forward passes for a D-step chunk.

   arXiv ↩
2. OpenVLA: An Open-Source Vision-Language-Action Model

   OpenVLA is a 7B-parameter vision-language-action model that discretizes each action dimension into 256 bins and predicts action tokens autoregressively via the language-model decoding stack — discretized tokens, not a diffusion action head.

   arXiv ↩

FAQ