Your AI agent, robotics-ready.
robium equips Claude Code with battle-tested robotics engineering skills — stack selection, simulation, navigation, learned manipulation — so your agent builds robot applications that pass their smoke tests, not just compile.
> start manip-trial ⏺ robium:architect — manipulation golden path stack: LeRobot 0.6.0 · gym-pusht · uv (Python 3.12) · MPS brief written → docs/architecture-brief.md $ make smoke tests/test_smoke.py::test_train_completes PASSED tests/test_smoke.py::test_eval_produces_metrics PASSED 2 passed in 39.51s
From idea to a smoke-tested robot app.
Describe the robot app
"Autonomous navigation in sim" or "train a manipulation policy" — plain language, in your Claude Code session.
> build a mobile robot that navigates a warehouse
Skills route the stack
The architect skill turns requirements into a verified stack decision and writes an architecture brief your whole build follows.
middleware ROS 2 Jazzy nav Nav2 sim Gazebo Harmonic viz Foxglove
Build and see it run
Reproducible envs (uv or Docker), headless simulation, browser visualization — local and remote runs behave identically.
gz sim -s --headless-rendering foxglove ws://localhost:8765 RTF ≈ 0.99
Smoke test gates done
An app is not done until one command proves it: robot reaches its goals, policy trains and evals with metrics. Exit code 0 or it is not shipped.
$ make smoke PASS: all goals reached exit 0
21 skills. One coherent robotics brain.
Generated from the repo at build time — versioned, battle-tested on real builds, and hardened by a continuous learning loop.
Entry-point skill for designing robotics applications with AI agents. Turns requirements (robot type, task, hardware, sim-vs-real, GPU/budget) into a full stack decision — middleware, simulation, data, visualization, training frameworks — plus a scaffold plan and a written architecture brief.
Data sourcing strategy for robotics and physical-AI: choose between offline datasets (HuggingFace hub, Open X-Embodiment and similar), simulation-generated data, and teleop/real-robot collection; plan storage formats, episode structure, and dataset versioning.
Virtual-environment-first setup for robotics projects: decide uv/venv vs Docker, make local and remote-server runs reproduce identically, handle GPU passthrough and headless/display forwarding.
Foxglove for robotics visualization: foxglove_bridge setup for live ROS 2 robots, layouts, MCAP recording and playback, and remote/web visualization of robots running on servers.
Modern Gazebo (gz — Harmonic/Ionic line) simulation: SDF worlds and models, sensors (lidar, camera, IMU, contact), the ros_gz bridge, spawning robots, and headless/server operation.
HuggingFace ecosystem for robotics projects: hub datasets and models for robot learning, and demo Spaces. DELEGATES: for hub mechanics (download/upload/auth/jobs), install HuggingFace's own skills — /plugin marketplace add huggingface/skills, then /plugin install hf-cli@huggingface-skills — and defer to them; this skill adds only the robotics-specific layer (which datasets and models matter for manipulation and navigation, robotics dataset conventions on the hub).
Glue robotics modules into one running system: choose module boundaries, pick inter-module communication (ROS 2 topics/services/actions, zenoh, gRPC, REST, shared memory), and write solid Dockerfiles and docker-compose for robotics workloads.
NVIDIA Isaac Lab: reinforcement-learning and imitation-learning workflows on top of Isaac Sim — prebuilt environments and tasks, training runs, and exporting policies.
NVIDIA Isaac Sim: installation and container setup, GPU/driver requirements, USD scenes, robots and sensors, the ROS 2 bridge, and headless/livestream operation for remote servers.
HuggingFace LeRobot for physical-AI manipulation: the LeRobotDataset format, loading and recording episodes, training policies (ACT, diffusion, pi0), evaluating in simulation, and teleoperation.
Turn a working robium app into a public, interactive web demo: a mission-control demo page (start/stop instance buttons, live boot terminal, fleet budget), per-visitor simulator instances on Cloud Run (scale-to-zero), and a visualizer handoff (Foxglove deep link or self-hosted viewer).
Nav2 mobile-robot navigation for ROS 2: bringup, behavior trees, costmaps, planner/controller servers, localization (AMCL, slam_toolbox), waypoint following, and tuning.
Rerun for data-centric robotics and ML visualization: logging APIs (Python), timelines, entity paths, and viewing policy rollouts, episode data, and sensor streams.
Core ROS 2 usage: workspaces, colcon builds, packages (ament_python/ament_cmake), nodes, topics/services/actions, QoS, launch files, parameters, TF2, rosdep, and gluing third-party packages together.
RViz2 visualization for ROS 2: displays, TF frame debugging, markers, saved config files, and the common 'nothing shows up' fixes (fixed frame, QoS, sim time).
Choose and set up robotics simulators, and simulate sensors correctly: Gazebo vs Isaac Sim selection, sensor fidelity (rates, noise models, frames matching the real robot), determinism, and sim-to-real considerations.
Author and improve robium skills. Three modes: fresh authoring from skills/_TEMPLATE, mining skills out of existing repos and apps, and hardening skills from learnings/ notes after trial runs. Enforces the robium quality bar (template compliance, trigger-surface descriptions, <500-line bodies, stated delegation posture, upstream links, no invented syntax) and runs scripts/validate_skills.py.
Curation pass over the robium skill catalog: measure bloat against token budgets, find cross-skill duplication and overlap worth merging, sweep dated version/status facts for staleness, and review which skills never fire so their trigger surface or existence gets questioned.
Fold the current session's learnings back into the robium skills, on demand. Harvests gotchas from the conversation and any unabsorbed learnings/ files, confirms the list, then edits the robium source checkout: fixes wrong/stale guidance, widens missed trigger surfaces, adds figured-out-from-scratch knowledge, prunes noise, and promotes ✓-verified examples.
Test-driven robotics development: smoke tests for launch files, sim-based regression tests, node-level unit tests, policy eval as a test, and CI patterns for robotics repos.
Choose and apply robotics visualization: selection guidance for rviz2 vs Foxglove vs Rerun, plus best practices — what to visualize at each dev stage, live vs recorded, local vs remote.
Built by the plugin. Gated by smoke tests.
Every reference app in robium-applications is built with the skills and stays green — the apps are the regression suite, and the registry tells the next build what to bootstrap from.
nav-trial
ROS 2 Jazzy · Nav2 · slam_toolbox · Gazebo Harmonic · Docker (arm64) · Foxglove
TurtleBot 3 maps its world with SLAM, then navigates goals on the saved map — fully headless on a MacBook, visualized in the browser.
9/9 waypoints SUCCEEDED — map saved 111×103 AMCL localized, 2 map-frame goals SUCCEEDED PASS: all goals reached · exit 0 · 94 s wall
manip-trial
LeRobot 0.6.0 · ACT policy · gym-pusht · uv · Apple-silicon MPS
An imitation-learning policy trains on the PushT dataset and evaluates in sim with metrics — on a GPU-less laptop. Below: a real evaluation rollout.
ROS 2 Nav2 Gazebo LeRobot 
Hugging Face 
Isaac Sim Foxglove Rerun RViz2 
Docker 
uv ROS 2 Nav2 Gazebo LeRobot Hugging Face Isaac Sim Foxglove Rerun RViz2 Docker uv Two commands in Claude Code.
/plugin marketplace add mdemirst/robium /plugin install robium@robium ✓ 20 robotics skills loaded — start with: > build a mobile robot that navigates in sim
Then just describe your robot application. Full docs in the README.