ACT vs SmolVLA: specialist against generalist on the same card

Same tier, opposite philosophies

Both run on the 24 GB tier, both are estimated at two to five hours, both land at roughly 1 to 3 USD, both read LeRobot v2.1. Take cost off the table and what remains is a real architectural disagreement. ACT learns your task and only your task, starting from nothing. SmolVLA arrives already knowing something about images, language and manipulation, and spends its budget adapting that to you. Neither is better in general; they fail in different directions, and the direction yours will fail in is knowable before you spend anything.

Side by side

Two schedules that look nothing alike

Read the defaults as descriptions of what each model is doing. ACT runs 100 000 optimizer steps at 1e-5 with a batch of 8 and no accumulation: a from-scratch schedule, because the network starts with no useful representation and needs many small, cautious updates before anything coherent exists. SmolVLA runs 20 000 steps at 1e-4 with an effective batch of 16. Ten times the learning rate over a fifth of the steps is the signature of adaptation.

ACT      batch 8 x accum 1 = effective 8   x 100 000 steps = ~800 000 sample views
SmolVLA  batch 2 x accum 8 = effective 16  x  20 000 steps = ~320 000 sample views

ACT extra knobs      chunkSize 100, nActionSteps 100, seed, logFreq
SmolVLA extra knobs  seed, logFreq

Both estimated at 2 to 5 hours on the 24 GB tier: ACT takes far more
steps, but each step is much smaller.

The consequence is that ACT is far more sensitive to how much data you have and how consistent it is. Every pattern it knows came from your episodes. SmolVLA can lean on what it already had when your data runs out, which is why its useful threshold sits twenty episodes lower.

The 20 ms figure is both bigger and smaller than it looks

Twenty milliseconds against 245 is roughly a factor of twelve. At 245 ms the arm gets about four action steps a second; at 20 ms the servos and cameras become the limiting parts of the system rather than the policy.

The nuance is that ACT is the only model whose chunking is exposed to you. chunkSize and nActionSteps both default to 100, so the policy predicts a block of actions and executes a block between inferences. Much of what people describe as ACT feeling fluid comes from that commitment rather than from raw speed. The same commitment is why it looks stubborn when the scene changes mid-chunk: it is executing a plan that was correct when it was made. Lower nActionSteps to make it reconsider more often.

Language conditioning is structural, not a feature bullet

ACT has no text input. There is nowhere to put a task string, so one checkpoint means one behavior. Two tasks means two datasets, two runs, two checkpoints, and something in your setup deciding which to load. That is workable for a fixed cell and quietly awkward for anything else.

SmolVLA attends to the string recorded with each episode. One dataset holding "put the red cube in the bowl" and "put the blue cube in the bowl" can produce one policy that does both, provided you wrote those strings consistently. This is where recording discipline turns into a capability, and where a dataset full of labels like "test 4" throws it away.

Pick ACT if

• You are building a fixed cell: bolted camera, one part, one motion, the same cycle repeated, and you will never ask the policy to do anything else.
• You have fifty or more clean episodes of exactly one task from the same viewpoint. ACT converts consistency into performance better than it converts volume into performance.
• You need to run a real ablation. seed, chunkSize and nActionSteps are all exposed, so you can change one variable at a time and defend the comparison.

Pick SmolVLA if

• You have around thirty episodes and do not yet know whether the dataset is any good. SmolVLA is useful twenty episodes earlier, which is exactly where a first dataset lives.
• Your dataset holds two or three related tasks with distinct strings. One checkpoint serving all of them beats three checkpoints and a loader.
• You expect placements, lighting or objects the demonstrations did not cover. Pretraining carries a policy across that gap and ACT has none to lean on.

What the model you did not pick still does better

ACT, if you went with SmolVLA

Latency and control. Twenty milliseconds with a tunable action horizon is not something SmolVLA approaches, and on a task that runs all day, cycle time compounds. ACT is also the most transparent model here: with no pretraining, anything the policy does came from an episode you recorded and can go watch.

SmolVLA, if you went with ACT

Everything to do with variation. It starts working on a smaller dataset, it takes a language input, and its pretraining gives it something to fall back on when the scene drifts. It also finishes in 20 000 steps rather than 100 000, so a failed experiment costs less waiting even at a similar price.

Decide it with one run

1. 1
   Count your task strings

   Open the dataset and see how many distinct strings it holds. More than one is already an argument for SmolVLA, because ACT cannot read them.

2. 2
   Count your usable episodes

   Kept episodes, not recorded ones. Under fifty, ACT is below its threshold and the choice is made for you.

3. 3
   Train the one the counts point to, at its defaults

   Pick the dataset in Training, select the model, leave the recipe alone. Both expose a seed, so set one and note it beside the job id.

4. 4
   Evaluate twenty attempts, half of them off-nominal

   Ten from placements you demonstrated, ten from placements you did not. That split separates a data problem from a generalization gap.

5. 5
   Only switch models if the split says to

   Strong on demonstrated placements and weak on new ones: move to SmolVLA. Weak on both: record better data, because the model is not the bottleneck.

policy: act, job 4c1e88, checkpoint step 90000, seed 42
date: 2026-08-09   arm: SO-100   lighting: ceiling, blinds closed

demonstrated placements   x x x x . x x x x x    9 / 10
new placements            . . x . . x . . . .    2 / 10

reading: not a data problem. The gap is generalization, so the next
run is SmolVLA on the same dataset id, not more of the same episodes.

Changing your mind is a form field

Both models read LeRobot v2.1, both run on the same tier, both start from the same upload. Retraining under the other one is a new job against the dataset you already have, at the same 1 to 3 USD, with no re-recording and no conversion. The episodes are the asset; the checkpoint is a rented result. That is also why this page is not worth agonizing over: the wrong choice costs one run.

Where to go next

• /policies/act: chunk parameters, seed, and the from-scratch schedule
• /policies/smolvla: the pretrained alternative on the same card
• /train/act-on-so-100: ACT end to end on the reference arm
• /train/smolvla-on-so-100: the pretrained route on that arm
• /so-100/imitation-learning for what these policies are actually learning

Frequently asked questions