NVIDIA Isaac GR00T: The Open Humanoid Model That Ships With Its Own Compute Bill

NVIDIA describes Isaac GR00T as "an open reference platform for general-purpose humanoid robots," a bundle of open data, an open robot foundation model, simulation frameworks, middleware, CUDA-X runtime libraries, and Jetson Thor for on-robot inference. The name expands on the product page as "Generalist Robot 00 Technology." The current release is GR00T N1.7, marked General Availability, a 3-billion-parameter vision-language-action model with published weights, published finetuning recipes, and published benchmark tables with the exact commands that produced them.

That last part is what makes GR00T worth a careful read. The release publishes numbers that cut against its own pitch. The same repository that reports 98.45% success on one LIBERO tabletop split also reports 8.58% on a broad-generalization suite of 4,800 episodes. Reading both at once is the only honest way to place this model.

Companion reading: foundation models and VLA robotics, imitation learning in robotics, sim-to-real transfer, edge AI and robot compute.

Table of contents

1. Key takeaways
2. What GR00T actually is
3. The benchmark record
4. Demonstrated versus claimed
5. How open is it
6. The compute dependency
7. What to watch
8. Frequently asked questions
9. Changelog

What GR00T actually is

The repository frames N1.7 as "an open vision-language-action (VLA) model for generalized humanoid robot skills," a cross-embodiment model that takes language and images and outputs manipulation actions. Architecturally it pairs a vision-language backbone with a diffusion transformer head that denoises continuous actions. In N1.7 the backbone is nvidia/Cosmos-Reason2-2B (a Qwen3-VL architecture), replacing the vendored Eagle model used in N1.6, and the flow-matching action head changes from 32 diffusion layers to 16.

The interface moved a long way between versions. State and action dimensions go from 29 to 132, the action horizon from 16 to 40. The headline design change is a relative end-effector action space shared across robot and human embodiments. NVIDIA's stated rationale: "Representing actions as deltas from the current pose (rather than absolute targets) improves generalization and is a key factor in the model's cross-embodiment performance."

One documentation point matters for anyone citing this work. The repository's Paper link and its citation block both point to "GR00T N1: An Open Foundation Model for Generalist Humanoid Robots" (arXiv:2503.14734, submitted 18 March 2025, 41 NVIDIA authors listed alphabetically by surname, from Johan Bjorck to Yuke Zhu). That paper describes N1. The relative-EEF change, the backbone swap and the N1.7 pretraining mixture are documented in the repository itself.

On data, exactly one quantified pretraining figure appears in the material: "20K hours of EgoScale human video data in pretraining." There is no robot-hours count, no episode count and no mixture breakdown. The README header does link a "Datasets (Physical AI)" Hugging Face collection, though nothing in the fetched material maps that collection onto the N1.7 pretraining corpus. The demo data shipped in the repo is deliberately tiny: three DROID episodes, five LIBERO, five SO100.

The benchmark record

These are simulation results, published by NVIDIA, all with commands attached.

Averages hide the shape of the change. On Bridge, stack_cube improved from 5.0% to 48.0% and spoon_on_towel from 55.4% to 78.0%, while put_eggplant_in_basket fell from 89.0% to 53.0% and put_eggplant_in_sink collapsed from 33.0% to 2.0%. On RoboCasa, PnPCounterToMicrowave rose from 19.0% to 30.0% while OpenDoubleDoor fell from 39.0% to 25.0%. Progress here is uneven per task.

Two caveats come from NVIDIA directly. It states that "users may observe 5-6% variance between runs due to non-deterministic image augmentations," a band wide enough to cover the entire RoboCasa average delta. And the --state_dropout_prob setting is overridden per benchmark by the shipped scripts (0.2 on LIBERO 10-Long, 0.8 on SimplerEnv Bridge, 0.5 on SimplerEnv Fractal), so headline figures each use a hand-picked value.

The RoboLab README is candid about its own evidence: the final full-suite run used --video-mode none, so the table is the authoritative quantitative result while some high-success tasks have no recoverable video. That same README is also the one place where an outside artefact enters the record. Its N1.6 reference row (87/1,200, 7.25%) comes from a third-party branch, nadunRanawaka1/Isaac-GR00T-n16-droid, and it separately reports a local reproduction of 94/1,200 (7.83%).

