strands-isaaclab-ant-131k

The Isaac Lab Ant running forward, from a policy trained with 131,072 parallel environments on one GPU through strands-robots (≈ 624k env-steps/s median). The PPO policy was trained with strands' isaaclab train_policy provider (PR #4227); its rollouts, written with strands' DatasetRecorder, are this LeRobot v3 dataset.

4 recorded envs (2×2) from the strands camera — mp4. Policy: cagataydev/strands-isaaclab-ant-131k-policy.

episodes / frames	12 / 3600 at 60 fps (12 × 300 frames = 5 s each)
camera	observation.images.chase 320×240 RTX, chase cam attached to the torso
observation.state	75-D = 8 joint pos + 60-D policy observation (policy_obs.*) + root pos (3) + root quat xyzw (4)
action	8-D raw policy action: joint efforts for the 8 leg joints, 60 Hz
task string	"run forward as fast as possible"
episode return (mean)	19.6 (range 17.4 – 20.9)
checks	strands verify_dataset ok · LeRobotDataset load ok · video decode ok · NaN/inf = 0 · Hub round-trip ok

Results (the policy that generated this data)

Trained with 131,072 parallel envs × 100 PPO iterations (419 M env steps) in 11 min 14 s on one NVIDIA L40S (Newton/MJWarp). Mean reward -0.09 → 62.8 (best) → 62.6 (last); mean episode length 32 → 957 of 1000; throughput median 624 k env-steps/s (max 641 k, GPU shared with the Allegro run).

Scaling curve (Isaac-Ant, 40 iterations per size, same train_policy call with only num_envs changed)

num_envs	env-steps/s median	max	GPU mem Δ (MB)	wall s	result
4,096	81055	83501	1497	110.2	success
16,384	253759	260996	3643	120.3	success
65,536	523312	535462	12705	230.5	success
131,072	611919	623934	24775	390.8	success
262,144	–	–	34787	210.4	CUDA OOM

Raw rows: scaling_isaac_ant.json · script: examples/scale.py.

PPO iteration	mean reward	mean episode length (of 1000)	env-steps/s
0	-0.09	32	521,432
10	1.04	352	602,889
25	9.48	832	611,975
50	36.93	960	628,789
75	54.29	944	635,691
99	62.62	957	636,633

How it was made with strands-robots

# Isaac Lab in its OWN venv (its pins clash with strands; strands never imports it)
uv venv --python 3.12 ~/il && uv pip install --python ~/il/bin/python --prerelease=allow \
  --index https://pypi.nvidia.com --index-strategy unsafe-best-match "isaaclab[rsl-rl,isaacsim]==3.0.0rc1"
export ISAACLAB_PYTHON=~/il/bin/python
export OMNI_KIT_ACCEPT_EULA=YES          # you accept the NVIDIA Omniverse / Isaac Sim EULA yourself
pip install "git+https://github.com/cagataycali/robots@feat/isaaclab-trainer"   # strands-robots with PR #4227

1. Train (strands train_policy, isaaclab provider)

As an agent tool call (the train_policy tool is a Strands @tool):

from strands import Agent
from strands_robots.tools.train_policy import train_policy

agent = Agent(tools=[train_policy])
agent("Train Isaac-Ant with the isaaclab provider at the largest scale this GPU fits: 131072 envs, 100 iterations, seed 1.")
# -> train_policy(action="train", provider="isaaclab", steps=100, seed=1, output_dir="runs/c5_ant_131k",
#                 extra={"task": "Isaac-Ant", "num_envs": 131072, "timeout_s": 3600})

As plain Python (exactly what produced this run):

from strands_robots.tools.train_policy import train_policy

job = train_policy(action="train", provider="isaaclab", steps=100, seed=1, output_dir="runs/c5_ant_131k",
                   extra={"task": "Isaac-Ant", "num_envs": 131072, "timeout_s": 3600})   # Newton/MJWarp (task default)
train_policy(action="status", provider="isaaclab", job_id="<job_id from the result>")

Under the hood: python -m isaaclab train --rl_library rsl_rl --task Isaac-Ant --max_iterations 100 --num_envs 131072 --seed 1 in $ISAACLAB_PYTHON. Job id of this run: isaaclab-20260929-095103-667764acb8c8. Docs: docs/learn/training/isaaclab.md · PR: strands-labs/robots#4227.

2. Record (strands Policy + DatasetRecorder)

