Ping the Isaac Sim extension server and return scene information including stage path, assets root, and prim count.

Create a physics scene with ground plane. Call get_scene_info first to verify connection.

Args: gravity: Gravity vector [x, y, z]. Default is standard gravity. scene_name: Name for the physics scene prim.

Remove all prims from the scene.

Args: keep_physics: If True, keep physics scene prims.

List all prims in the scene, optionally filtered by type.

Args: root_path: Root path to start listing from. prim_type: Filter by prim type (e.g. "Mesh", "Xform").

Get detailed information about a specific prim.

Returns type, world-space position, and children. For geometric prims (Cube, Sphere, Cylinder, Cone, Capsule), also returns actual_size [x, y, z] in meters accounting for scale and default primitive dimensions.

Args: prim_path: The USD prim path to inspect.

List all available environments discovered from the Isaac Sim asset server. Includes warehouses, offices, outdoor scenes, and more.

Load a pre-built environment into the scene. Supports fuzzy matching. Call list_environments first to see available options.

Args: environment: Environment name or search term (e.g. "warehouse", "hospital", "office"). prim_path: Prim path for the loaded environment.

Create a primitive object (Cube, Sphere, Cylinder, Cone, Capsule, Plane).

The scale parameter multiplies the primitive's default size. For example, a Cube has default size 2.0, so scale=[0.5, 0.5, 0.5] creates a 1.0m cube.

Returns prim_path, actual_size [x, y, z] in meters, and bounding_box (min/max corners in world coordinates) so you can accurately place other objects relative to this one (e.g. placing a cube on top of a table).

Args: object_type: Type of primitive — Cube, Sphere, Cylinder, Cone, Capsule, or Plane. position: [x, y, z] world position. rotation: [rx, ry, rz] rotation in degrees. scale: [sx, sy, sz] scale factors. color: [r, g, b] color values (0-1). physics_enabled: Enable physics on this object. prim_path: Custom prim path. Auto-generated if not provided.

Delete an object from the scene.

Args: prim_path: The prim path of the object to delete.

Set the transform (position, rotation, scale) of an existing object.

Args: prim_path: The prim path of the object to transform. position: [x, y, z] new world position. rotation: [rx, ry, rz] new rotation in degrees. scale: [sx, sy, sz] new scale factors.

Duplicate an existing object to a new prim path.

Args: source_path: Prim path of the object to clone. target_path: Prim path for the cloned object. position: [x, y, z] position for the clone. Keeps original position if not set.

Create a light in the scene.

Args: light_type: Type of light — DistantLight, DomeLight, SphereLight, RectLight, DiskLight, or CylinderLight. position: [x, y, z] world position. intensity: Light intensity. color: [r, g, b] light color (0-1). rotation: [rx, ry, rz] rotation in degrees. prim_path: Custom prim path. Auto-generated if not provided.

Modify properties of an existing light.

Args: prim_path: The prim path of the light to modify. intensity: New intensity value. color: [r, g, b] new light color (0-1).

Create a robot in the scene from the Isaac Sim asset library.

Supports fuzzy matching — e.g. "franka", "spot", "g1", "go1". Call list_available_robots first to see all available robots. Call create_physics_scene before creating robots.

Returns prim_path, robot_key, joint_names, and num_dof so you can immediately use set_joint_positions without a follow-up get_robot_info call.

Args: robot_type: Robot name or search term. Fuzzy matched against available robots. position: [x, y, z] world position. name: Custom name for the robot prim. prim_path: Exact USD prim path (e.g. "/World/Franka"). Overrides name-based path.

List all available robots discovered from the Isaac Sim asset server. Returns robot keys, descriptions, manufacturers, and asset paths. The list is auto-discovered at startup and reflects the actual assets available in your Isaac Sim version.

Force re-scan the asset server for available robots. Use this if new robot assets were added.

Get robot joint information including names, DOF count, joint types, and limits.

Call this after create_robot to understand the robot's kinematic structure. Returns joint names ordered by DOF index, joint types (revolute/prismatic), and joint limits (degrees for revolute, meters for prismatic).

