AY-ROBOTSAI Teleoperation
Sign Up

NVIDIA Isaac GR00T N1.7

NVIDIA, United States · April 2026

Reasoning VLAOpen weights, NVIDIA Open ModelAlso written GR00T N1.7, GR00T-N1.7-3B, Isaac GR00T N1.7Trainable on AY-Robots
Parameters
3.1 B
3,144,016,000 parameters according to total_parameters in model.safetensors.index.json of nvidia/GR00T-N1.7-3B, with a...
GPU memory
16 GB
reported by the authors
Inference latency
27.9 ms
H100 80GB HBM3 with the full TensorRT pipeline, 4 denoising steps, single camera: 27.9 ms end to end (35.9 Hz), split as 6.2...
Weights
NVIDIA Open Model
NVIDIA Open Model License Agreement for the weights, Apache-2.0 for the code.

What it is

GR00T N1.7 is the first GR00T that a company can legally ship, and it is also the best instrumented. The backbone moves to Cosmos-Reason2-2B on a Qwen3-VL base, the action horizon grows from 16 to 40, state and action dimensions expand from 29 to 132, and pre-training adds roughly 20,000 hours of EgoScale human egocentric video. NVIDIA publishes a nine-platform latency table (27.9 ms on an H100 with TensorRT, 93.8 ms on a Jetson AGX Thor) and hard VRAM minimums of 16 GB for inference and 40 GB for fine-tuning. Two things deserve scrutiny before adopting it. The LIBERO table on the N1.7 branch is identical to N1.6's and looks carried over rather than re-measured, and several SimplerEnv tasks regressed sharply against N1.6 even though the averages improved.

Architecture

Backbone
nvidia/Cosmos-Reason2-2B, built on the Qwen3-VL architecture, replacing the vendored Eagle backbone of N1.6. Supports flexible resolution and encodes images in their native aspect ratio without padding. The backbone is a gated Hugging Face repository, so access must be requested before any checkpoint will load.
Action head
flow matching diffusion transformer (32-layer DiT) with adaptive layer normalisation, 4 denoising steps at inference. Actions are encoded and velocity predictions decoded by an MLP, one per unique embodiment. Action space is a relative end-effector representation shared across robot and human embodiments.
Action chunk
40 steps per forward pass
Parameters
3,144,016,000 parameters according to total_parameters in model.safetensors.index.json of nvidia/GR00T-N1.7-3B, with a total_size of 6,910,361,856 bytes. The model card rounds this to Number of Model Parameters: 3,000,000,000. The Hugging Face API separately reports 3,455,180,928 BF16 tensors, which is higher because shared or tied tensors are counted more than once. The index metadata figure of 3,144M is the one to use.
Pretraining data
21.6 million data points across 13 datasets, collected by a hybrid of human, robot and simulation methods. The distinguishing addition is EgoScale pre-training on human egocentric video, described as 20K hours in the repository README and as 20,854 hours spanning 20 or more task categories in the Hugging Face release blog, covering manufacturing, retail, healthcare and home environments. Training consumed 64 GB200 nodes at 4 GPUs per node for about 120 hours, roughly 41,288 kWh and 16.949 tCO2e by NVIDIA's own accounting.
Embodiments
Unitree G1 and UNITREE_G1_SONIC, Franka Panda (LIBERO_PANDA), WidowX (SIMPLER_ENV_WIDOWX), Google Robot (SIMPLER_ENV_GOOGLE), DROID Franka (OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT), RoboCasa Panda Omron and RoboCasa GR1 tabletop, custom robots via NEW_EMBODIMENT

What hardware it needs

This is the section most people came for, so it is worth being precise about which numbers are measured and which are arithmetic.

Computed from 3.1 B parameters. Weights only, so treat it as a floor: activations, image encoder intermediates and the CUDA context come on top, in practice 30 to 50 percent more for inference.
PrecisionWeightsNote
fp3212 GBTraining master weights, rarely used for inference
bf16 or fp165.9 GBThe usual way these checkpoints are served
int82.9 GBQuantised, expect some loss of precision on fine motions
int41.5 GBAggressive quantisation, verify success rate before trusting it

Smallest real card that fits the bf16 weights plus a 40 percent runtime allowance: 12 GB. That is an estimate for inference, not for fine tuning. Full fine tuning also holds optimiser state and gradients, which typically costs several times the weights unless you use LoRA or a comparable adapter.