The final checkpoint was rolled out and recorded with examples/record_trained_policy.py (included): rebuild the task env in play mode with an RTX camera → load model_99.pt with rsl_rl and export TorchScript/ONNX → wrap the actor as a strands Policy (RslRlJitPolicy, max |Δa| vs rsl_rl = 6.0e-08) → step with policy.get_actions_sync(...) → write every frame through strands DatasetRecorder (LeRobot v3) → verify with strands verify_dataset.

OMNI_KIT_ACCEPT_EULA=YES PYTHONPATH=/path/to/strands-robots $ISAACLAB_PYTHON examples/record_trained_policy.py \
  --task Isaac-Ant --checkpoint model_99.pt --episodes 12 --frames 300 \
  --cam chase --attach Robot/torso --eye 2.5,-3.0,1.8 \
  --task_str "run forward as fast as possible" --robot_type ant --root out/ds --repo_id cagataydev/strands-isaaclab-ant-131k
$ISAACLAB_PYTHON examples/record_trained_policy.py --verify out/ds --repo_id cagataydev/strands-isaaclab-ant-131k

Use it

from lerobot.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("cagataydev/strands-isaaclab-ant-131k")
print(ds.num_episodes, ds.num_frames)            # 12 3600
x = ds[0]; print(x["observation.state"].shape, x["action"].shape, x["observation.images.chase"].shape)
# (75,) (8,) (3, 240, 320)

Train an imitation policy on it with strands:

from strands_robots.tools.train_policy import train_policy
train_policy(action="train", provider="lerobot", dataset_repo_id="cagataydev/strands-isaaclab-ant-131k",
             output_dir="runs/act_ant", steps=20000, batch_size=32, extra={"policy_type": "act"})

Provenance

• strands-robots: feat/isaaclab-trainer @ fa66fc68 — strands-labs/robots#4227 (isaaclab train_policy provider; DatasetRecorder; verify_dataset)
• Isaac Lab 3.0.0rc1 · Isaac Sim 6.1.0.0 · Newton / MJWarp (task default physics) · rsl-rl-lib 5.4.1 (PPO) · lerobot 0.6.1
• GPU: 1× NVIDIA L40S (46 GB), shared with the Allegro reorientation training (~8.4 GB)
• Seeds: training seed 1 (params/agent.yaml, params/env.yaml); recording seed 7
• Training job: isaaclab-20260929-095103-667764acb8c8, 2026-09-29

Limitations

• Simulation only; the Ant is a classic simulated benchmark robot.
• Release candidates: Isaac Lab 3.0.0rc1 / Isaac Sim 6.1.0.0. Trained on the task's default Newton/MJWarp physics; the checkpoint does not remember the preset (IL-X-011) — replay on the same physics.
• This is a throughput demo, not a converged policy: 100 iterations at 131,072 envs (419 M env steps in ~11 min). The reward was still rising at the end; the Ant runs forward but is not tuned. 262,144 envs ran out of CUDA memory on the shared 46 GB L40S, and the strands status message did not surface the OOM (finding IL-X-007).
• Scaling numbers were measured with another training (Allegro, ~8.4 GB) on the same GPU; a solo GPU would be somewhat faster.
• Recording: 12 parallel envs, 300 frames (5 s @ 60 fps) each from one fixed camera; all 12 episodes ran the full 300 frames (5 s @ 60 fps). observation.state = 8 joint pos + 60-D policy observation + root pos/quat (75-D), not a standard LeRobot robot state.
• create_policy("rl") in strands cannot load rsl_rl checkpoints yet (IL-X-006); use the exported TorchScript + the wrapper above.

License

Card choice: license: other — our generated data / weights under CC-BY-4.0, plus NVIDIA notices. Why:

• Trajectories, rendered camera video, playback clips and trained weights are user-generated content made with NVIDIA Isaac Sim / Isaac Lab; the NVIDIA Omniverse License Agreement (governs Isaac Sim 6.1, isaacsim/LICENSE.txt) §2.1 allows distributing "user generated content that you develop using Omniverse, such as video, audio, stills, models, 3D assets and screen captures". We release it under CC-BY-4.0.
• No NVIDIA Content is redistributed: the Ant USD (Robots/IsaacSim/Ant/ant_instanceable.usd) comes from the Isaac Lab / Isaac Sim asset packs and are not in this repo (params/env.yaml only references their paths). No endorsement by NVIDIA is implied.
• params/*.yaml are Isaac Lab configurations (BSD-3-Clause); examples/* are Apache-2.0 like strands-robots. Running Isaac Sim requires your own acceptance of the NVIDIA Isaac Sim / Omniverse EULA. Full text: LICENSE.md.