# URDF Desk

> Paste one robot description - a URDF, and where you have them the MoveIt 2 SRDF
> and the SDFormat SDF beside it - and get a robotics engineer's review in three
> lanes over that same description. A free in-browser reader parses the XML
> itself first, walks the kinematic tree, checks every inertia tensor against the
> physics, and cross-references the planning groups and the simulated links
> against the robot they claim to describe.

Live at https://urdf-desk.skillsafe.ai/

## What it is for

One work object: a single robot description. Three lanes over it, in the order an
engineer meets them:

1. `structure` - Structure and physics. Will this load as one rigid-body tree and
   stay numerically stable? Reads the link and joint inventory, the tree they
   form, the inertials, the joint types, limits and axes, the visual and collision
   geometry, the mesh references and whatever declares how the joints are driven.
   Posture: `spawnable`, `spawnable-with-caveats`, `not-spawnable`.

2. `planning` - MoveIt 2 semantics. Can MoveIt configure this robot, and will the
   groups actually plan? Reads the planning groups, the chains, the group states,
   the end effectors, the virtual joint, the passive joints and the self-collision
   matrix, resolving every name against the URDF. If no SRDF was pasted, this lane
   authors a complete one instead of reviewing nothing.
   Posture: `plannable`, `plannable-with-caveats`, `not-plannable`.

3. `sim` - Gazebo handoff. Will this model behave in a simulator? Reads the
   SDFormat version, the models and worlds, the per-link inertials and collisions,
   the mesh URI schemes a simulator has to resolve, the sensors and what publishes
   them, the plugins and the physics settings - and, when both files are present,
   whether the URDF and the SDF describe the same robot.
   Posture: `sim-ready`, `sim-ready-with-caveats`, `not-sim-ready`.

The handoff between lanes is a button: the same description carries across, so the
structure audit leads into the planning review and the planning review into the
simulation check without re-pasting.

## What the free in-browser reader computes

No model call, no sign-in, no charge. It has its own XML parser, so every finding
carries the line it came from.

- Unexpanded xacro is detected first and reported as the finding, because every
  `${...}` would otherwise be read as literal text.
- The kinematic tree: root and leaf links, depth, degrees of freedom, links with
  two parent joints, fragments no root reaches, cycles in the joints.
- The physics: analytic principal moments of every inertia tensor, a
  positive-definiteness test, the triangle inequality on the principal moments,
  and an implied density cross-checked against the collision volume where the
  collision shape is a primitive.
- The joints: type validity, missing or inverted limits, zero effort or velocity,
  a range declared on a continuous joint, an axis left to default to `1 0 0`, an
  unnormalised axis, a mimic pointing at a joint that does not exist, soft limits
  outside the hard range.
- The geometry: links with visual but no collision, meshes used for collision,
  mesh URI schemes (`package://`, absolute, relative, `http`, `model://`), zero
  mesh scales, non-positive primitive dimensions, materials referenced but never
  defined.
- The SRDF against the URDF: ghost links and joints in a group, a chain whose tip
  is not a descendant of its base, a chain with no movable joint, group states
  outside the joint's own limits, an end effector on a link that does not exist, a
  virtual joint not attached at the root, stale `disable_collisions` pairs, and the
  directly-jointed link pairs missing from the self-collision matrix.
- The SDF: version, a static model that declares joints, links with no inertial,
  mesh URIs a simulator cannot resolve, sensors with no plugin, an oversized
  physics step, and which URDF links are absent from the converted model.

Every flag it raises carries an id, and the paid review must return one
`coverage_check` entry per id. The app displays that reconciliation as a table and
names any flag the review failed to address - which is the point of having both
halves.

## Contract

Input is the object itself (not wrapped in an `input` key):

    {"task": "structure" | "planning" | "sim",
     "description": "the URDF, SRDF and/or SDF text",
     "notes": "what you are about to do with it",
     "prescan": {"facts": ..., "flags": [...], "counts": ...}}

Several files go in one `description` string, separated by a line reading
`# file: name.urdf`. The three document kinds are told apart by content, not by
filename.

Output is one JSON object: a common envelope shared by every lane - `task`,
`title`, `posture`, `confidence`, `verdict`, `exec_summary`, `findings[]`,
`coverage_check[]`, `assumptions[]`, `open_questions[]`, `artifacts[]`,
`next_steps[]`, `summary` - plus exactly one lane body: `links[]` for structure,
`groups[]` for planning, `entities[]` for sim.

Full API documentation, with worked examples in cURL, Python, JavaScript, Go,
Java, Ruby, PHP and C#: https://urdf-desk.skillsafe.ai/api.html

## Boundaries, stated plainly

This app reads description text and returns judgement over it. It does not load
the robot, resolve a mesh file, spawn anything, or run any command. A finding
about a mesh is a finding about its path. A finding about physics is computed from
the numbers in the file. It is not a substitute for loading the robot in RViz or
spawning it in a simulator, and it does not pretend to be.

Reviews are metered and need a signed-in SkillSafe account. Estimating any lane is
free, and both bundled examples ship with a saved review so every lane can be seen
end to end without an account and without a charge.

## Sources

A derived work built on three agent skills by @earthtojake, from the `text-to-cad`
repository:

- @earthtojake/urdf - URDF robot description generation and generation-time
  validation: links, joints, limits, inertials, visual and collision geometry,
  mesh references, frame conventions.
- @earthtojake/srdf - MoveIt 2 SRDF generation, validation and planning
  semantics: planning groups, virtual joints, passive joints, end effectors,
  group states, disabled collisions.
- @earthtojake/sdf - SDFormat model and world generation, validation and
  simulator handoff: models, links, joints, poses, frames, inertials, geometry,
  mesh URIs, sensors, lights, physics, plugins.

This app is not a republication of those skills.

Model: gpt-terra (currently resolving to gpt-5.6-terra).