Where you are. You can draw three frontier VLAs from a blank page. Every one of them wants hardware you do not have on your desk. This lesson is the exception, and it is the model the rest of this module runs on.
A model trained in other people’s spare rooms
Somebody recorded forty episodes of a cheap arm dropping a wooden block into a cup and pushed the recording to a public hub. It is not a clean dataset. The light is a desk lamp. The camera is a webcam clamped to a monitor. The gripper misses twice.
There are 480 more datasets like it, from 480 more spare rooms. Together they are 22,900 episodes and 10.6 million frames of mostly cheap arms doing small domestic things imperfectly.
That pile is the pretraining corpus for the only model in this module whose entire loop closes on hardware you already own: download the checkpoint, fine-tune on your own episodes, run it on your arm. And on real robot tasks its authors report that having seen the pile is worth 26.6 percentage points of success rate over not having seen it.
The idea in one paragraph
SmolVLA is the same skeleton as everything else in this module, built an order of magnitude smaller on purpose. A 450-million-parameter model: a small pretrained vision-language backbone, a flow-matching action expert of roughly 100M parameters, and three deliberate cuts that trade capacity for a memory budget a consumer GPU can hold. It is not the strongest model here and does not claim to be. It is the one where you personally can run every step, which changes what you are able to learn from it - you can ablate it, break it, and measure it, and none of that is available to you on a model you can only read about.
Wider than the screen; scroll it sideways.
Several of the numbers in that figure are not quoted from a launch post. They were read out of the checkpoint’s own config.json on 9 August 2026. Which ones, and how to check them for yourself, is the exercise at the end.
What it is made of
The backbone is SmolVLM2-500M-Video-Instruct: a SigLIP-style vision encoder feeding a SmolLM2 language decoder. It is Apache-2.0 and about 507M parameters in its own right, which is already an odd fact worth pausing on - the finished robot policy is smaller than the vision-language model it started from, because SmolVLA does not run all of it.
The action head is an action expert: a separate transformer trained with flow matching, roughly 100M parameters, emitting a chunk of 50 future actions. Its hidden width is 720, exactly 75% of the backbone’s 960.
Three cuts, and what each one buys
Wider than the screen; scroll it sideways.
64 visual tokens per frame instead of roughly 1024. Images dominate the token count in any VLA, and attention cost grows quadratically in sequence length. Cutting visual tokens by a factor of sixteen is the single largest saving in the model.
Sixteen of the language decoder’s thirty-two layers. SmolVLA does not run the whole backbone. It takes the features available half way up and stops. The bet is that the representation you need for “which object is the blue one” is fully formed well before the last layer, and only the layers doing fine linguistic work get skipped.
An action expert 75% as wide as the backbone. A narrower residual stream through the part that has to run every control cycle.
What the checkpoint says about itself
Every architectural claim above is checkable in about ninety seconds, because the checkpoint ships a config.json and that file is the artifact rather than the description of it. Here is what it held on 9 August 2026.
config.json key | Value | What it means |
|---|---|---|
vlm_model_name | HuggingFaceTB/SmolVLM2-500M-Video-Instruct | which backbone, exactly, with no ambiguity about the variant |
num_vlm_layers | 16 | half of the decoder’s 32 layers run |
expert_width_multiplier | 0.75 | expert hidden width 720 against the backbone’s 960 |
self_attn_every_n_layers | 2 | the expert alternates cross-attention with self-attention |
chunk_size | 50 | actions emitted per forward pass |
num_steps | 10 | flow-matching integration steps at inference |
license | None | nobody has stated one |
Two of those rows are worth dwelling on. The num_vlm_layers and expert_width_multiplier entries are the second and third cuts, stated by the model rather than by anybody’s prose, including this lesson’s; if the figure above ever disagrees with them, the figure is stale and the file is right. And the last row is an empty field where a licence should be, which the section on evidence below comes back to.
The weights answer one more question. Summing the shapes in model.safetensors gives 450,046,176 parameters. The model card rounds it to 0.5B and the paper says 450M; the file says 450,046,176, and only one of those three is a measurement.
What it costs you
Where SmolVLA sits against the models you have just spent four lessons reading about, as of August 2026.
| Model | Inference | Fine-tuning |
|---|---|---|
| SmolVLA 450M | CPU or a laptop, per its authors | one consumer GPU; users report success on an RTX 3090 |
| π₀ / π₀.₅, about 3B | more than 8 GB, so an RTX 4090 | LoRA needs more than 22.5 GB; a full fine-tune needs more than 70 GB |
| OpenVLA 7B | 16 GB in bf16 | roughly 24 GB with LoRA; multi-GPU for a full run |
| GR00T N1.7 3B | 16 GB and up, including a Jetson | 40 GB and up recommended |
Wider than the screen; scroll it sideways.
The line to draw is at 24 GB, and SmolVLA is the only row that sits comfortably below it in both columns. That is the entire practical argument for building this module’s hands-on work on it: not that it is the best model, but that it is the one where you personally get to run the experiment rather than read about somebody else’s.
Wall-clock, with the caveat that these are reported figures rather than controlled measurements: about 20,000 training steps in roughly four hours on a single A100, which is a few dollars rented or a free overnight run on a card you own. If VRAM is tight the levers are gradient checkpointing, a batch size as small as 4, and bf16. Measure your own; the number that matters is the one your machine produces.
How much data you actually need
Fifty demonstrations per task. That is the number the authors used for their real-robot results, collected as ten trajectories from each of five starting positions, and it is the number to design your own experiment around.
On the arm from Module 4 that is a thirty to sixty minute teleoperation session for a simple pick-and-place. It is genuinely small, and the reason it can be small is the pretraining: without the community-dataset pretraining their real-robot success was 51.7%, and with it 78.3%. That 26.6-point gap is the cleanest published evidence in this field that pretraining on other people’s cheap arms transfers to yours. It is also, unavoidably, the authors measuring their own contribution, which the next section is about.
The scoreboard, and who wrote it
| Benchmark | SmolVLA 0.45B | π₀ 3.5B | OpenVLA 7B | ACT 0.08B |
|---|---|---|---|---|
| LIBERO, average | 87.3% | 86.0% | 76.5% | not reported |
| Meta-World, average | 57.3% | 47.9% | not reported | not reported |
| Real arm, 3 tasks, 50 demos each | 78.3% | 61.7% | not reported | 48.3% |
Every number in that table comes from the SmolVLA authors, and so does the “3.5B” label on π₀ - Physical Intelligence’s own arithmetic gives around 3.3B for the same model, which is a reminder that even a parameter count is a claim by somebody. None of the cells carries a trial count, which means none of them is a measurement you can put an error bar on. Read it as the authors’ claim, which is what it is.
Check yourself
1. SmolVLA is 450M parameters, but the vision-language model it is built on is about 507M on its own. How is the finished policy smaller than its own backbone?
Because it does not run all of the backbone. SmolVLA uses 16 of the language decoder’s 32 layers and throws away the rest, so a large fraction of the pretrained weights is never loaded into the policy. Add the roughly 100M-parameter action expert to the half of the backbone that remains and you land near 450M. This is worth internalising: “backbone size” and “policy size” are different quantities, and a model card that quotes one is not telling you the other.
2. Which of the three efficiency cuts would you expect to save the most, and why?
The visual token cut, from roughly 1024 tokens per frame to 64. Attention cost grows quadratically in sequence length and images supply almost all of the tokens in a VLA, so a sixteen-fold reduction there dominates a halving of layer count or a 25% narrowing of one module. It is also the cut with the most obvious failure mode: 64 tokens is a coarse view, and fine visual discrimination is exactly what you would expect to lose first.
3. The config lists chunk_size 50 and num_steps 10. Both are counts of steps. What is the difference?
They live in different kinds of time. chunk_size is 50 future actions, emitted by one forward pass and consumed by the controller over real wall-clock seconds; it sets how far ahead the robot has committed and therefore how long it can be surprised without noticing. num_steps is 10 integration steps of the flow-matching solver inside a single forward pass, taken in the model’s own internal time and invisible from outside; it sets what one prediction costs in latency. Raising num_steps buys sample quality and costs you milliseconds. Raising chunk_size buys smoothness and costs you reactivity. Confusing the two is the same category error as reading π₀’s 50-step chunk as 50 Hz.
4. The authors report 78.3% on a real arm against a from-scratch ACT’s 48.3%. An independent lab on the same class of arm reports 32.5% and 33.75%. Both are honest. What do you conclude?
That the difference between the two setups matters more than the difference between the two policies. The tasks, the demonstration quality, the operator, the camera placement and the tuning effort all differ, and any of them can move a real-robot success rate by tens of points. The defensible conclusion is narrow: a small VLA is not automatically better than a well-trained task-specific policy, and anyone who tells you the ranking without telling you whose rig it was measured on has not given you information. The only number that settles it for your robot is one you produce on your robot.
5. The SmolVLA model card has no licence field. What can you actually conclude from that?
Almost nothing, which is the useful part. The absence of a field is not permission and it is not a prohibition; it is a gap. The surrounding library is Apache-2.0 and the backbone is Apache-2.0, so the likely intent is permissive, and for personal learning the risk is negligible. For anything commercial, “likely intent” is not a licence, and the correct move is to ask the maintainers in an issue and get the answer in writing. Note also that this is exactly the failure mode from the previous lesson, running in the other direction: there, people asserted a licence the weights did not have.
6. This lesson says the model runs 16 of 32 layers. Where would you go to find out whether that is still true next year, and why not here?
To config.json in the checkpoint you are actually loading, and specifically to num_vlm_layers. Not here, because a lesson is coverage: it describes an artifact at a moment, and the artifact keeps moving while the description does not. The same applies to the parameter count, the chunk size and the number of flow-matching steps, all of which are fields in that file. The general habit is worth more than any of the numbers: prefer the artifact to the description of the artifact, and when they disagree, the artifact is not the one that is wrong.
Do this
Twenty minutes, no GPU required. You are going to read the architecture out of the checkpoint instead of out of a blog post, this lesson included.
# pip install huggingface_hub safetensors numpy
import json, math
from huggingface_hub import list_repo_files, hf_hub_download, ModelCard
from safetensors import safe_open
REPO = "lerobot/smolvla_base"
print(list_repo_files(REPO)) # look before you download
cfg = json.load(open(hf_hub_download(REPO, "config.json")))
for key in ("vlm_model_name", "num_vlm_layers", "expert_width_multiplier",
"self_attn_every_n_layers", "chunk_size", "num_steps", "license"):
print(f"{key:26} {cfg.get(key)}")
weights = hf_hub_download(REPO, "model.safetensors") # about 1 GB
with safe_open(weights, framework="numpy") as f:
total = sum(math.prod(f.get_slice(k).get_shape()) for k in f.keys())
print(f"parameters: {total:,}")
print("card licence:", ModelCard.load(REPO).data.license)Three things to write down.
The parameter count. On 9 August 2026 this printed 450,046,176. The model card says “0.5B” and the paper says 450M; only one of those is the number in the file.
The architecture. num_vlm_layers and expert_width_multiplier are the two cuts from this lesson, stated by the artifact rather than by prose. If they disagree with the figure above, the figure is out of date and the checkpoint is right.
The licence. Both cfg["license"] and the card’s licence printed None when this lesson was written. If they print something for you, the field has been filled in since, and your answer is better than mine. Either way you have now checked a licence yourself instead of repeating one, which is the habit this module is really trying to build.
Then one line on your own machine: torch.cuda.mem_get_info() for free and total VRAM in bytes, or the equivalent for your accelerator. Put that number in your notes next to the table above. It decides which half of this module you can run locally and which half you rent.
What you can now do
You can say what SmolVLA is made of - a half-used SmolVLM2-500M backbone, a 100M flow-matching action expert, 64 visual tokens per frame, a 50-step chunk - and why each of those choices exists. You can quote what it costs in VRAM and in hours, and say where the 24 GB line falls and what sits either side of it. You know that fifty demonstrations per task is the design target, that its authors report pretraining buying 26.6 points on top of it, and that an independent lab measured something less flattering. And you can read all of that out of the checkpoint yourself, including the licence field that is not there.