SimRig: From Prompt to Robot Behavior

Today we are open-sourcing SimRig, an agent-guided workflow for turning MuJoCo robots into trained policies, evaluated checkpoints, and interactive browser previews.

SimRig combines a Python command-line interface with an agent skill for Codex, Claude Code, Cursor, and other coding agents. Together they provide a structured path from a robot model and a requested behavior to the less visible work that makes a training run meaningful: observations, actions, rewards, resets, termination conditions, validation, evaluation, and reproducible artifacts.

The central idea is simple:

A robot model is not a training task. SimRig helps an agent turn one into an explicit, testable workflow.

SimRig v0 uses MuJoCo and MuJoCo Playground. It is open source under the MIT license.

Why We Built It

Robot-learning tools are powerful, but the path from “make this robot walk” to a trustworthy experiment is still fragmented.

Before training begins, someone has to inspect the model, identify its joints and actuators, decide whether an existing environment fits, define the task when it does not, and verify that reset and step behavior are valid. After training, someone still has to evaluate the checkpoint, reproduce the conditions, and make the behavior visible.

Coding agents can help with this work, but they need an interface and a set of guardrails. Without them, it is too easy to mistake a model that compiles for an environment that can learn, or a rollout that completed for a task that succeeded.

SimRig makes the workflow explicit:

inspect -> define -> validate -> smoke-test -> train -> evaluate -> preview

Each stage produces something that can be checked before moving to the next one.

One Interface for Existing and Custom Tasks

When a matching MuJoCo Playground environment already exists, SimRig can inspect it and move directly through smoke testing, PPO training, evaluation, and preview:

simrig inspect-env Go1JoystickFlatTerrain
simrig smoke Go1JoystickFlatTerrain --steps 10
simrig train Go1JoystickFlatTerrain --preset smoke

For a custom MJCF or XML robot, the process starts with the model:

simrig inspect-model path/to/robot.xml --save-report
simrig view-model path/to/robot.xml --port 8766

Once the task has been specified, SimRig can scaffold an ordinary Python environment and validate it before any training run:

simrig new-env my_task --model path/to/robot.xml --template mjx
simrig validate-env envs/my_task.py
simrig validate-env envs/my_task.py --runtime
simrig smoke envs/my_task.py --steps 10

The generated environment remains editable. Reward terms, observations, actions, resets, and termination logic are visible in Python rather than hidden behind an opaque task generator.

Example 1: Training Go1

We tested the complete workflow on Unitree Go1 locomotion.

SimRig first inspected the existing Go1JoystickFlatTerrain environment and ran local smoke tests. Only after those gates passed did it connect to an already provisioned Lambda Cloud instance, verify GPU visibility, synchronize the project, run a remote smoke test, and start a detached PPO training job.

The cloud preset targeted 50 million training steps across 8,192 parallel environments. The resulting evaluation reported an average episode length of 964.4 out of 1,000 steps and an episode reward of 25.36. SimRig then downloaded the policy, metrics, configuration, logs, and checkpoints for local evaluation and preview.

The workflow is deliberately conservative around paid compute. SimRig operates on a Lambda instance the user has already provisioned; it does not launch or terminate billable infrastructure. It also keeps long training behind local and remote smoke tests, then includes a shutdown-cost reminder when artifacts are fetched.

Example 2: Direct Control with Franka Panda

Not every robotics problem needs reinforcement learning.

For the Franka Panda example, the right solution was a direct controller: a quintic Cartesian trajectory defines a five-pointed star, and damped-least-squares inverse kinematics tracks the fingertip while holding its orientation fixed.

LiveWebViewer lets an ordinary MuJoCo script publish the MjModel and MjData it already owns. The script keeps control of simulation timing and stepping while SimRig provides the browser scene, camera controls, live state, and optional body tracking.

This distinction matters. SimRig is not a system that forces every prompt through PPO. It helps the agent choose a suitable path, and it can provide the same inspection and visualization layer for learned policies and direct controllers.

Evaluation That Says What It Knows

SimRig separates rollout completion from task success.

An evaluation can report the requested and completed steps, reward, termination state, seed, and applied command. If an environment does not define a task-specific success evaluator, SimRig says so. Completing a rollout or producing a high reward is useful evidence, but it does not automatically prove that a command was tracked or a task was completed.

Every training run also records its Python and package versions. Evaluation, native demos, and browser previews check that recorded runtime before loading the policy. A mismatch is rejected by default unless the user explicitly opts into a qualitative preview.

These checks are not incidental features. They are part of the goal: make robot-learning workflows easier to run without erasing the boundaries of what was actually tested.

Built for Agents and Humans

SimRig's CLI can be used directly, but the repository also includes an agent skill that teaches coding agents the intended workflow and safety rules.

That makes natural-language requests possible:

Train this MuJoCo robot to walk forward.

Create a crouching task, validate it, and run a small smoke training job.

Evaluate this checkpoint across five seeds and open an interactive preview.

The agent skill is not a replacement for the CLI. It is the operating knowledge around the CLI: inspect first, prefer an existing environment when it fits, keep custom tasks explicit, smoke-test before long runs, and do not overstate evaluation results.

Installation

SimRig requires Python 3.10 or newer. The MuJoCo Playground stack can be installed from PyPI:

python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install "simrig[playground]"

simrig --version

The agent skill can be installed globally with:

npx skills add Su1eym4n/simrig --skill simrig --global

Source code, examples, and documentation are available in the SimRig repository.

What Comes Next

SimRig currently focuses on MuJoCo and MuJoCo Playground. The next phase is to deepen the task-development loop: richer evaluation scenarios, clearer experiment comparisons, more reusable custom environments, and additional simulation backends where the same inspect-before-train discipline can be preserved.

The larger goal is not one more training command. It is an open workflow where a person can describe a robot behavior, an agent can help construct the experiment, and both can inspect the decisions and evidence between the prompt and the final policy.