Is this page helpful?

Robot Policy Examples Extension 7.0.0#

Isaac Sim 6.1 includes version 7.0.0 of the isaacsim.robot.policy.examples extension. The extension replaces PolicyController and its articulation-owning robot policy classes with RobotPolicyRunner, PolicySpec, and PolicyArtifact. The 7.0.0 version number belongs to the extension; it is not an Isaac Sim product version.

The old import paths remain available as migration shims. Importing a removed class succeeds, but constructing it raises a RuntimeError with replacement code for that class.

Shipped Policies#

Use the bundled specification that matches the old policy class:

Extension 6.x class

Extension 7.0.0 construction

AnymalFlatTerrainPolicy

RobotPolicyRunner(get_anymal_spec(), prim_path=...)

SpotFlatTerrainPolicy

RobotPolicyRunner(get_spot_spec(), prim_path=...)

Go2FlatTerrainPolicy

RobotPolicyRunner(get_go2_spec(), prim_path=...)

H1FlatTerrainPolicy

RobotPolicyRunner(get_h1_spec(), prim_path=...)

CartpolePolicy

RobotPolicyRunner(get_cartpole_spec(), prim_path=...)

FrankaOpenDrawerPolicy

RobotPolicyRunner(get_franka_spec(), prim_path=..., task_state_provider=make_franka_task_state_provider(cabinet))

For example:

from isaacsim.robot.policy.examples import RobotPolicyRunner, get_spot_spec

runner = RobotPolicyRunner(
    get_spot_spec(),
    prim_path="/World/Spot",
    position=[0.0, 0.0, 0.8],
)
runner.spawn()  # While the timeline is stopped.

# After physics starts:
runner.initialize()

def on_physics_step(dt):
    runner.step(dt, command)

Call step() once per physics tick. The runner owns policy decimation, so do not add another decimation counter around it. Use runner.articulation in place of the old policy.robot property. Before replay, reset or teleport the articulation and then call runner.initialize(). Call runner.close() during teardown.

Non-Shipped Policies#

A non-shipped policy does not use a bundled get_<robot>_spec() factory. Group the policy files in a PolicyArtifact, create a PolicySpec for the robot, and pass that spec to RobotPolicyRunner:

from isaacsim.robot.policy.examples import PolicyArtifact, PolicySpec, RobotPolicyRunner

artifact = PolicyArtifact.from_files(
    model_path="/path/to/policy.pt",
    env_config_path="/path/to/env.yaml",
    descriptor_path="/path/to/IO_descriptors.yaml",
)
spec = PolicySpec(
    name="my_policy",
    usd_path="/path/to/robot.usd",
    engines={"physx": artifact},
)
runner = RobotPolicyRunner(spec, prim_path="/World/Robot", training_engine="physx")
runner.spawn()

model_path must identify an exported TorchScript .pt or ONNX .onnx model, not a raw training checkpoint. env_config_path must identify the exported env.yaml from the same training configuration.

descriptor_path is the local path or omniverse:// URL of the exported Isaac Lab IO_descriptors.yaml file for the same task configuration used to train the model. It is not another copy of env.yaml. The descriptor records the ordered policy observations and actions, their shapes, joint names, and authored scales, offsets, and clipping. The runner uses it to reconstruct the model input and output interface without robot-specific Python code.

For an already-defined manager-based Isaac Lab task, export the file from the Isaac Lab checkout:

./isaaclab.sh -p scripts/environments/export_io_descriptors.py \
    --task <task_name> --output_dir <output_dir>

This writes <output_dir>/IO_descriptors.yaml. You can instead request the descriptor when training by adding --export_io_descriptors to the Isaac Lab training command, for example:

./isaaclab.sh -p scripts/reinforcement_learning/rsl_rl/train.py \
    --task <task_name> --export_io_descriptors

See Isaac Lab IO Descriptors 101 for the export workflow and for attaching descriptors to custom observation and action terms. IO-descriptor export is available for manager-based environments.

Use PolicyArtifact.from_training_run(run_dir) when the run contains exported/policy.pt, params/env.yaml, and io_descriptors/IO_descriptors.yaml. Use PolicyArtifact.from_bundle(bundle_dir) for a flat directory containing policy.pt or policy.onnx, env.yaml, and IO_descriptors.yaml.

The automatic binding supports the observation and joint-action terms implemented by the extension. If a custom term cannot be reconstructed from its descriptor, provide PolicySpec.binding explicitly and, when the policy reads task-owned state outside the robot articulation, provide a task_state_provider to RobotPolicyRunner. The explicit binding must preserve the trained observation/action order and preprocessing exactly; an IO descriptor alone does not make an unsupported custom term executable.