NVIDIA Isaac GR00T N1.6 is a 3-billion-parameter vision-language-action model and cross-embodiment robot foundation model developed by Nvidia. Released on December 15, 2025, it is a successor to Isaac GR00T N1.5 for post-training manipulation and locomotion-manipulation policies across multiple robot forms. The model accepts camera images, robot state, and a language instruction, then predicts a chunk of continuous robot actions.[1][2]

N1.6 is a downloadable base policy rather than a ready-made autonomous robot system. NVIDIA provides weights, post-training code, deployment examples, and several task-specific checkpoints. Users must still configure an embodiment, supply demonstration data or use a supported checkpoint, connect the policy to a robot controller, and add task and safety logic appropriate to the deployment.[4]

Field	N1.6 release
Developer	NVIDIA GEAR team
Release date	December 15, 2025
Model class	Cross-embodiment vision-language-action policy
Parameter count	3 billion, as labeled by NVIDIA
Inputs	One or more RGB camera views, robot proprioception, and a text instruction
Output	Continuous action vectors arranged as an action chunk
Policy head	32-layer diffusion transformer using flow matching
Pretraining	300,000 steps, global batch size 16,384
Data scale	More than 10,000 hours across the GR00T base mixture; several thousand additional hours named for N1.6
Released precision	BF16 safetensors, split across two weight shards
Runtime	PyTorch on Linux; TensorRT path available for the action head
Code license	Apache License 2.0
Weight license	NVIDIA noncommercial license, limited to research or evaluation

Release and intended use

NVIDIA introduced N1.6 as an improved version of N1.5 for generalized humanoid robot skills. The release emphasized bimanual manipulation, household and industrial tasks, and whole-body locomotion-manipulation. It was not accompanied by a separate N1.6 research paper. Its primary technical record is NVIDIA's release page, model repository, checkpoint configuration, and model card.[1][2][4]

The base checkpoint is intended for zero-shot testing of basic primitives and, more commonly, post-training for a particular robot, task, and environment. The repository assumes that demonstrations are represented as video, state, and action triplets converted to a GR00T-flavored LeRobot schema. A policy server exposes model inference, while a robot-specific client and controller are responsible for executing the returned actions.[4]

NVIDIA also released task-specific N1.6 checkpoints for Bridge data on a WidowX arm, Fractal data on a Google robot, BEHAVIOR-1K on a Galaxea R1 Pro, a Unitree G1 pick-and-place task, and DROID manipulation data. Results from those checkpoints measure an adapted N1.6 policy, not the untouched base checkpoint.[4]

Architecture

N1.6 combines a vision-language backbone with a diffusion transformer action head. The backbone encodes a variable number of camera views and a language instruction. An embodiment-specific multilayer perceptron encodes proprioceptive state. The action head interleaves self-attention over state and action tokens with cross-attention to the vision-language representation.[1][2]

The action head uses flow matching. During training, clean actions are interpolated with Gaussian noise and the model learns a velocity field. At inference time, it starts with a Gaussian action sample and iteratively reconstructs a continuous action vector. The released configuration uses four inference timesteps by default, a 50-step action horizon, maximum state and action dimensions of 128, and BF16 parameters.[2][3]

NVIDIA described four main architectural changes from N1.5:

The base vision-language model supports flexible image resolution and native aspect ratios.
The diffusion transformer doubled from 16 to 32 layers.
The four-layer transformer adapter placed after the N1.5 vision-language model was removed, while the top four backbone layers were unfrozen during pretraining.
Most embodiments changed from absolute joint-angle or end-effector targets to state-relative action chunks.[1]

NVIDIA's version-specific artifacts use two names for the backbone. The release page calls it an internal Cosmos-2B or Cosmos-Reason-2B vision-language variant. The distributed configuration labels the backbone type eagle and names nvidia/Eagle-Block2A-2B-v2; the model card also cites Eagle 2.5. NVIDIA has not published a mapping that explains the relationship between these labels. The checkpoint configuration is therefore the most precise description of the released files, while the Cosmos wording describes the model family in the release notes.[1][2][3]

The model card includes an older schematic that describes SigLIP2 image encoding and T5 text encoding. That schematic does not match the N1.6 configuration's named Eagle backbone. It should not be used to infer that the released N1.6 checkpoint has a second, separate SigLIP2-T5 policy backbone.[2][3]

Inputs and outputs

The policy accepts three modalities:

A variable number of RGB image frames from robot cameras. The release notes say the vision-language backbone can preserve native aspect ratio without padding.
A one-dimensional floating-point vector describing robot proprioception. Its meaning depends on the embodiment and can include joint positions, end-effector poses, gripper state, base pose, or velocity.
A text instruction describing the requested task.[1][2]

