Describe a robot, its world, and the behaviours to verify in YAML. Robotbase compiles that into a real, headless ROS 2 + Gazebo simulation in Docker — and hands back machine-readable pass/fail evidence.
No hand-written URDF, launch files, or bridges. You describe it; the compiler owns every sim gotcha.
# Linux + Docker + Python 3.12 (on Windows/macOS: WSL2 Ubuntu 24.04 + Docker Desktop)
$ pip install robotbase-kit
$ robotbase create my-bot # scaffold (differential-drive by default)
$ cd my-bot
$ robotbase up # compile specs + boot a real headless ROS 2 + Gazebo sim
$ robotbase test drive-forward
✔ robot_moved_minimum_distance 1.42 m ≥ 1.0 m
✔ required_topic_messages /scan 37 ≥ 5
PASSED # exit 0 · structured result + recorded MCAP episode
Driving a coding agent instead? One command gives it the whole workflow:
/plugin marketplace add getrobotbase/robotbase
/plugin install robotbase@robotbase
> /robotbase:new navigate an S-shaped maze to the goal without touching a wall
Your YAML compiles down to a real, standard ROS 2 graph (nodes, topics, TF, ros2_control) on top of Gazebo. Because the runtime is genuine ROS 2, a passing scenario means something — and you can drop in your own ROS 2 code, or later a real robot, underneath the same specs.
A few lines of YAML. When the spec is wrong, you get an error that names the field — not a C++ traceback.
describe / explain / validate hand back ground truth about the compiled robot, world, and runs — not console output to parse.
A scenario is an objective pass/fail. You can't claim a robot works — you make the assertions pass.
assertions: are the testDefine what "working" means declaratively. The assertions block is the whole test:
# simulation/scenarios/drive-forward.yaml
assertions:
- {type: robot_moved_minimum_distance, minimum_distance_metres: 1.0}
- {type: required_topic_messages, topic: /scan, minimum_count: 5}
Every run is metrics + assertions plus a recorded MCAP episode (Foxglove/Rerun-openable). Run it over N randomized trials with robotbase eval for a success-rate with a 95% confidence interval. Bring a Python policy instead of a ROS controller and get the same objective evidence.
pip install robotbase-kit[studio] then robotbase studio opens a localhost web app: see your robot, world, and scenarios; run a scenario or an eval and watch it live in 3D; open the episode in Foxglove; read the structured results and eval reports.
It's a thin client over the same CLI/runtime — drive it from your terminal (or a coding agent), no in-app chat, no API credits.
$ robotbase create my-arm --template arm
$ robotbase create my-bot --from-urdf my_robot.urdf # import an existing URDF verbatim
Robotbase is meant to be operated by a coding agent, so there are no external docs to keep in sync. It's CLI-first: every action is a robotbase verb with a structured (JSON) result, so any shell-capable agent drives it directly — no MCP required. robotbase schema returns the full authoring reference (generated from the code, so it can't drift). Every create drops an AGENTS.md into the project. An MCP server ships too, for MCP-only agents.
The gap it closes: a coding agent can write robot code; on its own it can't tell whether the robot actually works. Robotbase gives it the evidence.