NVIDIA Isaac GR00T でヒューマノイドロボットのポリシーをエンドツーエンドに開発

As more teams move from humanoid robot bring-up to task-specific skill development, the need for repeatable development workflows is growing. Building humanoids remains complex, and today’s development pipelines are still highly fragmented. As a result, developers spend significant time configuring robotics infrastructure before they can focus on building robot capabilities.

While the robotics community has developed capable tools across individual stages of the pipeline, connecting them into a seamless workflow remains a challenge due to siloed software ecosystems, incompatible data formats, and manual integrations between tools. To address this, we introduce the NVIDIA Isaac GR00T Development Platform: an open source humanoid robot platform that unifies every stage of the pipeline for faster development.

This post covers the end-to-end GR00T platform, from data collection and model training to large-scale evaluation and deployment readiness, showcasing how a fully integrated platform can streamline humanoid development.

Accelerate end-to-end humanoid development

The Isaac GR00T platform helps robotics developers scale humanoid data collection and simulation-based training to develop, validate, and deploy policies on real robots. Its end-to-end platform is fully open and modular, enabling teams to use individual components or the complete pipeline, integrate their own tooling, and build using the validated NVIDIA software stack.

A key component of the GR00T workflow is the open Isaac GR00T 1.7 vision-language-action (VLA) model, which streamlines development through a strong pretrained foundation. Trained on diverse data, it can efficiently generalize to new tasks and environments while producing more natural, human-like motion.

Get started with GR00T 1.7

GR00T 1.7 is the first open, commercially usable VLA model for generalized humanoid robot skills, released under the permissive Apache 2.0 license. It’s a cross-embodiment model that takes multimodal input, including language and images, and produces the actions needed to perform tasks across diverse environments. Instead of training a policy from scratch, developers can start from a model that already encodes broad manipulation priors and adapt it to specific robots, tasks, and environments through post-training.

What’s new in GR00T 1.7

• Robust Human Video Pretraining: 1.7 is pretrained on ~32K hours of real demonstration and human ego-centric data as well as ~8K hours of simulated rollouts and demonstrations from BEHAVIOR, RoboCasa, and Simulated GR-1 for more human-like action.

• New VLM backbone: Cosmos-Reason2-2B (Qwen3-VL architecture) replaces the Eagle backbone used in GR00T N1.6. This helps support flexible resolution and encodes images in their native aspect ratio without padding.

• Expanded deployment support: Adds full pipeline export to ONNX and TensorRT, with improved export reliability and higher-frequency updates.

• Enhanced performance: Improved long-horizon task reasoning through task- and subtask-level decomposition, increasing reliability, motion quality, and cross-embodiment generalization.

• Improved benchmarks: Consistent improvements across DROID and SimplerEnv compared to N1.6, including DROID-F0 (+10%) and DROID-F6 (+61%), as well as SimplerEnv Bridge (+5%) and Fractal (+2%), demonstrating stronger generalization.

GR00T 1.7 is accessible via GitHub and Hugging Face, with model weights publicly available and a base checkpoint of 3 billion parameters.

Using the GR00T 1.7 model in the end-to-end GR00T workflow streamlines post-training and policy evaluation, simplifying the transition from foundation model to deployed robot behavior. The following section details the steps for using GR00T 1.7 in the simulation workflow.

Using GR00T platform and 1.7 model for a dexterous manipulation task

This section walks through a simulation workflow for building a simple pick-and-place task using the GR00T platform and the GR00T 1.7 model, from environment setup to deployment readiness. This is an excerpt from our end-to-end GR00T development guide, which covers the full process in more detail.

The walkthrough includes:

• Setting up an environment in simulation

• Collecting robot data through teleoperation

• Converting collected data into LeRobot format

• Post-training GR00T 1.7 with the converted dataset

• Evaluating the post-trained policy

Although this section focuses on simulation, the same steps can be applied to physical robots and adapted across different embodiments and tasks.

Set up an environment

Before collecting any training data, you must first set up the environment. Compose the scene with object and robot assets, define the task, and choose the teleoperation device.

In this example (see Figure 3, above) , the robot stands in front of a shelf and uses its arms to move an apple onto a plate on the same shelf. A Whole Body Controller (WBC) keeps the robot balanced; since the robot doesn’t walk during this task, use AGILE WBC, a single end-to-end policy that fits a static task better than a stand/walk controller.

