Why Action Head Architecture Is the Most Underexplored Design Choice in VLA Systems

Everyone’s debating which VLM backbone to use. Almost nobody is asking the harder question: how should the model actually produce actions?

The robotics community is in the middle of a VLA gold rush. In the past 18 months, we’ve seen an explosion of Vision-Language-Action models, ranging from Google DeepMind’s RT-2 [1] to Physical Intelligence’s π₀ [4], from Berkeley’s Octo [3] to NVIDIA’s GROOT N1 [7]. The field is moving fast, and real robots are doing genuinely impressive things.

But if you read these papers closely, a pattern emerges that should make u uncomfortable. Every team picks a different action head architecture. And almost none of them justify it against the alternatives.

The Part Everyone Talks About (And the Part They Don’t)

Open any VLA paper, and the architecture diagram follows a familiar template. There’s a vision encoder (SigLIP, DINOv2, CLIP), a language encoder (LLaMA, Gemma, T5), and then the action head, which actually makes it a robot policy instead of a chatbot with eyes.

The vision backbone discourse is exhausting. There are papers upon papers comparing ViT variants and fusion strategies. But the action head? The component that determines whether your robot can fold a shirt or just stare at it? That part rarely gets a head-to-head comparison against other options.

And here’s the landscape as it actually stands:

Figure 1: Compilation from published papers [1] to [9]. See references for original sources.

Five Distinct architectural paradigms for the action head. No two industry leaders agree on the right one.

The Three Paradigms (actually four)

Think of it this way. The VLM (the “brain”) has figured out what the robot needs to do, like “pick up the red cup and put it on the shelf”. Now the action head has to turn that understanding into actual motor commands: move the arm here, rotate the wrist there, close the gripper now. The question is how.

Paradigm 1: Autoregressive (Predict actions like words)

Used by: RT-2 [1], OpenVLA [2], Gato

The idea is simple: treat robot actions like language. Chop up continuous movements into discrete bins (like rounding 0.347 to bin 89 out of 256), and predict them one token at a time, left to right, using the same next token prediction that powers ChatGPT.

The appeal is real. You inherit the entire LLM training stack for free. No new loss functions, no new sampling procedures. RT-2 demonstrated this could work at 55B parameters [1], and OpenVLA scaled it to 7B while open sourcing everything, beating RT-2-X by 16.5% across 29 tasks [2].

But this approach has a hard ceiling: speed. When actions are smooth and continuous (which robot motion is), consecutive tokens are nearly identical. The model can fall into trivially copying the last token instead of predicting meaningful future actions [5]. The FAST paper showed that standard binning fails completely on tasks above 20Hz [5]. OpenVLA’s own GitHub recommends downsampling your data to 5–10 Hz [2], capping your temporal resolution well below what dexterous tasks demand.

For context, π₀ runs at 50 Hz, GROOT N1 runs at 120Hz.

Paradigm 2: Diffusion (Sculpt actions from noise)

Used by: Octo [3], Diffusion Policy [10], CogACT

Instead of predicting tokens one by one, this starts with pure random noise shaped like an action, and iteratively refines it, like a sculptor carving away marble, until a clean action emerges. This is the same idea behind image generators like DALL-E, applied to robot motion.

The big advantage is that when there are multiple valid ways to do something (grab a cup from the left or the right), diffusion can represent all options simultaneously. Autoregressive models pick one path and commit.

Octo is the strongest evidence here. The team ran the cleanest ablation in the VLA literature, with the same architecture, the same data, and three different training objectives (diffusion, MSE regression, and cross entropy on discrete tokens). Diffusion won substantially [3].

Figure 2: Table II from Ghosh et al. [3], under POLICY, Octo’s diffusion objective (83%) dramatically outperforms both MSE (35%) and discretized action prediction (18%) on the same architecture and data.

A recent CMU paper adds theoretical grounding: diffusion models extract more learning from limited data than autoregressive models [11]. Their conclusion is blunt: if you’re data-constrained, use diffusion. Their work studied language models, but the logic likely transfers to robotics, where 10,000 hours is considered a massive dataset [4], and data scarcity is the norm.

The catch? Inference is slow. You need multiple denoising passes (typically 10–100) per action chunk. And when you bolt a diffusion head onto a frozen VLM, it only sees final features. That means, it may not fully leverage the VLM’s reasoning capabilities, at least, that’s the argument HybridVLA’s authors make [9].

Paradigm 3: Flow Matching (Learn a shortcut through the noise)

Used by: π₀ [4], π₀.5 [6], GROOT N1 [7]

Flow matching is diffusion's more efficient cousin. Instead of learning to remove noise step by step, it learns a direct transport path from noise to action, like GPS directions versus wandering and checking if you’re getting warmer. Fewer steps, same destination.

π₀ introduced this to VLAs [4]. Their architecture splits the model. The VLM handles reasoning, and a smaller “Action expert” handles flow matching. The results speak: 50Hz control for laundry folding and grocery bagging, tasks well beyond what autoregressive VLAs had demonstrated [4]. GROOT N1 took the same idea and pushed it to 120Hz for humanoid robots [7].

Figure 3. From Pertsch et al. [5], naive binning error grows with frequency (yellow). DCT-based FAST stays stable across all rates (green).

The natural question: how much of this is flow matching vs. data vs. compute?

Physical Intelligence partially answered this themselves with π₀-FAST, which uses the same backbone and data but swaps flow matching for FAST autoregressive decoding, and roughly matches on task success while training 5× faster [5]. That’s genuine evidence that the action head choice is less decisive than the backbone and data. But inference latency still differs (~750ms for FAST vs. ~100ms for flow matching [5]), and their cross-model comparisons against OpenVLA and Octo still confound multiple variables [4].