Demonstrated versus claimed

Demonstrated. A downloadable 3B base checkpoint plus finetuned checkpoints for LIBERO Panda, DROID, SimplerEnv WidowX and SimplerEnv Fractal. Reproducible simulation benchmarks across five suites. A LeRobot-v2 data format with a documented modality spec, and a groot policy type in LeRobot itself. Documented failure modes, in NVIDIA's own FAQ, at a level of frankness that is rare: lighting and hue shifts, object-shape deviation, large viewpoint and head-motion changes, the inability to retry after a failed attempt, and left/right confusion in bimanual tasks.

Claimed but not shown. The product page says the models "easily generalize across common tasks" and cites use cases in material handling, packaging and inspection, with no figures attached. The README says N1.7 "refreshes and expands documented results across RoboCasa, RoboCasa GR1 tabletop tasks, SimplerEnv, and real G1 evaluation," but no real-G1 success rates appear in the fetched files. The arXiv abstract states N1 "outperforms the state-of-the-art imitation learning baselines"; the current N1.7 material compares only against N1.6. The product page lists Cosmos world foundation models as a platform component, while the FAQ says a product-ready Cosmos synthetic-data pipeline is "currently in development and not yet part of the standard release."

Ruled out by NVIDIA. The FAQ says the N1.x series is optimized for action generation, "not open-ended reasoning or VQA." Asked whether a zero-shot cross-embodiment VLA exists, it answers "No," including for its own model, which is worth holding next to the cross-embodiment framing on the product page. The architecture is stateless and does not inherently know that a prior attempt failed, so explicit recovery is best achieved through DAgger or reinforcement learning. VLMs "can struggle with drastic appearance changes," and NVIDIA notes it has not released specific lighting ablations.

Absent entirely. No third-party evaluation of GR00T itself. No training-compute, GPU-hour or cost disclosure. No named commercial customer: the ecosystem section of the product page renders its partner logos as a single embedded image with no company names in the markup, although the repository does name robot platforms it supports, including Unitree G1, the Fourier GR-1 in the N1 paper, and R1 Pro Sharpa data variants tagged for MaxInsights and Mecka. No pricing for Thor, DGX Cloud, or the commercial support the GA notice promises.

How open is it

The code is Apache 2.0. The weights are not. The README's License section assigns model weights to the NVIDIA Open Model License, while the intro paragraph of the same file claims N1.7 is "fully commercially licensable under Apache 2.0." Those two statements contradict each other. Anyone making a commercial decision should treat the License section as governing and read the NVIDIA Open Model License text directly.

The second asterisk is operational. The Cosmos-Reason2-2B backbone is a gated Hugging Face model that every GR00T checkpoint loads on first use, including the base model. Without approved access, loading fails with a GatedRepoError. The weights are downloadable; running them requires an approved account.

The compute dependency

The product page pairs each workflow stage with an NVIDIA product tier: DGX Cloud to train, RTX PRO 6000 Blackwell to simulate, Jetson AGX Thor to deploy. NVIDIA's own hardware guide then quantifies what that dependency costs in control rate. All of these figures are NVIDIA-reported, on NVIDIA hardware, with no outside replication. At four denoising steps with one camera, the guide lists PyTorch eager inference at 11.7 Hz on an H100 and 2.9 Hz on Orin; with TensorRT those become 35.9 Hz and 6.6 Hz. Thor sits at 8.9 Hz eager and 12.4 Hz with TensorRT. NVIDIA's own reading is that under 10 Hz is "only suitable for slow, non-reactive tasks," and that TensorRT gives a 1.5x to 3.3x speedup.

Read that carefully. Those figures are the model inference, or replanning, rate. NVIDIA notes that roughly 10 Hz inference can sustain about 30 FPS execution through action chunking and asynchronous inference. Also note what the table does not cover. It is one camera, no load, one robot. No multi-camera, latency-under-load or multi-robot numbers appear in the release.

