RobotGuide
Brain and cerebellum/VLA Anatomy

Foundation-model teardown · VLA Anatomy · 25 min

Taking a VLA Apart

Backbone, visual encoding, action head, action chunking — four components explain the shared skeleton of every VLA; the industry's debates are all about how the components connect.

25 minreal anchors, sourcedchecked 2026-11

What it really is, once the buzzwords are off

Every VLA follows the same idea: take an internet-trained vision-language model as the base, then attach an action head that 'knows how to act'. The skeleton had converged by 2026 — the debates and performance gaps are all in how components connect and which action-head route is chosen. Once you understand these four components, you can translate any new model's press release into 'which component it changed'.

The big picture first: four components

From image to joint command, a VLA takes only four steps: visual encoding → language backbone reasoning → action head generation → action chunk execution. Each step has several options, and the combinations make up every model on the market. The table below is this page's roadmap; we unpack each one after.
ComponentWhat it doesMainstream approachRepresentative models
Visual encodingTurn camera frames into vectors the model can readDual encoders: spatial + semanticOpenVLA
Language backboneFuses image, instruction and history for reasoningOff-the-shelf VLMs (Llama / Gemma / Qwen family)RT-2 / π0
Action headTurns the model's internal state into continuous actionsDiscrete tokens / flow matching / diffusionSection on this page
Action chunkingPredicts a stretch of actions at once, lowering the brain's frequency requirementInterpolation within a chunk + asynchronous executionDeployment page
To judge any new model, ask three questions: Did the backbone change? Did visual encoding change? Did the action head change? If none changed and only the data recipe did, its progress belongs on the data page (Data Engine); if the action head changed, read the section below.

Component one: why the base must be a VLM

Before RT-2, robots learned instructions via 'instruction templates + retrieval'. RT-2 proved another path: let a VLM pre-trained on internet image-text pairs output actions directly, so an instruction like "bring me the dinosaur toy" — never seen in robot data — can still be executed, because it recognizes dinosaur toys. This 'internet prior' is the entire advantage VLAs hold over traditional perception-planning stacks, and it's why almost nobody trains the base from scratch. But the base is not the bigger the better. The brain layer is only allowed 1–10Hz (brain and cerebellum principles), and the inference latency of a 55B base on the robot itself disqualifies it outright. So the practical selection range in 2026 is 0.45B (SmolVLA) to 7B (OpenVLA): closed-source flagships (Gemini Robotics 2, Helix) keep parameters undisclosed but all obey the same constraint — the brain must leave latency budget to the cerebellum. This is why 'parameter count' is not a monotonically better-is-better metric in VLA evaluation.

Component two: why two visual encoders

OpenVLA runs two visual encoders in parallel: DINOv2 handles spatial relations (where objects are, relative poses — self-supervised features are geometry-sensitive), SigLIP handles semantics (what it is, how it maps to words in the instruction — image-text aligned features). The problem with a single encoder: image-text alignment models (CLIP/SigLIP family) are insensitive to spatial details like 'move two centimeters left', while purely self-supervised features don't align with language. You need both. This design was widely inherited by later open-source models (the GR00T N1.6 Eagle backbone and SmolVLA's encoder choices are variants of the same logic). When building your own VLA: if your task is spatial-precision-sensitive (assembly, peg insertion), weight spatial features more heavily in the dual encoders; if it is dominated by semantic instructions (household service), the semantic side matters more.

Component three: the action head — three routes in 2026

This is the biggest fork inside a VLA, and the component you should look at first when reading a press release. The essential differences among the three routes: are actions continuous or discrete, how many steps are sampled at once, and can force-control precision be preserved.
RouteRepresentative modelsHow actions are producedStrengthsStructural weakness
Discrete tokensRT-2 / OpenVLAActions discretized into 256 bins, output as a vocabularyFully reuses the LM training stack; open-source community baselineSlow at high-frequency control; quantization hurts force-control precision
Flow matchingπ0 / RDT-1B / CogACTContinuously integrates an action-vector flow from a noise field5-step sampling, stable training, native continuous controlNot compatible with the LM's next-token training stack
DiffusionDiffusion Policy familyMulti-step denoising samplingStrongest expressive power for multimodal distributionsMany steps mean high latency; distillation can compensate
The 2026 reality: flow matching is the de facto standard for new models — π0 used it to win long-horizon dexterous tasks like folding clothes, RDT-1B applies it in a dual-arm diffusion Transformer, and CogACT follows the same line. The discrete-token route survives on FAST frequency-domain compression: DCT-transform and quantize the action sequence to shorten the token sequence severalfold; OpenVLA-OFT and π0.5 both adopt it by default. Diffusion's share is being squeezed by flow matching, but Consistency Policy's single-step distillation keeps it a place in production deployment. A judgment rule for you: when reading a new model's action head, first ask 'how many sampling steps' and 'how is force-control precision preserved'. If they can't answer the latter, it's most likely straight discrete-token output — such models have a structural ceiling on contact-rich tasks (peg insertion, cap twisting) that data alone cannot fully fix.

Component four: action chunking — a slow brain, unbroken motion

The brain runs at 1–10Hz while arm joints need 100Hz+ to stay smooth; chunks bridge the gap: the model predicts the next 20–50 action steps (about 0.5–1 second) at once, the controller interpolates through that stretch, and meanwhile the brain computes the next chunk. This solves two problems at once: the model can be slow (80ms for a whole segment) and motion can be smooth (naturally smooth within a chunk). The cost is correction latency — noticing a bad grip means waiting for the current chunk to finish or cutting it short. π0 at about 80ms per chunk on a single 4090, reaching 50Hz after distillation, is the fruit of the 'chunk + distillation' combo. The more radical approach is dual systems: Helix runs cerebellum S1 at 200Hz on the robot's own GPU handling only the upper body while brain S2 emits a single intent vector — extremely low intermediate bandwidth but semantically complete. Both are two implementations of the same principle: decouple 'thinking' from 'acting', passing only narrow-bandwidth high-level signals between them.

Treat the four components as an X-ray for reading models

How to use this page

For any VLA press release, fill in four blanks: what/how large is the backbone, single or dual visual encoders, which action-head route with how many sampling steps, and how long the chunk is.

Can't fill them in = the piece is selling a vision without technical specifications; stay skeptical first.

Once all four are filled, go to the Data Engine to see what data recipe it used — most real performance gaps in 2026 live there.

Three common misreadings

'Big parameters = strong': the brain layer has a latency budget, so anything above 7B is out on-device; more than one evaluation shows a 0.9B model matching a 7B one.

'End-to-end = no hierarchy': even architecturally end-to-end models still rely on chunks and controllers for hierarchical execution — the debate is about the training paradigm, not the runtime structure.

'Flow matching won so discrete tokens are useless': the open-source community baseline and FAST-compressed OFT remain the smoothest starting points in the fine-tuning ecosystem; toolchain maturity is also a selection variable.

Sourcing: architecture conclusions come from each model's public papers and repos (OpenVLA, openpi, RDT-1B, SmolVLA, the Helix blog); 'flow matching as the standard' and 'FAST as the default' are summary judgments on the open-source model family as of 2026-11 — for each model, defer to its repo.

Next · Data EngineData Engine: the real bottleneck of VLAs

All 6 teardown pages

01The model survey 02Taking a VLA Apart25 min03Data Engine: the real bottleneck of VLAs25 min04Post-training: from base model to your robot20 min05Deployment and Inference: landing a 1–10Hz brain20 min06Evaluation Truth: between 90% and 15%20 min