Paradigm 4: Hybrids (Why not both?)

Used by: HybridVLA [9], π₀.5 [6], DiffusionVLA [8]

This is where it gets interesting. HybridVLA runs both autoregressive and diffusion inside the same model and adaptively fuses their predictions [9]. The result: 14% improvement in simulation and 19% in real-world tasks over prior state of the art [9].

But the most important finding isn’t the headline number. It is that the two approaches have complementary strengths across different tasks [9]. Sometimes the discrete prediction is better. Sometimes the continuous one is. This single observation should make everyone question single paradigm approaches.

π₀.5 takes a different hybrid route. It pretrains with discrete FAST tokens (fast, scalable), then post-trains with flow matching (precise, continuous) [6]. Two paradigms, two stages, better than either alone.

The Elephant in the Room

Here’s what should frustrate everyone reading VLA papers.

Not a single published work, as of March 2026, holds everything constant except the action head and measures the difference.

Every comparison in the literature confounds at least three variables:

1. Architecture beyond the action head. π₀ uses PaliGemma + action expert. OpenVLA uses LLaMA 2 + DINOv2/SigLIP fusion. Octo uses a custom transformer with readout tokens [2][3][4]. You can’t attribute performance to the action head when the entire pipeline differs.
2. Training data. π₀ trains on 10k+ hours of proprietary data [4]. OpenVLA uses 970K episodes from Open X-Embodiment [2]. Octo manually curated 25 OXE datasets [3]. Vastly different distributions.
3. Compute Budget. π₀ trains for 700k steps. OpenVLA for 160k. Octo for 320k [4][2][3]. These “steps” differ in batch size, sequence length, and effective FLOPS.

As already mentioned, Octo ablation comes cleanest. But Octo is a 93M parameter model without a VLM backbone. It doesn't tell us how these choices interact with large-scale vision language pretraining.

Figure 4: π₀ architecture from Black et al. [4], pre-trained VLM handles vision and language, separate action expert generates actions via flow matching.

What the Evidence does tell us:

Autoregressive binning has a hard ceiling on temporal resolution. FAST showed degradation above 20Hz [5]. OpenVLA recommends 5–10Hz [2]. If your robot needs dexterous manipulation, vanilla autoregressive is out.

FAST tokenization partially closes the gap. π₀-FAST mathced diffusion π₀ on task success while training 5x faster [5]. But inference latency is still ~750ms per chunk vs ~100ms for flow matching [5]. For real-time control, this matters.

Diffusion excels with limited data. CMU’s scaling laws provide theoretical grounding [11]. Robotics is definitionally data constrained (already mentioned when talking about π₀’s 10k+ hours).

The dual system architecture is converging, but the action system isn't. Helis [8], GROOT N1 [7], and π₀.5 [6] all use “slow VLM reasoning + fast action generation”. But the fast part differs everywhere: flow matching, DiT-based flow matching, and undiscovered.

HybridVLA’s finding is the most underappreciated result in recent VLA research. Task-dependent complementary strengths between paradigms [9] suggest there is no single best action head. The optimal choice depends on the task, action space, control frequency, and data.

So, WHAT NOW?

The action head is not a detail. It's the interface between understanding and doing, between a model that knows what to do and a robot that does it. Right now, the field is treating it as a plug-in component, chosen by engineering intuition and local evidence rather than controlled comparison.

The experiment the field needs is straightforward: one backbone, one dataset, one compute budget, multiple action heads, same eval. Until someone published that, we’re comparing recipes where the chef, the kitchen, and the ingredients all change at once, then arguing which oven is best.

Figure 5: From Liu et al. [9], (a) prior diffusion VLAs treat the action head as a separate module, (b) HybridVLA integrates both diffusion and autoregressive generation within the same LLM. Right: benchmark results across simulation and real-world tasks.

If you’re working on VLAs and this resonated, or if you think I’m wrong, I’d like to hear about it.

References

[1] Brohan et al. “RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control.” arXiv:2307.15818, 2023.

[2] Kim et al. “OpenVLA: An Open-Source Vision-Language-Action Model.” arXiv:2406.09246, 2024.

[3] Ghosh et al. (Octo Model Team). “Octo: An Open-Source Generalist Robot Policy.” arXiv:2405.12213, 2024.

[4] Black et al. “π₀: A Vision-Language-Action Flow Model for General Robot Control.” arXiv:2410.24164, 2024.

[5] Pertsch et al. “FAST: Efficient Action Tokenization for Vision-Language-Action Models.” arXiv:2501.09747, 2025.

[6] Physical Intelligence. “π₀.5: A VLA Model with Open-World Generalization.” physicalintelligence.company/blog/pi05, 2025.

[7] Bjorck et al. “GR00T N1: An Open Foundation Model for Generalist Humanoid Robots.” arXiv:2503.14734, 2025.

[8] Figure AI. “Helix.” / Anonymous. “DiffusionVLA.” OpenReview, 2025.

[9] Liu et al. “HybridVLA: Collaborative Diffusion and Autoregression in a Unified VLA Model.” arXiv:2503.10631, 2025.

[10] Chi et al. “Diffusion Policy: Visuomotor Policy Learning via Action Diffusion.” RSS, 2023.

[11] Prabhudesai et al. “Diffusion Beats Autoregressive in Data-Constrained Settings.” arXiv:2507.15857, 2025.