Choose the WBC deliberately up front: during teleoperation, the AGILE WBC and PinkIK produce the joint-space targets that become the policy’s training signal, so a different controller yields a different training distribution for the same motion.

At a high level the implementation looks like the following code snippet. These snippets use the Isaac Lab-Arena APIs to compose the scene, register assets, and wire up the teleoperation device. These are just snippets; for the entire environment set-up, go to GitLab Pages.

background = self.asset_registry.get_asset_by_name("galileo_locomanip")()

pick_up_object = self.asset_registry.get_asset_by_name(args_cli.object)()

destination = self.asset_registry.get_asset_by_name(args_cli.destination)()

embodiment = self.asset_registry.get_asset_by_name(args_cli.embodiment)(

enable_cameras=args_cli.enable_cameras

)

teleop_device = (

self.device_registry.get_device_by_name(args_cli.teleop_device)()

if args_cli.teleop_device is not None else None

)

scene = Scene(assets=[background, pick_up_object, destination])

task = PickAndPlaceTask(

pick_up_object=pick_up_object,

destination_location=destination,

background_scene=background,

)

return IsaacLabArenaEnvironment(

name=self.name,

embodiment=embodiment,

scene=scene,

task=task,

teleop_device=teleop_device,

)

Collect demonstrations

Once you’ve set up your environment, you can use Isaac Teleop to capture demonstration data, with AGILE WBC handling whole-body control during collection. Demonstrations are collected using a supported VR headset over a CloudXR client. After starting the CloudXR runtime and sourcing the CloudXR environment, record demonstrations with:

python isaaclab_arena/scripts/imitation_learning/record_demos.py \

--viz kit \

--device cpu \

--enable_cameras \

--dataset_file $DATASET_DIR/arena_g1_static_apple_dataset_recorded.hdf5 \

--num_demos 400 \

--num_success_steps 10 \

--disable_full_sim_buffer_reset \

galileo_g1_static_pick_and_place \

--object apple_01_objaverse_robolab \

--destination clay_plates_hot3d_robolab \

--teleop_device openxr

Quality matters as much as quantity here. Aim for clean demonstrations with smooth motions, stable grasps, and diverse approach directions, since noisy or inconsistent data limits how well the policy can learn. For this task, we collected 400 trajectories not all at once but stitched together through multiple sessions of data collection. You can definitely start with a smaller batch of data to understand how the pieces fit together before committing to a full set of demonstrations.

Successful demonstrations are saved to an HDF5 file, which becomes the raw input for the next stage, where it’s converted to the LeRobot format that GR00T 1.7 consumes for post-training.

Convert data format

GR00T 1.7 consumes datasets in LeRobot format, so the recorded HDF5 is converted inside the Arena container before training. The conversion is driven by a config file, g1_static_apple_config.yaml, which maps the recorded fields to what GR00T expects:

data_root: /datasets/isaaclab_arena/static_apple_tutorial

hdf5_name: "arena_g1_static_apple_dataset_recorded.hdf5"

language_instruction: "move the apple to the plate"

task_index: 3

state_name_sim: "robot_joint_pos"

action_name_sim: "processed_actions"

pov_cam_name_sim: "robot_head_cam_rgb"

fps: 50

chunks_size: 1000

Run the conversion with:

python isaaclab_arena_gr00t/lerobot/convert_hdf5_to_lerobot.py \

--yaml_file isaaclab_arena_gr00t/lerobot/config/g1_static_apple_config.yaml

This produces a lerobot folder containing parquet files with states and actions, MP4 camera recordings, and dataset metadata. Now with a converted dataset you can post-train GR00T 1.7 model.

Post-train GR00T 1.7

Post-training runs outside the Arena container, in a standalone checkout of the Isaac-GR00T repo. The fine-tuning command tunes the visual backbone, projector, and diffusion model while keeping the language model frozen:

uv run python -m torch.distributed.run --nproc_per_node=1 --standalone \

gr00t/experiment/launch_finetune.py \

--base-model-path nvidia/GR00T-N1.7-3B \

--dataset-path $DATASET_DIR/arena_g1_static_apple_dataset_recorded/lerobot \

--output-dir $MODELS_DIR/static_apple_n17_finetune \