Stated minimums are 16 GB VRAM for inference with CUDA 12.6+, and 40 GB or more for finetuning with H100 or L40 nodes recommended. The stack is Python 3.12 everywhere, uv for dependencies, torchcodec as the sole video backend (which pins FFmpeg 4 through 7, since FFmpeg 8 breaks it). NVIDIA documents its own rough edges too: a Triton patch script is needed for CUDA 13+, and torch.compile fails on GB300.

What to watch

The N2 release. The FAQ names N2 as the next generation, not yet released, and assigns semantic reasoning and VQA capability to it. That is where the reasoning gap in N1.x is meant to close.

A real-hardware number. The most valuable thing NVIDIA could publish next is a success-rate table on a physical humanoid, run the way the simulation suites are run. The README documents a whole-body humanoid path, the UNITREE_G1_SONIC tag with the GEAR-SONIC controller and a collect, finetune and deploy workflow in the GR00T-WholeBodyControl repository, and the tag tables list a REAL_G1 pretrain tag for a real Unitree G1. None of that carries a published success rate in the fetched material. Today the quantified humanoid evidence is a 44.5% simulated tabletop average.

Movement on RoboLab. The 8.58% broad-generalization figure is the number to track across releases. If it climbs meaningfully while the narrow suites hold, that points to real generalization progress.

The licence text. The Apache 2.0 versus Open Model License contradiction inside one README is the kind of thing that gets quietly corrected. Which direction it gets corrected matters for anyone building on the weights.

Any independent evaluation. One credible outside lab reproducing these tables, or comparing GR00T against a non-NVIDIA VLA on shared tasks, would change how much weight the numbers carry.

A Cosmos data pipeline that ships. Synthetic data generation is central to the platform story and currently absent from the release.

Frequently asked questions

Is Isaac GR00T open source? The code is Apache 2.0. The model weights are under the NVIDIA Open Model License, and the required vision-language backbone is a gated model needing approved access. The README contains a contradictory Apache 2.0 claim for the weights in its intro; the License section says otherwise.

Can GR00T control a new robot without finetuning? No. NVIDIA's FAQ states that a true zero-shot model, one that works perfectly on a new robot without any finetuning, does not currently exist in the open VLA landscape. Cross-embodiment data improves generalization, and the finetuning step remains.

How much data do you need to finetune it? NVIDIA gives rules of thumb: roughly 100 trajectories for simple fixed-location pick and place, 500 or more for complex or multi-step scenes, 2,000 or more for high-DoF humanoid tasks such as shelf-picking with a G1, and 100 to 500 episodes for fine manipulation, ideally with human motion pretraining.

What hardware do I need? Inference needs a single GPU with 16 GB or more of VRAM on CUDA 12.6 or later; the tested platform list includes H100, H20, RTX Pro 6000 and 5000, L40, L20, DGX Spark, Jetson AGX Thor and Orin. Finetuning is recommended on 40 GB-plus GPUs, with H100 or L40 nodes suggested.

Can it recover from a failed grasp? Not reliably on its own. The architecture is stateless and does not inherently know a previous attempt failed. NVIDIA points to DAgger or reinforcement learning for explicit recovery behavior.

Which robots are supported out of the box? The policy guide lists pretrain tags OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT, XDOF, XDOF_SUBTASK, REAL_G1, REAL_R1_PRO_SHARPA, REAL_R1_PRO_SHARPA_HUMAN, REAL_R1_PRO_SHARPA_MAXINSIGHTS and REAL_R1_PRO_SHARPA_MECKA, and posttrain tags OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT, UNITREE_G1_SONIC, LIBERO_PANDA, SIMPLER_ENV_GOOGLE and SIMPLER_ENV_WIDOWX, plus NEW_EMBODIMENT for custom robots. A separate ROBOCASA_GR1_TABLETOP checkpoint tag is used for the GR1 tabletop benchmark. The N1 paper's abstract describes deployment on the Fourier GR-1 for language-conditioned bimanual manipulation.

Are there independent benchmarks? None found in the fetched material. The published numbers are NVIDIA-run and NVIDIA-published, with one exception: the RoboLab README's N1.6 reference row comes from an outside branch maintained by the RoboLab author. The only comparison baseline in the N1.7 release is GR00T N1.6.