strands-isaaclab-anymald-rough

ANYbotics ANYmal-D quadruped walking over rough terrain, recorded in NVIDIA Isaac Lab through strands-robots. A PPO policy trained with strands' isaaclab train_policy provider (PR #4227) trots the 12-DoF ANYmal-D over procedurally generated rough terrain while tracking a commanded base velocity; its rollouts were recorded as a LeRobot v3 dataset with strands' DatasetRecorder.

4 of the recorded envs (2×2 grid) from the strands camera — mp4. Policy: cagataydev/strands-isaaclab-anymald-rough-policy.

episodes / frames	12 / 6000 at 50 fps
camera	observation.images.chase 320×240 RTX, chase cam attached to the base
observation.state	254-D = 12 joint pos + 235-D policy observation (policy_obs.*, incl. height scan) + root pos (3) + root quat xyzw (4)
action	12-D raw policy action (joint position targets, scaled by the task's action scale), 50 Hz
task string	"walk over rough terrain following the commanded base velocity"
episode return (mean)	11.6 (range 4.7 – 13.6); all 12 episodes ran the full 10 s without falling
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 4096 parallel envs × 1500 PPO iterations (147 M env steps) in 67 min 15 s on one NVIDIA L40S (PhysX). Mean reward -0.53 → 16.6 (best) → 14.4 (last), velocity-tracking success 0.90 at the last iteration (Isaac Lab Metrics/success_rate: |v_xy error| < 0.5 m/s and |yaw-rate error| < 0.8 rad/s), terrain curriculum level 6.0, base-contact terminations 0.113; throughput median 36 k env-steps/s (max 58 k; the GPU was shared with the Cassie rough-terrain run for the whole training).

PPO iteration	mean reward	velocity-tracking success	mean ep. length (of 1000)	terrain curriculum level	env-steps/s
0	-0.53	0.081	12	3.51	22,425
150	7.28	0.506	817	0.12	34,758
375	13.65	0.919	921	2.70	36,341
750	13.45	0.886	931	5.74	35,673
1125	15.21	0.907	954	6.04	57,527
1499	14.43	0.902	932	5.99	31,706

How it was made with strands-robots

Setup

# 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 through the isaaclab train_policy 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 the ANYbotics ANYmal-D to walk on rough terrain with the isaaclab provider: task Isaac-Velocity-Rough-AnymalD, 4096 envs, PhysX, 1500 iterations, seed 1.")
# -> train_policy(action="train", provider="isaaclab", steps=1500, seed=1, output_dir="runs/c4_anymald_rough",
#                 extra={"task": "Isaac-Velocity-Rough-AnymalD", "num_envs": 4096, "physics": "isaacsim_physx", "timeout_s": 10800})

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=1500, seed=1,
                   output_dir="runs/c4_anymald_rough",
                   extra={"task": "Isaac-Velocity-Rough-AnymalD", "num_envs": 4096, "physics": "isaacsim_physx", "timeout_s": 10800})
# poll: iteration, rewards, learning verdict, steps_per_s, checkpoint_dir
train_policy(action="status", provider="isaaclab", job_id="<job_id from the result>")

Under the hood the provider runs python -m isaaclab train --rl_library rsl_rl --task Isaac-Velocity-Rough-AnymalD --max_iterations 1500 --num_envs 4096 --seed 1 physics=isaacsim_physx in $ISAACLAB_PYTHON and parses its log. Job id of this run: isaaclab-20260929-064750-44b7c0a1f62a. Docs: docs/learn/training/isaaclab.md · PR: strands-labs/robots#4227.

2 · Record with strands DatasetRecorder

The final checkpoint was rolled out and recorded with examples/record_trained_policy.py (included in this repo). It runs in the Isaac Lab venv with strands on PYTHONPATH and:

1. rebuilds the task env in play mode and adds an RTX camera per env;
2. loads model_1499.pt with rsl_rl's OnPolicyRunner and exports TorchScript/ONNX with Isaac Lab's exporter;
3. wraps the exported actor as a strands Policy (RslRlJitPolicy, max |Δa| vs rsl_rl inference = 1.8e-07);
4. steps the env with policy.get_actions_sync(...) and writes every frame through strands DatasetRecorder (strands_robots.dataset_recorder.DatasetRecorder.create(...) → add_frame → save_episode, LeRobot v3);
5. verifies the result with strands verify_dataset + LeRobotDataset load + video decode + NaN scan.

OMNI_KIT_ACCEPT_EULA=YES PYTHONPATH=/path/to/strands-robots $ISAACLAB_PYTHON examples/record_trained_policy.py \
  --task Isaac-Velocity-Rough-AnymalD --checkpoint model_1499.pt --episodes 12 --frames 500 \
  --cam chase --override physics=isaacsim_physx \
  --task_str "walk over rough terrain following the commanded base velocity" --robot_type anymal_d \
  --root out/ds --repo_id cagataydev/strands-isaaclab-anymald-rough --attach Robot/base --eye 1.4,-2.0,0.6
$ISAACLAB_PYTHON examples/record_trained_policy.py --verify out/ds --repo_id cagataydev/strands-isaaclab-anymald-rough

