Description:

GN1x-Tuned-Arena-G1-Static-PickNPlace is a fine-tuned NVIDIA Isaac GR00T N1.7 model for the static pick-and-place task provided in IsaacLab Arena.

Isaac GR00T N1.7-3B is the medium-sized version of the model, built using pretrained vision and language encoders. It uses a flow-matching action transformer to model a chunk of actions conditioned on vision, language, and proprioception.

This model is ready for non-commercial use only.

License/Terms of Use:

GOVERNING DOWNLOAD TERMS: Use of the model is governed by the NVIDIA Open Model Agreement.

Deployment Geography:

Global

Use Case:

Researchers, Academics, Open-Source Community: AI-driven robotics research and algorithm development. Developers: Integrate and customize AI for various robotic applications. Startups & Companies: Accelerate robotics development and reduce training costs.

Release Date:

GitHub: 06/23/2026 via isaac-sim/IsaacLab-Arena Hugging Face: 06/23/2026 via nvidia/GN1x-Tuned-Arena-G1-Static-PickNPlace

Reference(s):

GR00T N1 White Paper: "GR00T N1: An Open Foundation Model for Generalist Humanoid Robots." (2025).

Liu, Xingchao, and Chengyue Gong. "Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow." The Eleventh International Conference on Learning Representations.

Flow Matching Policy: Black, Kevin, et al. "π0: A Vision-Language-Action Flow Model for General Robot Control." arXiv preprint (2024).

Model Architecture:

Architecture Type: Vision-Language Backbone, Multilayer Perceptron, Flow Matching Transformer

GR00T N1.7 uses a Cosmos-Reason2-2B vision-language backbone based on the Qwen3-VL architecture, replacing the Eagle backbone used in N1.6. It uses a flow-matching action transformer to model chunks of actions conditioned on vision, language, and proprioception.

RGB camera frames are processed through a pretrained vision transformer (SigLip2), and text is encoded by a pretrained transformer (T5). N1.7 supports flexible image resolution and encodes images in their native aspect ratio without padding. Robot proprioception is encoded using a multi-layer perceptron (MLP) indexed by the embodiment ID. To handle variable-dimension proprioception, inputs are padded to a configurable max length before feeding into the MLP.

Actions are encoded and velocity predictions are decoded by an MLP, one per unique embodiment. The flow-matching transformer is implemented as a diffusion transformer (DiT), with diffusion-step conditioning implemented using adaptive layer normalization (AdaLN).

Network Architecture: The schematic diagram is shown in the illustration above.

Number of Model Parameters: 3B

Input:

Input Type:

Vision: Image Frames
State: Robot Proprioception
Language Instruction: Text
Embodiment ID: Integer

Input Format:

Vision: Variable number of uint8 image frames, coming from robot cameras
State: Floating Point
Language Instruction: String
Embodiment ID: Integer indicating which of the training embodiments is observed

Input Parameters:

Vision: Two-Dimensional (2D) - Red, Green, Blue (RGB) image
State: One-Dimensional (1D) - Floating number vector
Language Instruction: One-Dimensional (1D) - String
Embodiment ID: One-Dimensional (1D) - Integer

Other Properties Related to Input: [Specific Resolution/Minimum or Maximum Resolution or Characters (Including Restrictions), Context Length, Image Range Needed (W x Y x Z), Pre-Processing Needed, Alpha Channel, Bit, Please State Explicity.]

Output:

Output Type(s): Actions
Output Format Continuous-value vectors
Output Parameters: [Two-Dimensional (2D)]
Other Properties Related to Output: Continuous-value vectors correspond to different motor controls on a robot, which depends on Degrees of Freedom of the robot embodiment.

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.

Software Integration

Runtime Engine(s): PyTorch

Supported Hardware Microarchitecture Compatibility: All of the below:

NVIDIA Ampere
NVIDIA Blackwell
NVIDIA Jetson
NVIDIA Hopper
NVIDIA Lovelace

Preferred/Supported Operating System(s): Linux

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

Model Version(s):

Version 1.7.

Training, Testing, and Evaluation Datasets:

Post-Training Dataset:

Trained with dataset nvidia/Arena-G1-Static-PickNPlace-Task

Data Collection Method

Data Modality: Other: Robot Simulation

Training Data Size: 200 demonstrations

Human

All 200 demonstrations were manually collected through human teleoperation using an XR headset in Isaac Lab. Each demo was recorded at 50 Hz.

Labeling Method

Human

Properties: [Number of data items in training set, descriptive information about the data indicating (i) the modalities (e.g,, text, images), (ii) nature of the content (e.g., personal data, copyright protected content, machine generated data such as Internet of Things or synthetic data) and (iii) its linguistic characteristics. If applicable, what specific sensor type was used for Data Collection]

Evaluation

Data Modality: Other: Robot Simulation

Data Collection Method: Simulated G1 robot - IsaacLab-Arena

Labeling Method: Not Applicable

Properties: The evaluation was performed in simulation using IsaacLab-Arena. The evaluation data consists of dynamically generated episodes of static pick-and-place tasks.

Inference:

Acceleration Engine(s): PyTorch

Test Hardwares

NVIDIA RTX 6000 Ada

Resources

NVIDIA Isaac GR00T repository: https://github.com/NVIDIA/Isaac-GR00T
Base model: https://huggingface.co/nvidia/GR00T-N1.7-3B
GR00T N1.7 collection: https://huggingface.co/collections/nvidia/gr00t-n17
Paper: https://arxiv.org/abs/2503.14734
Previous Version: https://huggingface.co/nvidia/GR00T-N1.6-3B
Blogpost: https://nvidianews.nvidia.com/news/foundation-model-isaac-robotics-platform
Fine-tuning guide: https://github.com/NVIDIA/Isaac-GR00T/blob/main/getting_started/finetune_new_embodiment.md

Ethical Considerations:

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

Please make sure you have proper rights and permissions for all input image and video content; if image or video includes people, personal health information, or intellectual property, the image or video generated will not blur or maintain proportions of image subjects included.

For more detailed information on ethical considerations for this model, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy Subcards.

Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.