# NVIDIA Isaac GR00T

Open foundation model for generalist humanoid robots — VLA with real-time whole-body control.

## Agent Decision Summary
- Risk level: elevated
- Source confidence: high
- Recommended workflows: Robotics or embodied agent workflow
- Permission surface: messages, hardware
- Agent JSON: https://www.openagent.bot/bots/isaac-gr00t.agent.json

## Summary
NVIDIA Isaac GR00T is an open vision-language-action (VLA) foundation model family for generalized humanoid and manipulation robot skills. It takes multimodal input — language and images — and outputs joint-level action sequences for diverse robot embodiments. GR00T N1.7 supports zero-shot inference, fine-tuning on custom robot data, and real-time deployment with TensorRT acceleration. Built on the LeRobot dataset format and fully commercially licensable under Apache 2.0.


## Guide
NVIDIA Isaac GR00T represents a significant step toward open, generalist robot intelligence — a VLA foundation model that controls whole humanoid bodies rather than just arms.

### What it is
GR00T N1.7 is a 3-billion parameter vision-language-action model that takes language instructions and camera images as input and outputs latent action tokens. A learned whole-body controller (SONIC) decodes these tokens into coordinated joint-level commands for legs, arms, and hands. The model is pre-trained on a diverse mixture of robot data including bimanual manipulation, semi-humanoid, and humanoid datasets, plus 20K hours of human video data.

### Why it matters
Generalist robot models have been dominated by closed-source efforts. GR00T changes that by open-sourcing a production-quality VLA under Apache 2.0. For the first time, a researcher with a humanoid robot can download a foundation model, fine-tune it on their specific tasks, and deploy it commercially — all without NVIDIA licensing constraints. This accelerates the whole field of physical AI.

### How it works
Data collection uses the LeRobot v2 format with synchronized video and action sequences. The model is fine-tuned via a launch_finetune.py script that handles modality configuration. For deployment, Gr00tPolicy connects to the robot controller, optionally accelerated with TensorRT. The model supports both zero-shot inference on pre-trained embodiments and fine-tuned deployment for custom robots.


## Use Cases
- Humanoid manipulation and locomotion: Deploy GR00T on a Unitree G1 humanoid for tasks that require walking to a location, picking up an object, and placing it — all from a single language instruction.
- Fine-tuning for specialized industrial tasks: Collect demonstration data from a custom robot arm performing a specific assembly task, fine-tune GR00T, and deploy with TensorRT for real-time inference.
- Cross-embodiment robotics research: Use GR00T's pre-trained representations as a starting point for studying how VLA models transfer across different robot morphologies.

## Alternatives
- Use Pi0 or Pi0.5 for arm-only manipulation vs GR00T: Physical Intelligence's Pi0 series excels at arm manipulation but does not support whole-body or locomotion control. GR00T is the choice when legs are involved.

### Getting Started
- Clone the repository: https://github.com/NVIDIA/Isaac-GR00T
- NVIDIA developer portal: https://developer.nvidia.com/isaac/gr00t

### FAQ
- What hardware do I need to run GR00T?
  - GR00T requires a GPU with sufficient VRAM for the 3B parameter model. A single A100 or RTX 6000 Ada is recommended for training. For inference, TensorRT-optimized deployment runs on consumer GPUs.
- Can I use GR00T commercially?
  - Yes, GR00T is fully licensed under Apache 2.0, including model weights, fine-tuning code, and evaluation tools.
- Does GR00T work with my robot?
  - GR00T supports multiple embodiments through its embodiment tag system. Supported tags include LIBERO PANDA, DROID, SO100, SimplerEnv, and UNITREE G1 SONIC. New embodiments can be added via fine-tuning.
## What It Does
GR00T N1.7 is a 3-billion parameter vision-language-action model that takes language instructions and camera images as input and outputs latent action tokens. A learned whole-body controller (SONIC) decodes these tokens into coordinated joint-level commands for legs, arms, and hands. The model is pre-trained on a diverse mixture of robot data including bimanual manipulation, semi-humanoid, and humanoid datasets, plus 20K hours of human video data.

## How To Evaluate
Data collection uses the LeRobot v2 format with synchronized video and action sequences. The model is fine-tuned via a launch_finetune.py script that handles modality configuration. For deployment, Gr00tPolicy connects to the robot controller, optionally accelerated with TensorRT. The model supports both zero-shot inference on pre-trained embodiments and fine-tuned deployment for custom robots.

## Why It Matters
GR00T matters because it is one of the first open foundation models capable of whole-body humanoid control — legs, arms, and hands coordinated from a single VLA policy. By open-sourcing model weights, fine-tuning code, and evaluation benchmarks under Apache 2.0, NVIDIA gives the robotics community a production-grade starting point for generalist robot intelligence that previously required millions of dollars and proprietary datasets.


## Best For
- Robotics researchers fine-tuning VLA models for custom hardware
- Teams deploying humanoid robots with whole-body coordination
- Developers needing a commercially licensable open-source robot foundation model

## Not For
- Teams looking for a full robotics SDK (GR00T is a model, use Isaac Lab or Isaac Sim for the full stack)

## What It Actually Does
- Whole-body humanoid control from a single VLA policy: GR00T predicts latent action tokens that a learned whole-body controller (GEAR-SONIC) decodes into coordinated leg, arm, and hand commands.
  - Why it matters: Prior VLA models focused on arms only. GR00T extends to full humanoid control, enabling locomotion + manipulation from one model.