Args: prim_path: The prim path of the robot.

Set target joint positions on a robot via ArticulationAction.

Units: radians for revolute joints, meters for prismatic joints (e.g. gripper fingers). Use get_robot_info to discover joint names, types, and limits first. After calling this, use step_simulation to advance and observe the result — do not use play_simulation + sleep.

Args: prim_path: The prim path of the robot. joint_positions: List of target joint position values. joint_indices: Optional list of joint indices to set. Sets all joints if not provided.

Read current joint positions from a robot.

Units: radians for revolute joints, meters for prismatic joints. Joint order matches the joint_names from get_robot_info. For a combined step-and-read, prefer step_simulation with observe_joints.

Args: prim_path: The prim path of the robot.

Add a camera sensor to the scene.

Args: prim_path: Prim path for the camera. position: [x, y, z] world position. rotation: [rx, ry, rz] rotation in degrees. resolution: [width, height] image resolution. Default 1280x720.

Capture an RGB image from a camera sensor.

Args: prim_path: Prim path of the camera. output_path: File path to save the image. Returns metadata only if not set.

Add a lidar sensor to the scene.

Args: prim_path: Prim path for the lidar. position: [x, y, z] world position. rotation: [rx, ry, rz] rotation in degrees. config: Lidar configuration name (e.g. "Example_Rotary").

Get point cloud data from a lidar sensor.

Args: prim_path: Prim path of the lidar sensor.

Create a PBR or physics material.

Args: material_type: "pbr" for visual material or "physics" for physics material. prim_path: Prim path for the material. Auto-generated if not set. color: [r, g, b] diffuse color (0-1). PBR only. roughness: Surface roughness (0-1). PBR only. metallic: Metallic value (0-1). PBR only.

Bind a material to an object.

Args: material_path: Prim path of the material. target_prim_path: Prim path of the object to apply the material to.

Import a robot from a URDF file into the scene.

Args: urdf_path: Path to the URDF file. prim_path: Prim path for the imported robot. position: [x, y, z] world position.

Load a USD asset from a URL or file path into the scene.

Args: usd_url: URL or local path to the USD file. prim_path: Prim path for the loaded asset. position: [x, y, z] world position. scale: [sx, sy, sz] scale factors.

Search the NVIDIA USD asset library by text description, then load the best match.

Args: text_prompt: Text description of the 3D asset to search for. target_path: Prim path for the loaded result. position: [x, y, z] world position. scale: [sx, sy, sz] scale factors.

Generate a 3D model from text or image using Beaver3D, then load it into the scene.

Args: text_prompt: Text description for 3D generation. image_url: URL of an image for 3D generation. position: [x, y, z] world position for the generated model. scale: [sx, sy, sz] scale factors.

Start the physics simulation.

Pause the physics simulation.

Stop the physics simulation.

Step the simulation forward by N frames, then observe prim and joint states.

This is the primary tool for debugging robot behavior. Use it instead of play_simulation + sleep + execute_script. The observe parameters let you inspect positions, velocities, and joint states in a single call.

Typical debug loop:

1. set_joint_positions to command the robot

2. step_simulation with observe_prims and observe_joints

3. get_joint_config if drives are not tracking correctly

4. get_physics_state if objects are not behaving as expected

5. Adjust and repeat

Args: num_steps: Number of simulation frames to step. observe_prims: List of prim paths to observe (returns position + velocity). observe_joints: List of articulation prim paths to observe (returns joint positions).

Configure physics engine parameters.

Args: gravity: Gravity vector [x, y, z]. time_step: Physics time step in seconds. gpu_enabled: Enable GPU-accelerated physics.

Diagnostic tool: get recent warnings and errors from the Isaac Sim console.

Call this after any tool returns an error, after simulation behavior is unexpected, or after execute_script / reload_script fails. Helps diagnose physics warnings, collision issues, and script errors that are not surfaced in tool responses.

Args: clear: Clear the log buffer after reading. Default True. count: Maximum number of log entries to return.

Get the current simulation state including timeline status (playing/stopped/paused), simulation time, and physics dt. Call this to verify the simulation is running before using step_simulation.

