robium-ai
OrganizationTeach your coding agent robotics — 22 versioned, battle-tested skills for ROS 2, Gazebo, Nav2, LeRobot, Isaac Sim, MuJoCo and more. npx robium-ai install
Categories
Indexed Skills (20)
architect
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. Use when: starting any new robotics app; 'build a robot app', 'which robotics stack', 'scaffold a robotics project', 'mobile robot', 'robot arm', 'manipulation policy', 'navigation stack', backlog-driven kickoffs like 'let's do demo 1', 'do demo N', 'build the next demo'; or when requirements exist but the stack is unchosen. This is the entry-point skill of the robium plugin: load it first; it routes to every other robium skill per build phase. Not for: debugging an existing stack (use the matching tool skill) or authoring robium skills (skill-author).
data
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. Use when: 'where do we get data', 'training data for the robot', 'dataset for manipulation', 'generate data in sim', 'collect demonstrations', planning any data pipeline for robot learning. Umbrella skill — mechanics live downstream: hub operations in huggingface, LeRobot formats in lerobot, synthetic generation in isaac-sim/gazebo. Not for: model training itself (lerobot, isaac-lab) or sourcing test fixtures/assets (test-assets).
environments
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. Use when: setting up any new robotics project environment; 'uv', 'venv', 'virtualenv', 'docker for this project', 'reproducible environment', 'works locally but not on the server', 'GPU in container'. Load early in any robium build, right after architect. Decision rule of thumb: pure-Python ML stacks → uv; anything needing ROS 2 or system deps → Docker. Not for: multi-module application Dockerfiles and compose wiring (integration skill).
foxglove
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. Use when: 'foxglove', 'mcap', visualizing a robot running on a remote server, sharing visualization with others, or recording sessions for later analysis. The remote-viz answer in the robium stack — key to the local-vs-remote workflow (cross-ref environments). Not for: ROS desktop debugging (rviz2) or ML logging (rerun).
gazebo
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. Use when: 'gazebo', 'gz sim', 'ros_gz', 'simulate the robot', 'add a lidar to the sim', simulating mobile robots or sensors in the ROS ecosystem. Pairs with ros2 and nav2; simulator SELECTION lives in the simulation skill. Gazebo Classic (11) is EOL — this skill covers modern gz only and must never recommend Classic. Not for: Isaac Sim (isaac-sim) or non-ROS simulation.
huggingface
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). Use when: HF hub operations inside a robotics project, 'huggingface dataset for robots', 'upload the policy to the hub', and the HF skills aren't installed yet. Pairs with lerobot and data.
integration
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. Use when: wiring components together; 'containerize this', 'dockerfile', 'docker compose', 'how should these modules talk', 'connect the planner to the controller', multi-process or multi-container robotics systems. Load after architect chose the stack and environments set the env strategy. Not for: choosing the overall stack (architect) or single-project env setup (environments).
isaac-lab
NVIDIA Isaac Lab: reinforcement-learning and imitation-learning workflows on top of Isaac Sim — prebuilt environments and tasks, training runs, and exporting policies. Use when: 'isaac lab', 'GPU RL for robots', 'train in isaac', sim-to-real policy training in the NVIDIA stack. Load after isaac-sim basics are settled (same GPU requirements apply — RTX-class NVIDIA GPU, no macOS). Alternative ML path to lerobot; the architect skill decides between them. Not for: Isaac Sim setup itself (isaac-sim) or imitation learning on real-robot datasets (lerobot).
isaac-sim
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. Use when: 'isaac sim', 'omniverse', GPU photorealistic simulation, synthetic data generation, or NVIDIA robotics ecosystem work. State the GPU requirement BEFORE recommending Isaac Sim — if the user lacks an RTX-class NVIDIA GPU, route to gazebo instead. Simulator selection lives in the simulation skill. Not for: RL training workflows (isaac-lab) or lightweight simulation needs (gazebo).
lerobot
HuggingFace LeRobot for physical-AI manipulation: the LeRobotDataset format, loading and recording episodes, training policies (ACT, diffusion, pi0), evaluating in simulation, and teleoperation. Use when: 'lerobot', 'manipulation policy', 'imitation learning', 'train a robot arm policy', 'ACT', 'diffusion policy', physical-AI dataset/training/eval tasks. Core skill of the manipulation vertical; pairs with huggingface (hub mechanics), environments (uv-first install), and data (sourcing strategy). Not for: classical motion planning or the NVIDIA RL stack (isaac-lab).
live-demo
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). Use when: 'live demo', 'demo page', 'let visitors drive the robot', 'try it live on the website', 'demo instance start/stop', 'host the sim for the demo', choosing the demo visualizer, or budgeting/deploying demo backends. Load after an app passes its smoke test (testing) — a demo hosts a finished app. Pairs with foxglove (bridge/viewer mechanics) and integration (container patterns). Not for: developer-facing visualization during a build (foxglove/rviz2) or general website building.
nav2
Nav2 mobile-robot navigation for ROS 2: bringup, behavior trees, costmaps, planner/controller servers, localization (AMCL, slam_toolbox), waypoint following, and tuning. Use when: 'navigation', 'nav2', 'costmap', 'path planning', 'robot won't move to goal', 'localization', 'SLAM', 'AMCL', 'waypoint', or any autonomous mobile robot task. Load after architect selects the ROS nav stack; pairs with ros2 (foundation), gazebo (sim), and visualization (debugging). Not for: manipulation (lerobot) or generic ROS 2 issues (ros2).
rerun
Rerun for data-centric robotics and ML visualization: logging APIs (Python), timelines, entity paths, and viewing policy rollouts, episode data, and sensor streams. Use when: 'rerun', visualizing ML training/eval rollouts, LeRobot episode data, or custom sensor pipelines outside ROS tooling. Defers heavily to Rerun's official examples and docs — check them before writing logging code. Pairs with lerobot and data. Not for: live ROS topic debugging (rviz2, foxglove).
ros2
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. Use when: any ROS 2 development or debugging; 'ros2', 'colcon', 'launch file', 'package.xml', 'QoS mismatch', 'TF', 'node not receiving messages', 'rosdep'. Foundation skill for the ROS vertical — load alongside nav2, gazebo, rviz2. ROS 2 only; ROS 1 is EOL and out of scope. Not for: navigation specifics (nav2), simulation (gazebo), or visualization (rviz2/foxglove).
rviz2
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). Use when: 'rviz', 'rviz2', visualizing ROS topics, TF trees, costmaps, or robot models during development. ROS-native desktop debugging tool — for remote/web visualization use foxglove; for ML/data-centric logging use rerun. Pairs with ros2 and nav2.
skill-author
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. Use when: 'write a new robium skill', 'improve robium skills', 'absorb learnings', 'harden skills', after building an app produced learnings files, or when distilling patterns from an existing robotics repo into a skill. Wraps Claude's skill-creator skill for evals and description tuning instead of reinventing it. Not for: building robot applications (use architect and the domain skills).
skill-refiner
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. Use when: 'refine the skills', 'check skill bloat', 'are the skills bloated', 'prune the skills', 'dedupe the skills', 'stale skill facts', at the end of a skill-updater absorption run (skill-updater routes here), or periodically (~monthly or after every 2-3 app builds). Report-first: produces a findings report, then applies only user-approved edits under skill-author's rules. Developer workflow — runs in the robium source checkout. Not for: absorbing session learnings (skill-updater) or authoring new skills (skill-author).
skill-updater
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. Use when: a work session surfaced gotchas, frictions, or better methods worth keeping; 'skill-updater', 'update my skills', 'absorb these learnings', 'fold these gotchas into the skills', end of an app-building session with the robium plugin. Runs ONLY on explicit user request — agents surface candidate learnings and offer, never invoke this themselves. Developer workflow — requires a local robium checkout. Not for: authoring a new skill from scratch (skill-author) or building apps (architect).
testing
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. Use when: 'test the robot app', 'how do I test this node', 'smoke test', 'regression test in sim', setting up tests for a new robotics project, or before claiming any robotics app works. Applies to both verticals: launch_testing and pytest for ROS 2 apps; deterministic small-scale eval runs for ML policies. Load alongside whatever skill is building the thing under test. Not for: general (non-robotics) testing practices.
visualization
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. Use when: 'visualize', 'see what the robot sees', 'debug visually', 'plot the trajectory', 'dashboard for the robot', choosing a viz tool, or recording data for later inspection. Umbrella skill — after selecting, load the matching tool skill: rviz2 (ROS-native debugging), foxglove (remote/web + MCAP recording), rerun (ML/data-centric logging). Not for: tool-specific how-to (the per-tool skills).
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.