Meta Global AI Developer Hackathon · Indie track

Check a robot before you build it.

Describe a robot or paste its parts list. Muse Spark drafts the spec, RobotForge catches the numbers that don't add up, and a simulated twin has to pass a measured motion test.

Open the app →See the evidence

Spec drafting by Muse Spark via the Meta Model API · twin and gate in Gazebo Sim

Illustration of a rugged four-wheel rover on a workbench, lit in amber
AI illustration (muse-image-1.0). The real robots in the app carry real, credited photos.
The workflow

Five steps from an idea to a verdict.

Every robot goes through the same path. Nothing downstream trusts the step before it: the model's spec is checked, and the twin is measured.

  1. 01

    Input

    Plain words, a pasted parts list, or a photo.

  2. 02

    Spec

    Muse Spark drafts a strict, structured hardware spec.

  3. 03

    Checks

    Engineering checks catch impossible or inconsistent numbers.

  4. 04

    Twin & gate

    The twin drives 1 m and turns 90° in Gazebo, graded on ground truth.

  5. 05

    Outputs

    URDF, a printable take-apart kit, and what's missing to buy.

Evidence

The gate is not a rubber stamp.

Thresholds are locked: distance error 5% passes and over 10% fails, heading error 5° passes and over 10° fails. Here is one robot that earned a PASS, and one that was rigged to fail.

Described in words, never drawnPass

Indoor Delivery Rover

One paragraph of plain English became a spec, a twin, and a measured PASS. Its odometry matched ground truth to 0.002%.

Drive error
0.398%
Turn error
3.653°
Fault injectionFail

Wheels 10% smaller than the paperwork

TurtleBot3 Burger with its physical wheels shrunk to 0.9× while odometry kept believing the spec. The robot's own sensors couldn't see it. The gate could.

Drive error
7.617%
Odometry vs truth
11.168%

Bars run 0–15. Green zone passes, yellow is marginal, past it fails. Recorded in Gazebo Sim, headless, Oct 26, 2026.

All gate reports →
Robodex

Robots the forge knows.

Each badge comes only from recorded gate runs. A robot that hasn't been gated says so in grey instead of borrowing a green it hasn't earned.

Andino
#001

Andino

Ground — wheeled · Differential roverFail
TurtleBot3 Burger
#002

TurtleBot3 Burger

Ground — wheeled · Differential roverPass
TurtleBot3 Waffle Pi
#003

TurtleBot3 Waffle Pi

Ground — wheeled · Differential roverNot gated
Pathfinder (AI concept illustration)
#004

Pathfinder

Ground — wheeled · Skid-steer roverPass
PX4 X500
#005

PX4 X500

Aerial · QuadcopterNot gated
Crazyflie 2.1
#006

Crazyflie 2.1

Aerial · QuadcopterNot gated
Unitree Go2
#007

Unitree Go2

Legged · QuadrupedNot gatedStatic check: STABLE — tip margin 32°
Mini Pupper
#008

Mini Pupper

Legged · QuadrupedNot gatedStatic check: STABLE — tip margin 28°
Unitree G1
#009

Unitree G1

Legged · HumanoidNot gatedStatic check: UNSTABLE — tip margin 3°
ROBOTIS OP3
#010

ROBOTIS OP3

Legged · HumanoidNot gatedStatic check: UNSTABLE — tip margin 3°
OpenManipulator-X
#011

OpenManipulator-X

Stationary · Robotic armNot gated
Under the hood

How RobotForge decides.

The model sits on the critical path, and nothing it says is trusted until it is checked and measured.

Describewords · list · photo
SpecMuse Spark
Validateengineering checks
URDFmodel
TwinGazebo, headless
Gatepass · marginal · fail

What a PASS proves

  • The spec's numbers are consistent with each other: geometry, mass budget, voltages.
  • A twin built from exactly that spec drives 1 m and turns 90° within the locked thresholds.
  • The twin's own odometry agrees with simulator ground truth, so its sensors aren't lying to it.

What it doesn't prove

  • That a physical robot will behave the same. The gate tests the spec's simulated twin, not hardware.
  • That a photo-drafted spec is accurate. Photo dimensions are marked ESTIMATED until measured.
  • Anything beyond drive and turn. Other behaviours aren't gated yet.
Meta model

Muse Spark drafts the spec

Through the Meta Model API in Standard mode. It turns words or a photo into a strict spec schema and never writes simulation code.

Cross-check

SAM 3.1 double-checks photos

It locates parts in the picture independently. When it disagrees with Spark, both answers are printed, not smoothed over.

Gate

Ground truth, not belief

Drive and turn are judged against the simulator's true pose. Odometry is graded too, so a robot can't pass on its own word.

Locked thresholds

Printed on every report, never quietly loosened
MeasurementPassMarginalFail
Distance error≤ 5%5–10%> 10%
Heading error≤ 5°5–10°> 10°

Run it yourself

Python, zero required dependencies for the core
pip install -e .
robotforge describe "a four-wheel rover, 30 cm long, with a front ultrasonic sensor" --mock --out rover.json
robotforge validate rover.json
robotforge urdf rover.json --out build/rover.urdf
robotforge run-gate rover.json

Watch a robot go through the forge.

Step through a real recorded run: the paragraph, the spec Muse Spark returned, the checks, and the gate's measured verdict.

Open the app →