Diagnostic tool: get physics state for a prim.

Returns rigid body status, mass, velocities, kinematic flag, and collision info. Call this when:

• Objects fall through the ground (check collision enabled)

• Objects don't move when expected (check is_kinematic, mass)

• Grasping fails (check collision on gripper fingers and target object)

Args: prim_path: USD path to the prim to inspect.

Diagnostic tool: get joint drive configuration for a robot articulation.

Returns stiffness, damping, limits, target vs actual positions, and position error for each joint. Call this when:

• Joint drives are not tracking targets (check position_error)

• Joints are oscillating or unstable (check stiffness/damping ratio)

• Joints hit limits unexpectedly (check lower_limit/upper_limit)

Args: prim_path: USD path to the robot articulation root.

Escape hatch: execute arbitrary Python code in Isaac Sim.

PREFER named tools over this for: reading/setting joints (set_joint_positions, get_joint_positions), inspecting state (get_prim_info, get_physics_state, get_joint_config), stepping simulation (step_simulation), and checking logs (get_isaac_logs).

USE this for: operations no named tool covers, such as creating Action Graphs, computing IK, setting up physics callbacks, or configuring advanced USD properties.

For persistent controllers (>20 lines), write a .py file and load it with reload_script instead of pasting code here.

Args: code: Python code to execute in the Isaac Sim context. cwd: Optional working directory to add to sys.path before execution.

Load a Python controller or module into Isaac Sim from a file on disk.

Use this instead of execute_script for persistent controllers, state machines, or any code longer than ~20 lines. Workflow:

1. Write the controller as a .py file

2. reload_script to load it into Isaac Sim

3. step_simulation to debug the behavior

4. Edit the file and reload_script again to iterate

The file's directory is auto-added to sys.path.

Args: file_path: Path to the Python file on disk. module_name: Optional module name to reload (e.g. 'my_controller').

Create and wire an OmniGraph Action Graph.

Builds a complete Action Graph with nodes, connections and attribute values using og.Controller.edit(). This is the programmatic equivalent of creating an Action Graph in the visual editor.

Args: graph_path: USD prim path for the graph (default "/World/ActionGraph"). nodes: List of node definitions. Each dict has: - "path": Node path relative to graph (e.g. "OnPlaybackTick") - "type": OmniGraph node type (e.g. "omni.graph.action.OnPlaybackTick") connections: List of [source_attr, target_attr] pairs for wiring nodes. Each attr is "NodePath.outputs:attrName" or "NodePath.inputs:attrName". values: List of attribute value overrides. Each dict has: - "attr": Full attribute path (e.g. "ScriptNode.inputs:script") - "value": The value to set evaluator: Graph evaluator type (default "push"). script_file: Convenience shortcut — path to a local Python script file. When provided, automatically creates OnPlaybackTick → ScriptNode nodes, wires them, and attaches the script file (sets usePath + scriptPath). The nodes and connections parameters are ignored when script_file is set.

Example (inline script): create_action_graph( values=[ {"attr": "ScriptNode.inputs:script", "value": "def compute(db): ..."} ] )

Example (script file — one-step): create_action_graph( script_file="/path/to/controller.py" )

Edit an existing OmniGraph Action Graph: set attribute values or add connections.

Use this to update ScriptNode scripts (inline or file path), change attribute values, or add new connections on an already-created graph.

For ScriptNode with a local file script, set both usePath and scriptPath: values=[ {"attr": "ScriptNode.inputs:usePath", "value": true}, {"attr": "ScriptNode.inputs:scriptPath", "value": "/path/to/script.py"} ]

For ScriptNode with inline script: values=[ {"attr": "ScriptNode.inputs:usePath", "value": false}, {"attr": "ScriptNode.inputs:script", "value": "def compute(db): ..."} ]

Args: graph_path: USD prim path of the existing graph (default "/World/ActionGraph"). values: List of attribute value overrides. Each dict has: - "attr": Attribute path relative to graph (e.g. "ScriptNode.inputs:script") - "value": The value to set connections: List of [source_attr, target_attr] pairs to add.