GR00T N1.7: what it is and how to fine-tune it on a low-cost arm

What a vision-language-action model is

A vision-language-action model, VLA for short, takes two inputs on every step: the camera images from your robot and one sentence describing the task. It returns the next joint targets. No perception module to configure, no grasp planner, no state machine. The mapping from pixels and words to motion is learned end to end.

The foundation model part is what separates N1.7 from ACT. ACT starts from random weights and learns your task from your episodes alone. N1.7 arrives pretrained on a large multi-robot corpus, so it already has a working notion of what a gripper is and what an object on a table looks like. Your episodes teach it your arm, your camera angles and your task, not the physical world.

The frozen backbone and the small trained head

The checkpoint holds about 3 billion parameters and fine-tuning does not touch most of them. The backbone that encodes images and language stays frozen. Training updates the action head and the adapters feeding it, roughly 40 million parameters, a little over one percent of the model.

Two things follow. A bad run cannot damage the pretrained understanding, because those weights are never written: you get a head that does the wrong thing, not a broken foundation model. And memory during training is dominated by activations rather than optimizer state, since only the trained slice needs gradient and momentum buffers. That is why batch size 32 fits at all.

Why pretraining shows up as generalization

A policy trained from scratch learns the positions you demonstrated. Put the cube ten centimeters left of anywhere it ever sat during recording and it has no basis for an answer, so it produces roughly the average of the nearest demonstrations, which is a confident miss.

A pretrained backbone changes what counts as nearby. It has seen objects at many positions, on many surfaces, through many camera angles, so a placement your dataset never contained still lands somewhere sensible in its representation. The head only has to map that onto your arm, which it can do for positions it never saw, because recognizing the situation was solved before your data arrived. That is the argument for paying A100 rates instead of training ACT on a 24 GB card.

What fine-tuning on 50 episodes actually changes

Fifty clean episodes is the practical floor. People expect them to teach the model manipulation; what they really teach it is your setup.

1. Your action space: joint ordering, usable ranges and gripper convention, taken from the normalization statistics of your dataset.
2. Your camera geometry. Move a camera afterwards and the policy degrades exactly as a from-scratch policy would.
3. Your task string. The sentence recorded with the episodes becomes the phrasing the policy responds to, so it has to be identical across every episode.
4. Your style: approach direction, speed, how wide the gripper opens. The model copies your habits, including the ones you would rather it did not.

What they do not change is the backbone’s picture of the visual world. That is why a fine-tuned GR00T fails differently from ACT: it usually reads the scene correctly and gets the placement or the grasp timing wrong, rather than driving decisively into empty table.

The format rule: LeRobot v2.1 only

The GR00T trainer accepts LeRobot v2.1 datasets and rejects v3.0. This has cost real users a recording session. The client writes v2.1 by default, so it only bites when someone changed the export setting or brought a dataset in from elsewhere.

{
  "codebase_version": "v2.1",
  "robot_type": "so100",
  "total_episodes": 50,
  "fps": 30,
  "features": {
    "observation.images.scene": { "dtype": "video", "shape": [480, 640, 3] },
    "observation.images.wrist": { "dtype": "video", "shape": [480, 640, 3] },
    "observation.state":        { "dtype": "float32", "shape": [6] },
    "action":                   { "dtype": "float32", "shape": [6] }
  }
}

Hardware: the 80 GB card and the batch size of 32

N1.7 requests the A100 80 GB tier. The pool rents GPUs by the hour on a spot market and selects by VRAM rather than by name, so an H100 with 80 GB satisfies the same request.

Cost follows the tier, not the model: roughly 3 to 6 hours at 1.20 to 2.00 USD per hour, so about 4 to 12 USD per run, with the spread coming from the spot market. The same pool rents the 24 GB tier that SmolVLA and ACT use for a fraction of that.

The missing seed, and what it costs you

ACT, SmolVLA and Pi0.5 run through the lerobot trainer and show a seed field in the form. GR00T does not use that trainer, and its fine-tuning entry point takes no seed at all. There is nothing to set and nothing to go looking for.

