Where you are. The fast-slow split told you there are three places to draw the line. The four lessons since then opened up π₀ and π₀.₅, GR00T and Gemini Robotics, and Helix, one at a time. This lesson puts all of them in one skeleton so you can draw any of them from a blank page, which is the exit test for this module.
Three drawings with the labels cut off
Someone hands you three architecture sketches with the company names removed.
The first is a large box with a smaller box beside it and a note saying the two share one attention stack. One arrow leaves the pair: fifty numbers, up to fifty times a second.
The second is a large box with a stack of thirty-two identical thin slices under it. One arrow leaves the stack: motor commands, about thirty-six times a second, with a footnote naming the datacentre GPU that was measured on.
The third has three boxes rather than two, and almost the only numbers on it are rates. Roughly once a second at the top. Two hundred times a second in the middle. A thousand times a second at the bottom.
You can tell those apart in about four seconds. That is the point. They are not three unrelated inventions; they are three answers to one question, given in the same three places on the same page. Learn the page and every release you read for the rest of your career has somewhere to go.
The idea in one paragraph
Every vision-language-action model in this module is the same three-part skeleton: a backbone that already understands images and words, an action head small and fast enough to feed a control loop, and a seam between them. The designs differ in exactly three places: which pretrained model the backbone is, how actions are represented and decoded in the head, and what crosses the seam in each direction. Everything else on a launch page is data, scale and marketing. Once you can draw the skeleton, reading a new model is filling in three blanks rather than learning a new architecture.
Wider than the screen; scroll it sideways.
Backbone and head are borrowed words and you already own them. What is new is that the seam is a design decision with real consequences, not a line on a diagram.
The seam is not inevitable, and it is worth remembering that RT-2 did not have one. Actions were written in the model’s own vocabulary, so there was no interface to design and nothing to cross. Every architecture below is a retreat from that purity in exchange for speed, and the seam is the shape of the retreat.
Three questions to put to a seam
Lesson 4 showed the shapes the fast-slow split takes. Turned around, they become questions you can put to any release, in the order that gets you an answer fastest.
Do the two halves share weights? If the action head is a second set of transformer weights inside the same attention stack, you have one model with two specialisms, one file, one deployment. If it is a separate module reading a hidden state, you have two models in a trench coat and you can replace either one.
Do gradients cross back? The question almost nobody asks, and action representations is where you saw why it decides whether the model’s hold on language survives. Answering it tells you what the training recipe was protecting.
What crosses downward? Discrete tokens, a continuous hidden state, an opaque latent vector, or a sentence of English. That choice sets how much the head can know and how much a human can read in a log.
Four answers
Three of them belong in the figure below because they are the three you should be able to reproduce from memory. The fourth arrives after it, and the reason it is not in the drawing turns out to be the most useful thing about it.
Wider than the screen; scroll it sideways.
π₀.₅ puts both experts inside one transformer. A vision-language backbone of the PaliGemma family and a separate set of action-expert weights share a single self-attention stack, so it behaves like a two-expert mixture inside one model rather than two models bolted together. The expert takes proprioceptive state and noisy action tokens and produces a chunk of continuous actions by flow matching; π₀’s published expert is around 300M parameters emitting 50-step chunks at up to 50 Hz. The seam here is the strangest of the four because information crosses it freely, through attention, while the backward path is deliberately restricted. Tight in the forward pass, cut in the backward pass, on purpose.
One caveat the figure cannot hold. The π₀.₅ paper (arXiv:2504.16054) reaches that separation with two training stages and an attention mask keeping the discrete and continuous action representations from attending to each other. The explicit stop-gradient, running both objectives in one stage, is the follow-up knowledge insulation paper (arXiv:2505.23705), which describes itself as formalising π₀.₅’s approach and extending it to a single stage. Draw the cut gradient if you are drawing knowledge insulation; draw two stages and a mask if you are drawing the π₀.₅ paper.
GR00T N1.7 keeps its two halves genuinely separate. A Cosmos-Reason2-2B vision-language model, which NVIDIA describes as reaching it via Qwen3-VL, does the understanding and hands a hidden state down to a 16-layer diffusion transformer trained with flow matching, which emits motor commands. Three billion parameters end to end. At inference it runs four integration steps on a single camera view, which NVIDIA measures at 35.9 Hz on an H100 80GB with TensorRT - and at 2.9 Hz on a Jetson Orin in eager PyTorch. Because the two halves are distinct modules, the embodiment configuration is a swappable part, which is exactly why this is the design that ships with fine-tuning scripts for other people’s robots.
The layer count is the trap. N1.6’s head had 32 layers and N1.7’s has 16, per NVIDIA’s own repository, and almost every diagram in circulation still says 32. Version-stale numbers survive precisely because they were once correct.
Helix 02 adds a tier below the tier. System 2 does slow semantic reasoning and emits a latent goal. System 1 is a 200 Hz visuomotor transformer consuming head and palm cameras, tactile and proprioception, and emitting full-body motor commands. New in this version is System 0: a 10M-parameter whole-body controller running at 1 kHz, trained in simulation across more than 200,000 parallel environments on over 1,000 hours of joint-level retargeted human motion. Where the other two designs stop and hand off to the robot’s stock joint controllers, Figure learned that layer too.
Gemini Robotics makes the seam a sentence, and it is the design left out of the figure. Because its two halves are separate models rather than two parts of one, they can be shipped separately, and as of August 2026 they have been: the embodied-reasoning half is callable through Google AI Studio and a private enterprise preview, while the VLA half and the on-device model go only to trusted testers. A loose seam is a product boundary as well as an architectural one, and it turns out to be the line a vendor cuts along when deciding what to release. Which is also why it is not in the drawing - you cannot fill in a skeleton for a model nobody outside the trusted-tester list has run.
The seam is a clock boundary
Lesson 4 argued that the deadlines belong to the world rather than to the designer. Here are the three designs measured against those deadlines, on one axis, which is a thing no vendor page will ever draw for you.
Wider than the screen; scroll it sideways.
Balance needs a decision every millisecond. Grasping needs one every few milliseconds. Deciding that the blue mug is the one being asked for does not, and could not be done that fast anyway. Helix’s three tiers make this legible because the rates are the labels. The other designs have the same three clock domains; they just do not own the bottom one, because a table-mounted arm’s servo loop came with the hardware.
What you can actually download
The architecture tells you how a model works. The licence tells you whether you are allowed to use it, and those two facts are published in different places by different people.
| Design | Backbone | Action head | What crosses the seam | Artifacts, August 2026 |
|---|---|---|---|---|
| π₀.₅ | PaliGemma-class VLM | action expert, flow matching | shared attention; backward path restricted (mask in π₀.₅, stop-gradient under knowledge insulation) | weights downloadable via openpi; code Apache-2.0, no separate weights licence found |
| GR00T N1.7 | Cosmos-Reason2-2B | 16-layer diffusion transformer, flow matching | a hidden state | weights downloadable; code Apache-2.0, weights under NVIDIA’s own model licence |
| Gemini Robotics 2 | a separate reasoning model | a separate VLA | natural language | reasoning model via API and private preview; the VLA is Trusted Tester only |
| Helix 02 | System 2 | System 1, plus a learned System 0 | a latent goal vector | nothing. A blog post with videos |
The diagram is not the reason it works
One honest caveat before you go and rank these.
You now have a mental model precise enough to explain each design, and it will tempt you into believing the architecture explains the performance. It mostly does not. π₀.₅ and GR00T are close cousins - a pretrained VLM feeding a continuous action head - and the visible differences between them at deployment come far more from what they were trained on than from whether the denoiser shares an attention stack. NVIDIA’s repository states that N1.7 was pretrained on 20K hours of egocentric human video, none of it released. Physical Intelligence’s data mixture is not public either. The parts you can draw are the parts they published; the parts that decide the numbers are the parts they did not.
Check yourself
1. Name the three things that vary between VLA designs, and the one thing that does not.
What varies: which pretrained model the backbone is, how the action head represents and decodes actions, and what crosses the seam in each direction. What does not vary is the skeleton itself - sensors and an instruction into a big slow backbone, a seam, a small fast action head, out to a chunk of future actions consumed by a controller. Every model in this module fits it, including ones released after this lesson was written.
2. Which design has a seam that is tight in the forward direction and restricted in the backward direction, and what does that combination buy?
The π-family, most explicitly under knowledge insulation. Information crosses freely because the backbone and the action expert share one self-attention stack, so the expert sees everything the backbone computed. The expert’s gradients are kept from travelling back into the backbone - by an explicit stop-gradient in the knowledge-insulation recipe, and by staging plus an attention mask in the π₀.₅ paper itself - because a freshly initialised expert emits noise and that noise would degrade semantic representations that cost an enormous pretraining run to build. The combination buys a fast continuous decoder at inference without paying for it in lost language ability. Note that “how tightly coupled is this” has two answers depending on which direction you ask about, which is why the seam is worth two questions rather than one.
3. Helix has three tiers where π₀.₅ and GR00T have two. Is that an extra idea, or the same idea drawn more completely?
Mostly the same idea drawn more completely. Every one of these systems has a kilohertz-class control layer; on a table-mounted arm it is the servo loop that came in the box, so it does not appear on the vendor’s diagram. Figure builds humanoids, where whole-body balance is not a solved off-the-shelf component, so it had to learn that layer and therefore had to draw it. The genuinely new part is that the bottom tier is a learned 10M-parameter network trained in simulation rather than a hand-written controller.
4. A new model claims 50 Hz control with an action chunk of 100 steps. How long is it committed to a plan, and why does that matter?
Two seconds, from . It matters because that is how long the world has to change without the model noticing. A longer chunk smooths execution and reduces compounding error, and it also means a slower reaction when someone moves the target object at the one-second mark. Chunk length and control rate are independent knobs and quoting one without the other tells you almost nothing.
5. Two write-ups say GR00T N1.7 is Apache-2.0. Is that right?
Half right, in the half that matters least. The Isaac-GR00T repository carries Apache-2.0 for the code. The weights are released under NVIDIA’s own Open Model License Agreement, which permits commercial use but is a bespoke NVIDIA document rather than an OSI-approved licence. Model cards and repository licences are separate artifacts and routinely differ; the model card is the one that governs the file you are about to fine-tune.
6. Which of these four designs would you expect to be easiest to adapt to a robot its authors never used, and why?
GR00T, because its seam is the loosest. Backbone and action head are separate modules communicating through a hidden state, so the embodiment-specific parts are configuration rather than surgery, and NVIDIA ships embodiment configs and fine-tuning scripts for exactly that reason. Gemini’s two-model split is looser still in principle, but you cannot test that claim because the VLA is not released - which is its own lesson about what “modular” means when you have no access.
Do this
1. Draw them from memory. Blank page, ten minutes, no scrolling back. Three columns, and in each one: inputs, backbone, seam, action head, output rate, bottom tier. Then check against the figure above and mark only what you missed. The three most commonly missed items are the restricted backward path in π₀.₅, the four integration steps in GR00T, and the existence of System 0 at all.
2. Fill the skeleton for a model this lesson did not cover. Start notes/05-skeletons.md with one section per model and four lines each: backbone, action head, seam, artifacts and licence. Fill it in for Wall-OSS-0.5, a 4B open model from X Square Robot built on a 3B Qwen2.5-VL backbone. Everything you need is in its repository and model card - including the release date, which I did not pin down and you should. The exercise is not the answer, it is finding out how long it takes you to get it. Under fifteen minutes means the skeleton is doing its job.
3. Check the chunk arithmetic yourself, because the 50-and-50 coincidence is a trap you will meet again.
H = 50 # actions emitted per forward pass
for rate in (10.0, 30.0, 50.0, 200.0):
print(f"{rate:6.0f} Hz -> {H / rate * 1000:6.0f} ms of committed future")Run it, then answer one question in writing: at which of those rates would you be comfortable with a human hand entering the workspace, and why? There is no clean answer, which is the point. That number is a latency budget for surprise.
What you can now do
You can draw π₀.₅, GR00T N1.7 and Helix 02 from a blank page, in one shared skeleton, and say for each one what the backbone is, how the action head represents actions, and what crosses the seam in both directions. You can place their blocks on a rate axis and explain why the seam is a clock boundary rather than a stylistic choice. You can separate the chunk length from the control rate. And you can tell, from a model card rather than a headline, whether the weights in front of you are downloadable and under what licence.