GR00T N1.7 vs SmolVLA: an 80 GB card against a 24 GB one

The short answer

GR00T N1.7 is the stronger model and SmolVLA is the cheaper one, and if that were the whole story this page would not exist. What makes it interesting is that the strength of the big model is generalization from pretraining, and generalization is the one thing a small dataset cannot show you. So the right order is almost always the cheap run first, with the expensive one held back until a result justifies it. There is also a second axis people get backwards, covered below: the three billion parameter model is the faster one at inference.

Side by side

What the two tiers actually cost

GPUs are rented by the hour on a spot market and the pool selects them by VRAM rather than by GPU name. Absolute prices move day to day. The ratio between the tiers barely does, and the ratio is what you plan around.

24 GB tier (SmolVLA)    2 to 5 hours  x  0.30 to 0.60 USD/h  ->  about 1 to 3 USD
80 GB tier (GR00T N1.7) 3 to 6 hours  x  1.20 to 2.00 USD/h  ->  about 4 to 12 USD

Four SmolVLA runs fit inside the price of one GR00T run.

That ratio is the whole argument. The first useful thing you learn from a dataset is almost never learned on the first run. You record, you train, you evaluate twenty attempts, you notice most failures happen when the object starts on the left, you record twenty more episodes with the object on the left, and you train again. Three or four rounds of that on the 24 GB tier cost less than one round on the 80 GB tier.

The bigger model is the faster one at runtime

SmolVLA is about 450 million parameters at about 245 ms per action step. GR00T N1.7 is about three billion at about 152 ms. The small model is the slow one, because these figures are measured where each model actually runs: GR00T on the 80 GB tier, SmolVLA on the 24 GB tier. You are comparing a model together with the card it was given. Choosing the small model does not buy a faster policy. It buys a cheaper run, a lower episode threshold, and the option of inference on hardware you own, which GR00T does not offer at all.

Dataset size is the deciding variable

Fine-tuning GR00T adjusts roughly forty million parameters on top of a prior about how arms and objects behave. A prior needs enough task-specific data to be anchored to your task, and it only pays off when the policy meets situations your demonstrations did not contain. Both conditions scale with episode count.

Pick SmolVLA if

• This is your first dataset for the task. Thirty to fifty episodes, some doubt about whether the camera framing survived the session, and you want a verdict today rather than a bill.
• You are iterating weekly. The rounds you can afford are the rounds you get, and on the 24 GB tier that number is roughly four times larger.
• You want the trained policy on hardware you own. SmolVLA is not cloud-only and fits a 24 GB card. GR00T is cloud-only, full stop.

Pick GR00T N1.7 if

• SmolVLA works and then stopped improving. You added fifty more good episodes and the success rate did not move. A ceiling is the one situation where a bigger model is a real answer.
• The task needs fine positioning. SmolVLA’s documented limit is exactly that: a lower ceiling than the three billion parameter models when the gripper has to land within a few millimeters.
• You want language conditioning at the lowest latency available. Both attend to the task string, but 152 ms against 245 ms is visible on a fast cycle.

What SmolVLA still does better

It is seedable. SmolVLA exposes seed and logFreq; GR00T exposes neither. If you need two runs comparable in any stronger sense than "same settings in the form", only the cheap one can give you that.

It is also the better regression check after you upgrade. Once GR00T is your production policy, the question you ask most often is whether this week’s episodes are consistent with last week’s, and a couple of dollars answers it on the same dataset id. And it starts working thirty episodes earlier, which for anyone recording by hand is an evening saved rather than a rounding error.

The cheap path to the right answer

1. 1
   Record thirty episodes and stop

   Vary object placement across the area you want covered, keep the task string identical, and discard failed attempts rather than keeping them for volume.

2. 2
   Train SmolVLA at its defaults

   Open Training, pick the dataset, choose SmolVLA, leave batch 2, accumulation 8, 1e-4 and 20 000 steps as they are. Set a seed so the run can be repeated.

3. 3
   Evaluate twenty attempts on the arm

   Same placements each time, results written down as they happen. Twenty attempts, not the three that went well.

4. 4
   Classify the failures

   Confidently wrong location means data or a moved camera. Correct location with a fumbled grasp means precision. Success only where you demonstrated means a generalization limit.

5. 5
   Only the last two justify the 80 GB tier

   If that is what you see, record up to fifty or more episodes and start GR00T against the same dataset id. If it is a data problem, more model will not help.

curl -s https://www.ay-robots.com/api/mcp \
  -H "Authorization: Bearer $AY_ROBOTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{
        "name":"start_training",
        "arguments":{
          "dataset_id":"ds_7f31c0a4",
          "policy_name":"cube pick, smolvla baseline",
          "model_id":"smolvla",
          "max_steps":20000,
          "confirm_spend":true}}}'

# "model_id":"groot1.7" sends the identical dataset to the 80 GB tier.
# Nothing about the upload changes, only the hourly rate.

Switching later is one more job on the same dataset

Your upload is the expensive part of this workflow, measured in your own time rather than in dollars. Both models read LeRobot v2.1, so the dataset id you pass to the second job is the string you passed to the first, and no episode is re-recorded. A checkpoint is disposable by design. Choose the model that answers your current question, not the one you expect to be using in six months.

Where to go next

• /policies/smolvla: defaults, strengths and the documented ceiling
• /policies/groot-n1-7: what the 80 GB tier buys and what it demands
• /train/smolvla-on-so-100: recording through to a running policy on a 24 GB card
• /train/groot-n1-7-on-so-100: the same route on the 80 GB tier
• /learn/record-your-first-dataset if the thirty episodes do not exist yet

Frequently asked questions