strands-isaaclab-shadow-handover

Two Shadow Dexterous Hands pass an object from one hand to the other and bring it to a goal, in NVIDIA Isaac Lab, recorded through strands-robots. 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-shadow-handover-policy.

episodes / frames	12 / 2857 at 60 fps (up to 300 frames = 5 s each; 9 full, 3 ended on a drop)
camera	observation.images.front 320×240 RTX, fixed (eye 1.0,-1.5,1.05 → target 0,-0.5,0.55)
observation.state	321-D = 24 right-hand joint pos + 290-D two-hand policy observation (policy_obs.*) + root pos (3) + root quat xyzw (4)
action	40-D raw policy action: 20 actuated joints per hand × 2 (right then left), 60 Hz
task string	"pass the object from one hand to the other and bring it to the goal"
episode return (mean)	13.0 (range 0.0 – 17.5)
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 2048 parallel envs × 1500 PPO iterations (49 M env steps) in 45 min 35 s on one NVIDIA L40S (Newton/MJWarp). Mean reward 0.00 → 25.2 (best) → 23.3 (last); handover success 0.89 at the last iteration (peak 0.96); final object-to-goal distance ≈ 4 cm; throughput median 16 k env-steps/s (max 47 k, GPU shared with the cable-lift run).

PPO iteration	mean reward	handover success	env-steps/s
0	0.00	0.000	27,700
100	0.32	0.002	19,498
300	15.47	0.638	40,439
600	19.51	0.767	16,978
900	20.58	0.791	15,199
1200	24.09	0.939	14,530
1499	23.26	0.892	14,438

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 two Shadow hands to hand an object over with the isaaclab provider: task Isaac-Shadow-Handover, 1500 iterations, seed 1.")
# -> train_policy(action="train", provider="isaaclab", steps=1500, seed=1, output_dir="runs/c6_shadow_handover",
#                 extra={"task": "Isaac-Shadow-Handover", "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/c6_shadow_handover",
                   extra={"task": "Isaac-Shadow-Handover", "timeout_s": 10800})   # task default: 2048 envs, Newton/MJWarp physics
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-Shadow-Handover --max_iterations 1500 --seed 1 in $ISAACLAB_PYTHON. Job id of this run: isaaclab-20260929-081406-931b9b40e4ff. 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_1499.pt with rsl_rl and export TorchScript/ONNX → wrap the actor as a strands Policy (RslRlJitPolicy, max |Δa| vs rsl_rl = 1.5e-06) → 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-Shadow-Handover --checkpoint model_1499.pt --episodes 12 --frames 300 \
  --cam fixed --cam_name front --eye 1.0,-1.5,1.05 --target 0,-0.5,0.55 \
  --task_str "pass the object from one hand to the other and bring it to the goal" --robot_type shadow_hand_x2 --root out/ds --repo_id cagataydev/strands-isaaclab-shadow-handover
$ISAACLAB_PYTHON examples/record_trained_policy.py --verify out/ds --repo_id cagataydev/strands-isaaclab-shadow-handover

Use it

from lerobot.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("cagataydev/strands-isaaclab-shadow-handover")
print(ds.num_episodes, ds.num_frames)            # 12 2857
x = ds[0]; print(x["observation.state"].shape, x["action"].shape, x["observation.images.front"].shape)
# (321,) (40,) (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-shadow-handover",
             output_dir="runs/act_handover", 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 Franka cable-lift training
• Seeds: training seed 1 (params/agent.yaml, params/env.yaml); recording seed 7
• Training job: isaaclab-20260929-081406-931b9b40e4ff, 2026-09-29

Limitations

• Simulation only; no real Shadow Hands were used; no sim-to-real claims.
• 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.
• Not every rollout succeeds: training success is 0.89 (peak 0.96), and in the recording 3 of 12 episodes ended early when the object was dropped (lengths 43, 49 and 65 frames); the other 9 ran the full 5 s.
• Recording: 12 parallel envs, 300 frames (5 s @ 60 fps) each from one fixed camera; an episode ends at 300 frames or when the object is dropped. observation.state = 24 joint pos of the right hand only + 290-D two-hand policy observation + root pos/quat (321-D); the left hand's state is inside policy_obs.*. 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 Shadow Hand USDs (Robots_Multiphysics/ShadowRobot/ShadowHandMultiPhysics_v0/…) and the ground-plane asset come from the Isaac Lab / Isaac Sim asset packs and are not in this repo (params/env.yaml only references their paths). "Shadow Hand" is a product of The Shadow Robot Company; no endorsement by Shadow Robot or 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.