Build a Robot Pick-and-Place Simulation with SimReady Assets

A Hugging Face Blog walkthrough lays out an end-to-end pipeline for a beverage can pick-and-place task built from SimReady assets in NVIDIA's Isaac Sim, using the UR17G robot arm, the Robotiq 2F-140 gripper and a beverage can. The example targets Isaac Sim 6.2, the version the walkthrough was built against. The workflow downloads the three assets from SimReady Central, an open asset library hosted on Hugging Face, composes them into a single scene, validates the assembly, and then runs agent-generated control code that grasps the can, lifts it, moves it to a target and releases it.
SimReady, in this context, means an OpenUSD asset has been prepared with the properties a specific simulation use case needs, such as collisions, mass, joints and joint drives. SimReady Central lets developers reuse robot and object assets that already carry those authored properties plus profile-validation evidence, rather than authoring physics setup themselves. The structure runs in three levels: a profile groups features for a use case (for instance a robot body), features are the capabilities that use case requires (such as controllable joints), and requirements are the checks on the settings behind each feature, such as a joint's drive configuration. For this task, the relevant properties are the arm and gripper joints plus the can's collisions and mass.
The asset packages ship the models and their simulation settings; the user supplies the scene assembly, the work surface, starting positions, and the controls that move the arm and open or close the gripper. Validation reports in the walkthrough use the Robot-Body 4.0.0 profile for the arm and Robot-Gripper 3.0.0 for the gripper, and both record passing PhysX driven-joint checks, which inspect joint-drive settings. The walkthrough's framing is that profile validation gives a shared baseline for reuse, while the actual pick-and-place run tests how arm, gripper, can and controller behave together.
Prerequisites are Isaac Sim 6.2 with its system requirements met, an agent configured with the bundled Isaac Sim skills per the Agent Skills documentation, and optionally the Hugging Face CLI if assets are pulled from the command line. The walkthrough also points to the USD Search endpoint for finding OEM-curated content. Assets should be downloaded as complete folders and left intact so Isaac Sim can resolve supporting files, and the agent is given local USD paths for the arm, gripper and can.
The recommended checks before attempting a grasp are worth noting for anyone doing similar work: a robot can look correct while stationary yet behave wrongly once simulated. So the walkthrough tests joint limits and drive settings, a small arm movement with gripper open and close, and contact behavior so the can rests on the work surface instead of falling through it. Isaac Sim is then started from its install directory with the remote Python server enabled — the example command is `./isaac-sim.sh --enable isaacsim.code_editor.python_server` — so the agent can drive the simulation through Python. The agent itself should be launched from the Isaac Sim directory so it reaches the needed skills.
Assembly is handled by prompting the agent to join the arm and gripper using the Robot Assembly documentation and to validate the result. The agent uses the `isaac-sim-remote` and `usd-articulation` skills packaged with Isaac Sim, producing one articulation that can be controlled as a unit. A manual route via the Robot Assembler tutorial exists for teams that prefer it. The task phase uses a prompt asking for a contact-based grasp, a run of the pick-and-place, and validation of placement error, drawing on the `isaac-sim-remote`, `manipulaiton-ik` and `physics-simulation` skills (the name is spelled that way in the walkthrough).
The demonstration model is GPT-6 Sol, with the caveat that another agent and model combination may work if it can load the required skills and execute Python against Isaac Sim, and that generated code and results can vary. This suggests the example is a template rather than a guaranteed pipeline: teams should expect to inspect generated code and adapt it.
Success criteria center on whether the can stays in the gripper throughout the approach, grasp, lift, hold, transfer and release sequence and lands accurately at the target, marked in yellow for pickup and green for destination. If a run diverges, the guidance is to identify where the sequence fails, ask the agent to inspect the scene and regenerate controls, and reset robot and can to identical starting state before retrying so runs are comparable.
The walkthrough is explicit about what the setup does not model. The can starts at a known position, the robot is anchored, the workspace is flat and clear, no vision is used and collision checks were limited. The can is simplified: no deformation or liquid motion, so crushing is out of scope. The grasp is scripted: a horizontal grasp with a 2 N·m drive-effort cap chosen through simulation testing rather than calibrated to fingertip forces or recommended by the manufacturer. Contact and friction hold the can while the arm follows fixed waypoints without replanning. The stated conclusion is that results apply to this scripted setup and do not establish robustness to uncertain object positions, different payloads or real hardware.
The post also points to next steps: browsing SimReady Central, checking an asset's profiles and requirements in SimReady Foundation alongside its validation reports, following the Isaac Sim installation and Agent Skills docs, contributing assets via the SimReady Central submission guide and the "5 Steps to Create SimReady Assets for Robotics" guide, and drawing inspiration from community demos such as Michael Wagner's voice-controlled VR demo and Maziyar Panahi's Microduck simulation.
Why it matters: Robotics teams evaluating simulation-first workflows get a concrete, reproducible reference — specific asset versions, profile versions, commands and test checks — for going from an asset library to a running manipulation task without authoring physics properties from scratch. The explicit assumptions list is as useful as the recipe: it tells developers where they must add vision, replanning or calibrated grasping before results transfer to real hardware, which by inference is the gap most teams will need to close themselves. The agent-driven assembly and control step, with its warning that generated code and results vary, suggests a workflow where the agent accelerates setup but human inspection remains part of the loop.
Based on reporting from the original publisher. Visit the source for full context and later updates.