SimTooReal CLI

The robotics platform that meets you where you work. Use any AI coding agent — Claude Code, Cursor, Codex, Windsurf — to scaffold, train, and deploy robot policies. SimTooReal handles the hard parts: simulation setup, GPU training, sim-to-real transfer, and deployment gating.

npm install -g simtooreal-cli
simtooreal setup

What is SimTooReal?

SimTooReal is an AI-powered robotics training platform. You write the robot behavior in plain language or code — SimTooReal generates the simulation environment, runs training on cloud GPUs, analyzes failures, and tells you when a policy is safe to deploy on real hardware.

The core idea: your local AI coding agent (Claude Code, Cursor, etc.) is wired to the SimTooReal platform via MCP (Model Context Protocol). You talk to your agent in natural language. The agent calls SimTooReal tools to create projects, generate robot descriptions, launch training runs, stream metrics, and gate deployments — all without you leaving your editor.

You → "train a go2 robot to walk on rough terrain"
   ↓
Claude Code (via MCP) → simtooreal project init + codegen + push + train
   ↓
SimTooReal Platform → GPU training + failure intelligence + confidence scoring
   ↓
You → "deploy to robot" (only if safety gate passes)

Installation

Requirements: Node.js 18+

npm install -g simtooreal-cli

Verify:

simtooreal --version
simtooreal --help

Platform support: Native binary included for Windows x64, Linux x64, and Linux arm64. macOS binaries ship in a future release (needs a macOS build host). Build from source in the meantime: cargo install --git https://github.com/sim-too-real/simtooreal-cli

Quick Start

1. Sign up and log in

simtooreal login --email [email protected]
# enter password when prompted

2. Run setup (wires your AI coding agent)

simtooreal setup

This detects installed agents (Claude Code, Cursor, Windsurf, Codex, VS Code, Devin), lets you choose your primary agent, and writes the MCP config file so your agent can talk to SimTooReal.

3. Open your agent and start building

Open Claude Code (or your chosen agent) in your project folder and say:

"create a go2 quadruped walking project with Isaac Lab"
"generate a URDF for a 6-DOF arm robot"
"push the project and launch training with 4096 environments"
"what failed in the last training run?"
"is this policy safe to deploy?"

Your agent handles everything through SimTooReal's MCP tools — no manual CLI commands needed.

Commands

Authentication

simtooreal login --email <email>     # sign in
simtooreal logout                    # sign out
simtooreal whoami                    # show current user

Setup

simtooreal setup                     # interactive: detect agents, pick primary, wire MCP
simtooreal setup --yes               # non-interactive (CI / scripted)
simtooreal experience doctor         # diagnose MCP wiring issues

Projects

# List your projects
simtooreal project list

# Browse starter templates
simtooreal project templates

# Create a new project (creates local folder + registers on platform)
simtooreal project init <name> --simulator isaaclab
simtooreal project init my-go2 --engine mujoco --description "quadruped rough terrain"
simtooreal project init arm-pick --template manipulation

# Push local files to the platform (required before training)
simtooreal project push
simtooreal project push --dir ./my-go2 --force

# Launch a training run on cloud GPUs
simtooreal project train
simtooreal project train --task "Isaac-Velocity-Rough-Go2-v0" --num-envs 4096 --max-iterations 5000
simtooreal project train --simulator mujoco --physics-backend mjx

# Check training status
simtooreal project status

# List all runs for a project
simtooreal project runs

# Stream live training logs
simtooreal project logs
simtooreal project watch                      # live-tail metrics

# Analyze a completed run
simtooreal project analyze --run-id <id>

# Failure intelligence — why did the policy fail?
simtooreal project failures --run-id <id>

# Sim-to-real promotion gate — is it safe to deploy?
simtooreal project gate --run-id <id>

# Confidence score
simtooreal project confidence --run-id <id>

# AI-powered suggestions for improving reward / hyperparams
simtooreal project suggestions --run-id <id>

# Compare two runs side-by-side
simtooreal project compare --run-a <id> --run-b <id>

# Chat with AI about your project
simtooreal project chat "why is the reward plateauing after 2000 iterations?"

Code Generation

Generate simulation-ready robot description files and training scaffolds:

# URDF — Universal Robot Description Format
simtooreal codegen urdf --name my-arm --type generic --dof 6 --out robot.urdf
simtooreal codegen urdf --name go2 --type quadruped --out go2.urdf

# MJCF — MuJoCo XML format
simtooreal codegen mjcf --name my-robot --out robot.xml

# SDF — Gazebo/SDFormat
simtooreal codegen sdf --name my-robot --out robot.sdf

# Isaac Lab environment
simtooreal codegen isaaclab-env --task locomotion --robot go2 --out env.py

# Isaac Lab reward function
simtooreal codegen isaaclab-reward --task locomotion --out reward.py

# Newton scene (NVIDIA Newton physics)
simtooreal codegen newton-scene --out scene.py

# PhysX scene
simtooreal codegen physx-scene --out scene.py

# ROS 2 package scaffold
simtooreal codegen ros2-package --name my_robot_pkg --out ./

# ROS 2 launch file
simtooreal codegen launch-file --package my_robot_pkg --out launch.py