Published figures. These come from the model authors, not from this site.
Inference memory, reported16 GB
Fine tuning memory, reported40 GB
Inference latency, reported27.9 ms on H100 80GB HBM3 with the full TensorRT pipeline, 4 denoising steps, single camera: 27.9 ms end to end (35.9 Hz), split as 6.2 ms data processing, 8.8 ms backbone, 12.3 ms action head. The same H100 in PyTorch eager mode takes 85.8 ms (11.7 Hz), and with torch.compile 48.6 ms (20.6 Hz). Edge figures with TensorRT: RTX Pro 6000 Blackwell 27.9 ms, L40 38.4 ms, AGX Thor 93.8 ms (10.7 Hz), DGX Spark 98.6 ms (10.1 Hz), Orin 216.5 ms (4.6 Hz, DiT-only TensorRT because TRT 10.3 cannot build the backbone engine).
Checkpoint download6.91 GB

Inference runs on 16 GB, so an RTX 4090 or a Jetson AGX Thor is enough. Fine-tuning needs 40 GB minimum, so H100, L40 or A100 class. Full-scale production fine-tuning is documented at 8x RTX Pro 6000 or DGX with 96 GB each and a global batch size of 640.

Reported results

Grouped by what the evaluation actually asked. Values from different suites are not comparable with each other, so each one keeps its suite and split.

Simulation

Reproducible benchmark suites. Everyone runs the same episodes, so the numbers can be compared inside a suite.

  • LIBERO Object suite, fine-tuned 20K steps at batch size 640
    98.45%
    success rateCAUTION. NVIDIA publishes this table on the N1.7 branch, but it is byte-identical to the table on the N1.6 branch (Spatial 195/200, Goal 195/200, Object 197/200, Long 189/200), while only the base-model path in the reproduction command changed from GR00T-N1.6-3B to GR00T-N1.7-3B. Four identical episode counts across four suites make an independent re-measurement implausible, so treat this as an N1.6 result carried forward rather than a verified N1.7 number.source
  • SimplerEnv Fractal (Google Robot) Average over 6 tasks, 100 trials each, nvidia/GR00T-N1.7-SimplerEnv-Fractal
    72.5%
    success rateFirst-party. Up from 52.0 percent for N1.6 on the identical protocol. The largest single gain is google_robot_open_drawer, which went from 0 of 100 to 65 of 100.source
  • RoboCasa Panda Omron Average over 24 kitchen tasks, fine-tuned N1.7 checkpoint
    70.8%
    success rateFirst-party. N1.6 scored 66.22 percent on the same 24 tasks. N1.7 is not uniformly better: OpenDoubleDoor fell from 39.0 to 25.0 percent and PnPMicrowaveToCounter from 24.5 to 19.0 percent.source
  • SimplerEnv Bridge (WidowX) Average over 7 tasks, 100 trials each, nvidia/GR00T-N1.7-SimplerEnv-Bridge
    62.3%
    success rateFirst-party. N1.6 scored 56.6 percent. The average masks two large regressions: put_eggplant_in_basket fell from 89 of 100 to 53 of 100 and put_eggplant_in_sink collapsed from 33 of 100 to 2 of 100, while stack_cube rose from 5 to 48.source
  • RoboCasa GR1 Tabletop Tasks Average over 24 tasks, 20 closed-loop episodes each, fine-tuned ROBOCASA_GR1_TABLETOP checkpoint
    44.5%
    success rateFirst-party, mean of per-task success rates. This is the hardest published suite for N1.7 and ranges from 10.0 percent (novel cuttingboard to basket) to 75.0 percent (novel plate to plate). Only 20 trials per task, so each task carries wide error bars.source

Real world

No results in this category are published for this model.

Fine tuned tasks

No results in this category are published for this model.

On real hardware

NVIDIA publishes real G1 evaluation alongside the simulation suites, and the model card lists real-robot evaluation on grocery packing, novel objects unseen in training, and industrial multi-robot coordination with handoffs, judged by human observers in the lab. No success-rate figures are given for those real-robot evaluations, so the quantitative record for N1.7 is the simulation benchmarks. Post-trained checkpoints ship for DROID, LIBERO, SimplerEnv Bridge and SimplerEnv Fractal.

Fine tuning it yourself