Use it

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("cagataydev/strands-isaaclab-anymald-rough")
print(ds.num_episodes, ds.num_frames, ds.fps)          # 12 6000 50
f = ds[0]; f["observation.state"].shape, f["action"].shape, f["observation.images.chase"].shape
# (254,) (12,) (3, 240, 320)

Check it with strands (the same verifier strands runs after stop_recording):

from huggingface_hub import snapshot_download
from strands_robots.verify_dataset import verify_dataset

root = snapshot_download("cagataydev/strands-isaaclab-anymald-rough", repo_type="dataset")
report = verify_dataset(root, expected=12)
assert report["ok"], report["problems"]

Train a LeRobot policy on it (behaviour cloning of the RL expert) with strands' lerobot_local train_policy provider — same tool, different provider (not run for this card):

from strands_robots.tools.train_policy import train_policy
train_policy(action="train", provider="lerobot_local", dataset_repo_id="cagataydev/strands-isaaclab-anymald-rough",
             output_dir="runs/act_anymald", steps=20000, batch_size=32, extra={"policy_type": "act"})

To replay the expert itself, see the policy repo: cagataydev/strands-isaaclab-anymald-rough-policy.

Provenance

• strands-robots: feat/isaaclab-trainer @ fa66fc68 — strands-labs/robots#4227 (isaaclab train_policy provider, IsaacLabTrainer; DatasetRecorder; verify_dataset)
• Isaac Lab 3.0.0rc1 · Isaac Sim 6.1.0.0 · PhysX (physics=isaacsim_physx) · rsl-rl-lib 5.4.1 (PPO) · lerobot 0.6.1 · torch on CUDA
• GPU: 1× NVIDIA L40S (46 GB), shared with the Cassie rough-terrain run for all of training
• Seeds: training seed 1 (params/agent.yaml, params/env.yaml); recording seed 7
• Training job: isaaclab-20260929-064750-44b7c0a1f62a, 2026-09-29
• Recording: examples/record_trained_policy.py, play-mode env cfg, recording seed 7, 102 s wall (policy 4.8 ms / env step 58 ms with RTX rendering)

Limitations

• Simulation only. Nothing here was run on a real ANYbotics ANYmal-D; no sim-to-real claims (the policy was not trained with sim-to-real hardening beyond Isaac Lab's default randomization).
• Release candidates: Isaac Lab 3.0.0rc1 on Isaac Sim 6.1.0.0; APIs and physics may change. PhysX and Newton results differ.
• Physics preset matters (IL-X-011): trained and recorded on PhysX only; always pass physics=isaacsim_physx when playing it (the provider does not remember the preset; the G1 PhysX policy falls in < 1.1 s when replayed on Newton).
• Recording: 12 parallel envs from a common reset, 500 frames (10 s) each with a chase camera; all 12 ran the full window. observation.state mixes joint positions with the policy observation (incl. height scan), so it is wide (254-D) and not a standard LeRobot "robot state".
• Actuator network: ANYmal-D uses Isaac Lab's LSTM actuator model (ActuatorNetLSTM); the recording script therefore runs the rollout inside torch.inference_mode() (resetting the env outside it crashes on inference tensors). The ANYdrive LSTM weights (IsaacLab/ActuatorNets/ANYbotics/anydrive_3_lstm_jit.pt) are NVIDIA-hosted content, only referenced in params/env.yaml and not redistributed here.
• create_policy("rl") in strands cannot load this rsl_rl checkpoint yet (finding IL-X-006: strands' RL actor is Tanh, rsl_rl is ELU
  • obs-normalizer); use the exported TorchScript + the small wrapper shown above.
• Known provider findings tracked with the PR: IL-X-001 (NaN reward not surfaced), IL-X-004/005 (no stop / play action), IL-X-007 (status text hid a crash traceback).

License

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

• The recorded trajectories, rendered camera video, playback clips and the trained policy weights are user-generated content produced with NVIDIA Isaac Sim / Isaac Lab. The NVIDIA Omniverse License Agreement (which governs Isaac Sim 6.1, shipped as isaacsim/LICENSE.txt) §2.1 explicitly allows you to "distribute user generated content that you develop using Omniverse, such as video, audio, stills, models, 3D assets and screen captures". We release that content under CC-BY-4.0.
• No NVIDIA Content is redistributed: the ANYbotics ANYmal-D USD (IsaacLab/Robots/ANYbotics/ANYmal-D/anymal_d.usd) and scene assets come from the Isaac Lab / Isaac Sim asset packs on NVIDIA's asset server and are not in this repo; params/env.yaml only references their paths. To reproduce you download them under your own NVIDIA EULA acceptance. The rough terrain is procedurally generated by Isaac Lab. "ANYbotics ANYmal-D" is a product of ANYbotics; no endorsement by ANYbotics or NVIDIA is implied.
• params/*.yaml are Isaac Lab task / agent configurations (Isaac Lab is BSD-3-Clause); the example script is Apache-2.0 like strands-robots. Running Isaac Sim itself requires accepting the NVIDIA Isaac Sim / Omniverse EULA.