# Reward specification (YAML)
simtooreal codegen reward-spec --task locomotion --out reward_spec.yaml

# Environment config
simtooreal codegen env-config --simulator isaaclab --out env_config.yaml

Validation

simtooreal validate robot.urdf           # auto-detect format
simtooreal codegen validate-urdf robot.urdf
simtooreal codegen validate-mjcf robot.xml
simtooreal codegen validate-sdf robot.sdf

Simulation Engine Detection

simtooreal detect-engines               # find locally installed sim engines
simtooreal codegen detect-engines       # same, with codegen context

Detects: Isaac Lab, MuJoCo, MuJoCo MJX, Gazebo, Newton, PhysX, ROS 2.

MCP Server

simtooreal mcp serve                    # start JSON-RPC 2.0 stdio server

This is called automatically by your AI coding agent — you don't run it manually. It exposes 29 tools covering the full project lifecycle, code generation, training, analytics, and deployment gating.

Supported Simulators

| Simulator | Code | |-----------|------| | NVIDIA Isaac Lab | isaaclab | | MuJoCo (CPU) | mujoco | | MuJoCo MJX (GPU) | mujoco + --physics-backend mjx | | Gazebo | gazebo | | NVIDIA Newton | newton | | PhysX | physx | | ROS 2 | ros2 |

Supported AI Coding Agents

simtooreal setup auto-detects and configures:

| Agent | Detection | MCP Config location | |-------|-----------|-------------------| | Claude Code | ~/.claude/ | .mcp.json | | Cursor | ~/.cursor/ | .cursor/mcp.json | | Windsurf | ~/.codeium/ | ~/.codeium/windsurf/mcp_config.json | | Codex | codex in PATH | .codex/config.toml | | VS Code | code in PATH | .vscode/mcp.json | | Devin | devin in PATH | manual step |

After setup, restart your IDE. The agent can call all SimTooReal tools in natural language — no simtooreal commands needed.

MCP Tools (for agent developers)

The MCP server exposes 29 tools via JSON-RPC 2.0 over stdin/stdout:

Auth & Identity

• whoami — current user info

Projects

• list_projects, create_project, list_templates, scaffold_project
• push_project, publish_project

Code Generation

• generate_urdf, generate_mjcf, generate_sdf
• generate_isaaclab_env, generate_isaaclab_reward
• generate_newton_scene, generate_physx_scene
• generate_ros2_package, generate_launch_file
• generate_reward_spec, generate_env_config
• validate_robot_description, detect_sim_engines

Training

• launch_training, get_run_status, get_run_logs, list_runs

Intelligence

• get_analytics, get_failure_intelligence, get_suggestions
• get_promotion_gate, get_confidence_score, compare_runs

Platform

• chat — AI assistant scoped to your project and run history

Wire it into any MCP-compatible client:

{
  "mcpServers": {
    "simtooreal": {
      "command": "simtooreal-cli",
      "args": ["mcp", "serve"]
    }
  }
}

What SimTooReal Handles For You

Simulation scaffolding — generate URDF, MJCF, SDF, Isaac Lab environments, reward functions, and ROS 2 packages from natural language descriptions. No boilerplate.

Cloud GPU training — push your project and launch training on managed GPU instances. Supports Isaac Lab, MuJoCo, MuJoCo MJX, Gazebo, Newton, and PhysX. Choose your hardware, number of environments, and iteration budget.

Failure intelligence — every training run is analyzed for failure patterns. The platform identifies what broke, when, and why — joint torque saturation, reward hacking, observation noise sensitivity, curriculum collapse.

Sim-to-real transfer — domain randomization configs, visual divergence detection, and transfer readiness scoring. Know before you ship whether the policy will hold up on real hardware.

Deployment gating — a promotion gate that must pass before a policy can be pushed to a robot. Checks confidence scores, failure rates, and safety margins. Blocks deployment if the policy isn't ready.

Metrics ingestion — run training anywhere (cloud or local) and stream metrics to the SimTooReal platform. Track reward curves, episode lengths, entropy, and custom metrics across runs.

Local Training + Cloud Metrics

You don't have to use SimTooReal's GPU cloud. Train locally and send metrics to the platform:

# pip install simtooreal-tooling
from simtooreal_tooling import MetricsCollector

collector = MetricsCollector(project_id="your-project-id")

for step in training_loop:
    collector.log({
        "reward": reward,
        "episode_length": ep_len,
        "entropy": entropy,
    }, step=step)

Metrics appear in the SimTooReal dashboard alongside cloud runs. Compare local vs cloud, track experiments, analyze failures — all in one place.

JSON Output Mode

Every command supports --json for machine-readable output:

simtooreal project list --json
simtooreal project train --json
simtooreal project gate --run-id <id> --json

Use this for scripting, CI pipelines, or integrating with other tools.

Configuration

• Auth token: ~/.simtooreal/auth.json
• Agent preference: ~/.simtooreal/config.toml
• API endpoint: override with SIMTOOREAL_PLATFORM_ENDPOINT=https://...

Links

• Platform: simtooreal.com
• Docs: simtooreal.com/docs
• npm: npmjs.com/package/simtooreal-cli
• Issues: github.com/sim-too-real/simtooreal-cli/issues

License

Proprietary — © SimTooReal. All rights reserved.