The output is a two-dimensional chunk of continuous values, with time along one dimension and embodiment-specific controls along the other. Depending on the configured robot, those values can represent arm joints, end-effectors, grippers, a mobile base, torso, hands, or other motor controls. Relative targets are the default for most, but not all, N1.6 embodiments. The policy does not itself provide a natural-language plan, collision certificate, or low-level motor driver.[1][2][3]

Training data and embodiments

The N1.6 repository says its base models were pretrained on more than 10,000 hours of robot data. The model card describes a mixture of bimanual, semi-humanoid, and humanoid data combining real capture with synthetic data generated through Isaac GR00T Blueprint components. NVIDIA has not published the complete corpus, per-source hour counts, sampling weights in machine-readable form, or all train-test splits.[2][4]

Beyond the N1.5 mixture, NVIDIA says N1.6 added several thousand hours associated with four settings:

The downloadable base checkpoint registers seven embodiment identifiers: OXE Google robot, OXE WidowX, LIBERO Panda, Unitree G1, RoboCasa Panda-Omron, GR-1, and BEHAVIOR R1 Pro. This registration list is not identical to the full training mixture or the set of real robots shown on the release page. YAM and AgiBot, for example, appear in the release experiments but are not named in the public base checkpoint's embodiment map.[5]

N1.6 was pretrained for 300,000 steps with a global batch size of 16,384. NVIDIA says its objectives combined flow matching with world modeling. For the real-robot results, the team then used small task-specific datasets and typically post-trained for 10,000 to 30,000 steps with a global batch size of 1,000 or less.[1][2]

Evaluation

Real-robot comparisons

NVIDIA compared post-trained N1.5 and N1.6 policies on 15 real-robot tasks. N1.6 had a higher reported success rate on 13 tasks, tied one AgiBot task, and was lower on one YAM fruit task. The largest gains appeared on several YAM atomic skills, while the AgiBot changes were modest.[1]

Platform and task	N1.5 success	N1.6 success
YAM, cube pick and place	33.8%	98.8%
YAM, bar pick and place	21.3%	92.3%
YAM, cube handover	59.5%	88.0%
YAM, fruit pick and place	100.0%	95.0%
YAM, fold towel	67.0%	93.0%
YAM, fold T-shirt	16.5%	80.0%
AgiBot, fold T-shirt	69.0%	73.0%
AgiBot, bus table	66.0%	68.0%
AgiBot, fruit packing	73.0%	73.0%
YAM industrial, connect tube	18.3%	59.8%
YAM industrial, insert rail into GPU	81.0%	88.0%
Unitree G1, walk and pick bottle	86.6%	98.3%
Unitree G1, fruit to plate	93.8%	96.4%
Unitree G1, shelf pick and place	67.0%	79.2%
Unitree G1, multi-station pick and place	60.0%	67.0%

The release page does not disclose the number of trials behind these percentages, confidence intervals, random seeds, amount of data per task, or whether task termination and human interventions were scored consistently across platforms. The table is first-party evidence of NVIDIA's experiment, not an independently replicated comparison.[1]

Simulation benchmarks

The repository provides post-training recipes and simulation results for N1.6-derived checkpoints. In SimplerEnv, the Bridge checkpoint averaged 62.07% across seven WidowX tasks, with 200 trials per task. Performance ranged from 5.5% for cube stacking to 95.5% for opening a drawer. The Fractal checkpoint averaged 67.66% across six Google-robot tasks, also with 200 trials per task, ranging from 14.5% for placing an object in a closed drawer to 97.5% for picking a Coke can. Both recipes used 20,000 post-training steps, eight GPUs, and a global batch size of 1,024.[6]

LIBERO suite	Reported successes	Rate calculated from count
Spatial	195 / 200	97.5%
Goal	195 / 200	97.5%
Object	197 / 200	98.5%
Long-horizon	189 / 200	94.5%

The LIBERO recipes used 20,000 post-training steps, eight GPUs, and a global batch size of 640. NVIDIA's repository prints percentages next to these counts, but three printed values do not exactly equal their fractions. The table above preserves the published counts and calculates the percentages directly. Neither the SimplerEnv nor LIBERO result page provides an N1.5 baseline, so these numbers do not by themselves measure the N1.6 improvement over N1.5.[6][7]

Weights, software, and licensing

NVIDIA distributes the N1.6 base checkpoint through Hugging Face as two BF16 safetensors shards plus a tensor index, configuration, processor configuration, normalization statistics, and embodiment map. The weight index records approximately 6.57 GB of tensor data. The repository supplies PyTorch code for data conversion, post-training, policy serving, simulation evaluation, and robot integration.[2][3][4]