So two runs on the same dataset with the same hyperparameters will not produce the same weights: data order, augmentation draws and head initialization come from an unseeded generator. The policies usually behave similarly on the arm, but small differences between them mean nothing.

• Do not attribute a few points of success rate to a hyperparameter change measured with one run each.
• Do not delete a checkpoint you might want back. You cannot regenerate it, which is what saveSteps protects you from.
• Keep the run configuration with the result. The job page records dataset, model, steps and hyperparameters, and that record is your reproducibility story here.
• If bit-exact reproducibility matters more than the last few points of success rate, an ablation table in a thesis for instance, Pi0.5 is the model that exposes a seed.

Starting a run

None of this needs a Python environment. The client at /download ships the driver, records episodes and uploads them; training runs in the browser or through the MCP server. If you have no arm yet, /live is a real SO-100 you can drive in the browser without signing up.

1. 1
   Open Training and pick the dataset

   Check the version badge while you are there. A dataset still processing has no repository id yet and cannot be selected.

2. 2
   Select GR00T N1.7

   The form fills in batch size 32, learning rate 1e-4, 20 000 steps and gradient accumulation 1. The only extra field is saveSteps.

3. 3
   Leave the defaults alone on the first run

   Changing three things at once on a model with no seed produces a result you cannot interpret.

4. 4
   Press Start and confirm the spend

   The run rents a GPU by the hour and bills the account, so the confirmation is deliberate. An A100 started by accident is an expensive accident.

5. 5
   Watch the loss curve, then stop watching it

   Loss falling then flattening is normal and says nothing about success rate. /learn/train-your-first-policy covers reading it without fooling yourself.

6. 6
   Evaluate two or three checkpoints on the arm

   The final one is not automatically the best. Compare the last few against identical scene resets.

curl -X POST 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_8f21c4",
        "policy_name": "so100-red-cube-groot17",
        "model_id": "groot1.7",
        "max_steps": 20000,
        "confirm_spend": true
      }
    }
  }'

The arm-specific version, with the camera layout and calibration that match these defaults, is at /train/groot-n1-7-on-so-100.

How it compares to Pi0.5, SmolVLA and ACT

The two comparisons worth reading in full are /compare/groot-n1-7-vs-pi0-5, which comes down to latency against precision on contact, and /compare/groot-n1-7-vs-smolvla, which comes down to how much GPU you pay for before you trust your data. ACT is the outlier: at about 20 ms per step it is roughly seven times quicker per decision, and on one rigidly defined task it is hard to beat.

What success rate should you expect

No honest version of that answer is a single number. It depends on the task, the camera placement, how consistent your demonstrations are and how far your evaluation positions sit from the demonstrated ones. A percentage quoted for GR00T on the SO-100 describes somebody else’s tabletop.

What transfers is the procedure. Twenty attempts, positions drawn from the range you care about, successes written down as they happen. That protocol is in /learn/run-your-first-policy, and the value of the number is not its size, it is that two runs can be compared with it.

Qualitatively, expect this shape. Near the middle of your demonstrated range a fine-tuned N1.7 and a well-trained ACT often look about the same, and ACT looks smoother because it is quicker per step. The gap opens at the edges: placements you never demonstrated, different light, the object rotated another way. An evaluation that always resets the scene identically cannot show the thing you paid the A100 for.

When not to pick GR00T N1.7

• Fewer than 50 clean episodes. You would be paying A100 rates to fit a head on data that cannot support it.
• You have not established that the dataset is any good. A SmolVLA or ACT run on the 24 GB tier answers that for a couple of dollars.
• The task needs fast, continuous motion. About 152 ms per step is the quickest of the VLAs here and still around seven times slower per decision than ACT.
• You need bit-exact reproducibility. There is no seed, so identical settings do not give identical weights.
• Your data only exists as LeRobot v3.0 and re-exporting is not an option.
• You want to train on hardware you own. No consumer card has 80 GB, and shrinking the batch to fit 24 GB is not a path the platform offers.

Frequently asked questions