Fine-tune via the Isaac-GR00T main branch with GR00T LeRobot format data (per-episode parquet plus per-episode mp4, LeRobot v2.0; a converter from v3.0 is provided). Request access to nvidia/Cosmos-Reason2-2B on Hugging Face first or every run fails. Pre-registered embodiment tags include LIBERO_PANDA, SIMPLER_ENV_WIDOWX, SIMPLER_ENV_GOOGLE, UNITREE_G1_SONIC, ROBOCASA_PANDA_OMRON, ROBOCASA_GR1_TABLETOP and OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT, plus NEW_EMBODIMENT for custom robots. Published recipes: LIBERO 20K steps at global batch 640 on 8 GPUs, SimplerEnv 20K steps at batch 1024, RoboCasa GR1 tabletop 60K steps at batch 512. Single-GPU prototyping is documented at 40 to 80 GB with batch size 32, and gradient accumulation compensates for fewer GPUs. Default fine-tuning tunes the projector and action head only, staying under about 35 GB per GPU.

This is one of the models the AY-Robots training pool can fine tune for you on a dataset recorded with your own arm. The platform page carries the defaults, GPU tier and inference latency measured in that pool.

Platform page for NVIDIA Isaac GR00T N1.7

Where it helps, where it does not

Strengths

  • The only commercially licensable model in this comparison. The NVIDIA Open Model License on N1.7 weights plus Apache-2.0 code is what separates it from N1, N1.5 and N1.6, and from every Physical Intelligence model after π0.5.
  • Best-documented deployment profile of any model here. A nine-platform latency table with per-component breakdowns, explicit VRAM minimums for inference and fine-tuning, and a published TensorRT speedup of 1.5x to 3.3x.
  • Genuinely deployable at the edge. 16 GB inference, 93.8 ms on a robot-mounted Jetson AGX Thor, and NVIDIA documents that roughly 10 Hz replanning sustains 30 FPS execution through action chunking and asynchronous inference.
  • Clear gains over N1.6 on the two SimplerEnv averages (72.5 versus 52.0 on Fractal, 62.3 versus 56.6 on Bridge) and on RoboCasa (70.8 versus 66.22).
  • 20K hours of EgoScale human egocentric video in pre-training, against the few thousand hours of teleoperation behind N1.6, which NVIDIA credits for the improved generalisation and language following.
  • The action horizon grew from 16 to 40 and the state and action dimensions from 29 to 132, so one model covers far more robot geometries.

Limits

  • The published LIBERO table on the N1.7 branch is byte-identical to the N1.6 branch table, so it appears to be carried over rather than re-measured. Do not treat the LIBERO figures as verified N1.7 results.
  • Averages hide regressions. On SimplerEnv Bridge, put_eggplant_in_sink collapsed from 33 of 100 under N1.6 to 2 of 100 under N1.7, and put_eggplant_in_basket fell from 89 to 53. Upgrading is not uniformly safe for a specific task.
  • The Cosmos-Reason2-2B backbone is a gated Hugging Face repository. Every checkpoint, including the base model, loads it at runtime, so without approved access every run fails with a GatedRepoError. Plan for this in CI and in air-gapped deployments.
  • Fine-tuning needs 40 GB minimum, and tuning the language or vision towers pushes the recommendation to 80 GB or more per GPU. Default fine-tuning only touches the projector and action head.
  • Orin is effectively unusable at 216.5 ms (4.6 Hz) because TensorRT 10.3 cannot build the backbone engine, leaving DiT-only acceleration. Budget for Thor rather than Orin.
  • NVIDIA's own warning of 5 to 6 percentage points of run-to-run variance in post-training applies here too, which is larger than several of the reported N1.6 to N1.7 deltas.
  • The N1.6 gr1_unified embodiment tag was retired, and the rollout flag --action-horizon was renamed to --execution-horizon, so N1.6 pipelines need migration.
  • No architecture paper exists for N1.7. The model card still points to the March 2025 GR00T N1 white paper, so the current design is documented only in a README and a model card.

Sources

Everything on this page was taken from these documents. Where they disagree with what you read here, they win.

Entry last checked 2026-08-11.

Try a policy on a real arm

A physical SO-100 is online and free to drive in the browser, and five of the models in this arena can be fine tuned on a dataset you record with your own.

Download the clientDrive a real arm now