The software repository uses the Apache License 2.0. The model weights do not. Their NVIDIA license permits use, modification, and redistribution subject to its terms, but Section 3.3 limits the work and derivative works to noncommercial research or evaluation, except for NVIDIA and its affiliates. N1.6 can therefore be described as publicly downloadable or open-weight, but the weight license is not commercially permissive and is distinct from the code license.[4][11]

Hardware and runtime

The model card lists PyTorch on Linux and NVIDIA Ampere, Hopper, Lovelace, Blackwell, and Jetson hardware. The N1.6 branch includes installation paths for discrete GPUs, Jetson AGX Thor with JetPack 7.1, and Jetson Orin with JetPack 6.2. It also offers ONNX export and TensorRT acceleration for the diffusion action head; the generated TensorRT engine is specific to the GPU architecture on which it is built.[2][4][8]

For four denoising steps and a single camera view, NVIDIA reports the following end-to-end torch.compile timings. These are repository benchmarks, not guaranteed latency for a complete robot, whose cameras, networking, controller, and safety stack add overhead.[4]

Device	End-to-end latency	Policy frequency
GeForce RTX 5090	37 ms	27.3 Hz
H100	38 ms	26.3 Hz
GeForce RTX 4090	44 ms	22.8 Hz
Jetson AGX Thor	105 ms	9.5 Hz

The deployment guide also reports TensorRT measurements and an Orin path, but emphasizes that only the action head is compiled or converted; backbone timing remains. Deployment feasibility therefore depends on camera count, requested action horizon, controller frequency, and whether inference is local or served over a network.[8]

Limitations and safety

NVIDIA states that N1.6 was not tested or intended for mission-critical applications requiring functional safety. A user who deploys the model is responsible for physical guardrails, robot-level safety mechanisms, controller limits, supervision, and validation in the actual environment.[9][10]

The model's own documentation identifies several technical limitations:

Relative actions are smoother in NVIDIA's experiments but can accumulate error when post-training data is small, reducing correction ability.
Pretraining statistics can cause underfitting when the downstream distribution differs from pretraining data; post-training statistics may be needed.
N1.6 converges faster than N1.5 but can overfit, leading NVIDIA to use stronger state regularization, data augmentation, and co-training with pretraining data.
Multi-task language following and out-of-distribution task generalization remain difficult.
Dynamic surroundings, changing lighting, environment-specific integration, and limited initial embodiment coverage can reduce performance.[1][10]

NVIDIA recommends corrective data collection with DAgger when a policy underperforms and reports that real-time chunking improved smoothness and robustness for asynchronous YAM and Unitree G1 rollouts. These techniques mitigate some deployment failures, but they do not turn the VLA policy into a certified safety system.[1]

References

NVIDIA GEAR Team, "GR00T N1.6: An Improved Open Foundation Model for Generalist Humanoid Robots," December 15, 2025. https://research.nvidia.com/labs/gear/gr00t-n1_6/
NVIDIA, "GR00T-N1.6-3B Model Card," December 2025. https://huggingface.co/nvidia/GR00T-N1.6-3B
NVIDIA, "GR00T-N1.6-3B Configuration," December 2025. https://huggingface.co/nvidia/GR00T-N1.6-3B/blob/main/config.json
NVIDIA, "Isaac-GR00T, n1.6-release branch," accessed July 24, 2026. https://github.com/NVIDIA/Isaac-GR00T/tree/n1.6-release
NVIDIA, "GR00T-N1.6-3B Embodiment Map," December 2025. https://huggingface.co/nvidia/GR00T-N1.6-3B/blob/main/embodiment_id.json
NVIDIA, "SimplerEnv N1.6 Evaluation and Fine-Tuning Guide," accessed July 24, 2026. https://github.com/NVIDIA/Isaac-GR00T/blob/n1.6-release/examples/SimplerEnv/README.md
NVIDIA, "LIBERO N1.6 Evaluation and Fine-Tuning Guide," accessed July 24, 2026. https://github.com/NVIDIA/Isaac-GR00T/blob/n1.6-release/examples/LIBERO/README.md
NVIDIA, "GR00T Deployment and Inference Guide," accessed July 24, 2026. https://github.com/NVIDIA/Isaac-GR00T/blob/n1.6-release/scripts/deployment/README.md
NVIDIA, "GR00T-N1.6-3B Safety and Security Subcard," December 2025. https://huggingface.co/nvidia/GR00T-N1.6-3B/blob/main/SAFETY_and_SECURITY.md
NVIDIA, "GR00T-N1.6-3B Explainability Subcard," December 2025. https://huggingface.co/nvidia/GR00T-N1.6-3B/blob/main/EXPLAINABILITY.md
NVIDIA, "NVIDIA One-Way Noncommercial License," March 22, 2022. https://developer.download.nvidia.com/licenses/NVIDIA-OneWay-Noncommercial-License-22Mar2022.pdf

Editing: NVIDIA Isaac GR00T N1.6