--modality-config-path /path/to/IsaacLab-Arena/isaaclab_arena_gr00t/embodiments/g1/g1_sim_wbc_data_gr00t_n_1_7_config.py \

--embodiment-tag new_embodiment \

--global-batch-size 12 \

--max-steps 20000 \

--num-gpus 1 \

--save-steps 5000 \

--save-total-limit 5 \

--no-tune-llm \

--tune-visual \

--tune-projector \

--tune-diffusion-model \

--dataloader-num-workers 8 \

--color-jitter-params brightness 0.3 contrast 0.4 saturation 0.5 hue 0.08

Evaluate the policy

After post-training, evaluation is just two steps: load your checkpoint into a GR00T server, then run the policy in a closed loop. Arena uses a server-client setup, where the server hosts your fine-tuned model and the Arena client runs the simulation and queries the model from the server.

Run the policy by launching the client from the Arena container:

/isaac-sim/python.sh isaaclab_arena/evaluation/policy_runner.py \

--viz kit \

--policy_type isaaclab_arena_gr00t.policy.gr00t_remote_closedloop_policy.Gr00tRemoteClosedloopPolicy \

--policy_config_yaml_path isaaclab_arena_gr00t/policy/config/g1_static_apple_gr00t_closedloop_config.yaml \

--remote_host <SERVER_HOST> --remote_port 5555 \

--num_steps 600 \

--enable_cameras \

galileo_g1_static_pick_and_place \

--object apple_01_objaverse_robolab \

--destination clay_plates_hot3d_robolab \

--embodiment g1_wbc_agile_joint

Metrics print to the console as evaluation is in progress until you get a final output that tells you the performance of your post-trained policy.

[Rank 0/1] Metrics: {'success_rate': 1.0, 'object_moved_rate': 1.0, 'num_episodes': 1}

To change how much you evaluate, adjust a few flags. --num_steps sets the rollout length; 600 is a quick smoke test corresponding to about one episode for this task. For a representative success rate, evaluate complete episodes instead with --num_episodes 100 (or 1000 for a stronger estimate), and add --num_envs 5 to run environments in parallel for more randomization across trials. Everything else stays the same; you’re only changing how many rollouts you average over.

Streamlined development process

That completes a full pass through the Isaac GR00T Development Platform. Each stage produces a clean artifact that feeds directly into the next for a fully integrated, streamlined development process. While this walkthrough uses a specific embodiment as an example, the same process can be adapted to your own robot setup, define a task for your use case, collect demonstrations on your system, and reuse the same data conversion, post-training, and evaluation workflow.

A growing GR00T ecosystem

The GR00T platform and reference workflow are already being adopted across a growing ecosystem of humanoid robotics partners.

• Humanoid makers and AI providers including 1X, Agility, ANYBotics, Bellboy Robotics, FieldAI, Lightwheel AI, NEURA Robotics, Nexuni, Noble Machines, Schaeffler, Skild AI, and Techman Robot are integrating components of the GR00T platform such as Isaac Teleop, Sim, Lab, and ROS to accelerate their development pipeline and bring AI-enabled robots into real industrial use faster.

• Research institutions including Stanford, CMU, UCSD, ETH Zurich, and AI2 will be experimenting with the unified GR00T end-to-end workflow to reduce integration complexity and move faster from robot bring-up to skill development and real-world validation.

• Leading wearable and XR device makers including Haptikos, Manus, Noitom, OpenGraph Labs, PICO, Sensing, HTC Vive, Wuji, and Xsens offer devices with native support for NVIDIA Isaac Teleop, making it easier to capture high-quality demonstrations.

Getting started

The GR00T platform and GR00T 1.7 model are available today for any developer to use. Whether starting in simulation or on a physical robot, the workflow remains the same. Select an entry point, define a bounded task, and build your first end-to-end policy.

Getting started can be challenging, so we have built a complete end-to-end reference workflow, which is provided in the learning content How to Develop and Deploy Humanoid Robots End-to-End with NVIDIA Isaac GR00T, along with the GR00T Platform Introduction Video.

Additional resources:

• NVIDIA Isaac GR00T Development Platform

• Isaac Teleop & GR00T 1.7 LeRobot Integration Blog

• Isaac GR00T 1.7 Brev Launchable

• LeRobot Brev Launchable

• NVIDIA Isaac GR00T 1.7 on GitHub

• NVIDIA Isaac GR00T 1.7 on Hugging Face