- Cross-embodiment zero-shot and fine-tuning: Pre-trained on diverse robot data including bimanual arms, semi-humanoids, and humanoids. Fine-tune on new embodiments with as few as 5 episodes.
  - Why it matters: You can evaluate zero-shot on supported robots or adapt to a custom robot with minimal data collection.
- Commercial-friendly open license: Fully Apache 2.0 licensed with model weights, fine-tuning code, and evaluation benchmarks all publicly available.
  - Why it matters: Open VLA models are rare. Apache 2.0 means startups and researchers can build commercial products without legal uncertainty.
- LeRobot dataset format compatibility: GR00T uses the LeRobot v2 dataset format, making it easy to use existing LeRobot datasets and tools for data preparation.
  - Why it matters: Direct compatibility with the Hugging Face robotics ecosystem lowers the barrier to getting started.

## Typical Use Cases
- Fine-tuning on custom robot hardware: Collect 5-50 demonstration episodes from your robot, convert to LeRobot format, and fine-tune GR00T for your specific embodiment and task.
- Whole-body humanoid deployment: Use GR00T with the SONIC controller on Unitree G1 or similar humanoids for tasks that require coordinated locomotion and manipulation.
- Benchmarking VLA models on LIBERO and SimplerEnv: Evaluate GR00T against standard benchmarks with provided fine-tuned checkpoints for Franka Panda and WidowX arms.

## How It Compares
- Choose GR00T for whole-body humanoid VLA vs arm-only VLA models: Most open VLA models (Pi0, Xiaomi Robotics-0) focus on manipulation only. GR00T uniquely supports whole-body control including locomotion.

## Fit Matrix
- Robotics or embodied agent workflow: strong. NVIDIA Isaac GR00T has multiple signals for robotics or embodied agent workflow, including matching tags, capabilities, category, or positioning. Required check: Separate simulator claims from hardware claims and verify safety boundaries before real-world operation.
- Browser automation: partial. NVIDIA Isaac GR00T has at least one signal for browser automation, but should be checked against a real task before adoption. Required check: Run one non-sensitive website task and inspect clicks, waits, retries, and changed URLs.
- Coding agent workflow: partial. NVIDIA Isaac GR00T has at least one signal for coding agent workflow, but should be checked against a real task before adoption. Required check: Run a small repository change and inspect the diff, tests, and rollback path.
- Connector or protocol layer: partial. NVIDIA Isaac GR00T has at least one signal for connector or protocol layer, but should be checked against a real task before adoption. Required check: Connect one low-risk service, then inspect schemas, auth scope, errors, and logs.
- Reusable skill workflow: partial. NVIDIA Isaac GR00T has at least one signal for reusable skill workflow, but should be checked against a real task before adoption. Required check: Run one skill end to end and check whether it produces evidence or structured output.
- Evaluation and observability: weak. NVIDIA Isaac GR00T is not primarily positioned for evaluation and observability in the current metadata. Required check: Add one repeatable test case and confirm results can run again in review or CI.

## Evidence
- verified: NVIDIA Isaac GR00T is listed as open source. Source: License metadata: Apache-2.0
- verified: NVIDIA Isaac GR00T has a recorded GitHub repository: NVIDIA/Isaac-GR00T. Source: Resource facts and GitHub source link.
- inferred: NVIDIA Isaac GR00T supports these recorded deployment modes: cloud. Source: OpenAgent decision signal metadata.
- inferred: NVIDIA Isaac GR00T is tagged with robotics, messaging capabilities. Source: OpenAgent capability taxonomy.

## Missing Checks
- Dedicated docs link is missing.
- Repository freshness has not been recorded.

## Next Actions
- Inspect repository: https://github.com/NVIDIA/Isaac-GR00T
- Open Homepage: https://developer.nvidia.com/isaac/gr00t
- Clone and run GR00T inference: git clone https://github.com/NVIDIA/Isaac-GR00T && cd Isaac-GR00T && pip install -e .

## Command Line
### Clone and run GR00T inference
Clone the repository and install dependencies. Follow the examples for zero-shot inference or fine-tuning.

```bash
git clone https://github.com/NVIDIA/Isaac-GR00T && cd Isaac-GR00T && pip install -e .
```

## Facts
- Category: bots
- Resource type: bot
- Open source: yes
- License: Apache-2.0
- Last verified: 2026-06-04
- GitHub repo: NVIDIA/Isaac-GR00T
- GitHub stars: 7236

## Capabilities
- robotics
- messaging

## Structured Use Case Tags
- robotics-agent

## Getting Started
- View the GitHub repository: https://github.com/NVIDIA/Isaac-GR00T
- NVIDIA Isaac GR00T homepage: https://developer.nvidia.com/isaac/gr00t

## Links
- GitHub: https://github.com/NVIDIA/Isaac-GR00T
- Homepage: https://developer.nvidia.com/isaac/gr00t

## Structured Outputs
- JSON: https://www.openagent.bot/bots/isaac-gr00t.json
- Markdown: https://www.openagent.bot/bots/isaac-gr00t.md
- Agent JSON: https://www.openagent.bot/bots/isaac-gr00t.agent.json
- Canonical: https://www.openagent.bot/bots/isaac-gr00t