# API Access
Source: https://docs.gizmo.antimlabs.com/api-access

Programmatic REST API for automated simulation authoring

The Gizmo API lets you generate articulated assets and complete scenes from text prompts, manage your library, browse the premade catalog, and export to USD, USDZ, MJCF, or SDF — all without the editor UI.

**Base URL:** `https://api.gizmo.antimlabs.com/v1`

## Authentication

All endpoints require an API key via the `Authorization` header:

```
Authorization: Bearer gzm_k1_YOUR_KEY
```

Create API keys in [Settings → API Keys](https://gizmo.antimlabs.com/settings#api-keys). Each key has configurable rate limits and scopes.

## Quick Start

### 1. Verify your key

```bash theme={null}
curl "https://api.gizmo.antimlabs.com/v1/whoami" \
  -H "Authorization: Bearer gzm_k1_YOUR_KEY"
```

### 2. Generate a scene

```bash theme={null}
curl -X POST "https://api.gizmo.antimlabs.com/v1/scenes" \
  -H "Authorization: Bearer gzm_k1_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A modern robotics lab with two workbenches"}'
```

This returns `202 Accepted` with a `job_id` — poll with `GET /v1/jobs/{job_id}` or stream real-time progress via SSE at `GET /v1/jobs/{job_id}/events`.

### 3. Export to a simulator

```bash theme={null}
curl -X POST "https://api.gizmo.antimlabs.com/v1/scenes/{scene_id}/export" \
  -H "Authorization: Bearer gzm_k1_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format": "mjcf"}' \
  -o scene.zip
```

## Endpoint Groups

### Scenes

| Method   | Path                     | Description                                         |
| -------- | ------------------------ | --------------------------------------------------- |
| `GET`    | `/v1/scenes`             | List all scenes                                     |
| `GET`    | `/v1/scenes/{id}`        | Get scene detail (optionally with full scene graph) |
| `POST`   | `/v1/scenes`             | Generate a new scene from a prompt                  |
| `PATCH`  | `/v1/scenes/{id}`        | Update scene metadata (name, description)           |
| `DELETE` | `/v1/scenes/{id}`        | Delete a scene                                      |
| `POST`   | `/v1/scenes/{id}/edit`   | Apply a natural language edit to a scene            |
| `GET`    | `/v1/scenes/{id}/status` | Get pipeline execution status                       |
| `POST`   | `/v1/scenes/{id}/export` | Export to MJCF, USD, USDZ, or SDF (returns ZIP)     |

### Assets

| Method   | Path                     | Description                                                    |
| -------- | ------------------------ | -------------------------------------------------------------- |
| `GET`    | `/v1/assets`             | List all assets (filter by scene)                              |
| `GET`    | `/v1/assets/{id}`        | Get asset detail (optionally with full record)                 |
| `POST`   | `/v1/assets`             | Generate a single asset from a prompt                          |
| `POST`   | `/v1/assets/{id}/export` | Export a single asset to MJCF, USD, USDZ, or SDF (returns ZIP) |
| `DELETE` | `/v1/assets/{id}`        | Delete an asset                                                |

<Note>
  `POST /v1/assets` attaches generated assets to a scene. If `scene_id` is omitted, a scene is created for you automatically. To generate a standalone environment instead, use `POST /v1/scenes`.
</Note>

<Note>
  Both `POST /v1/scenes` and `POST /v1/assets` accept an optional **`asset_pipeline`** field (`auto`, `gizmo`, or `cad`). `auto` picks the best pipeline for the prompt; `gizmo` uses editable parametric primitives; `cad` uses B-Rep solids via build123d for precision mechanical parts.
</Note>

<Note>
  **Reference images.** Both generate endpoints accept **`reference_image_urls`** (up to 3 http(s) URLs). For scenes, a room photo grounds the structure build in your image; for assets, photos ground geometry and texture.
</Note>

<Note>
  **Build method is automatic.** Asset requests are triaged per prompt: structured or jointed objects (furniture, appliances, racks) build as prim-based articulated assets (\~15–20 min); organic objects (food, plants, fabric) build as high-fidelity mesh scans (\~2–4 min). There is no knob to set — the API picks the right method.
</Note>

### Jobs

| Method | Path                   | Description                     |
| ------ | ---------------------- | ------------------------------- |
| `GET`  | `/v1/jobs/{id}`        | Poll job status                 |
| `GET`  | `/v1/jobs/{id}/events` | Stream real-time progress (SSE) |
| `POST` | `/v1/jobs/{id}/cancel` | Cancel a running job            |

### Catalog

| Method | Path                     | Description                                 |
| ------ | ------------------------ | ------------------------------------------- |
| `GET`  | `/v1/catalog`            | Search and browse premade assets            |
| `GET`  | `/v1/catalog/categories` | List all catalog categories                 |
| `GET`  | `/v1/catalog/{slug}`     | Get catalog item detail with download paths |

### Account

| Method | Path         | Description                       |
| ------ | ------------ | --------------------------------- |
| `GET`  | `/v1/whoami` | Verify API key and check scopes   |
| `GET`  | `/v1/usage`  | Get usage stats for all your keys |

## Async Generation

Scene and asset generation is asynchronous. `POST` endpoints return `202 Accepted` with a `job_id`. Use the Jobs endpoints to track progress:

* **Polling:** `GET /v1/jobs/{id}` returns status (`queued` → `running` → `succeeded` | `failed` | `cancelled`)
* **Streaming:** `GET /v1/jobs/{id}/events` provides real-time Server-Sent Events with stage transitions, asset completions, and errors

### SSE Event Types

| Event            | Description                     |
| ---------------- | ------------------------------- |
| `stage_start`    | A pipeline stage has begun      |
| `stage_complete` | A pipeline stage has finished   |
| `asset_ready`    | An individual asset is complete |
| `error`          | An error occurred               |
| `ping`           | Keep-alive (every 15s)          |
| `done`           | Job reached terminal state      |

## Rate Limiting

Every response includes rate limit headers:

* `X-RateLimit-Limit` — requests allowed per minute
* `X-RateLimit-Remaining` — requests remaining in current window
* `X-RateLimit-Reset` — Unix timestamp when the window resets

## Error Format

All errors follow a consistent structure:

```json theme={null}
{
  "error": {
    "code": "scene_not_found",
    "message": "Scene sc_abc123 not found",
    "status": 404
  }
}
```

Common error codes: `authentication_required` (401), `insufficient_credits` (402), `scene_not_found` (404), `rate_limit_exceeded` (429).

## OpenAPI Specification

The full OpenAPI 3.1 spec is available at:

```
GET https://api.gizmo.antimlabs.com/v1/openapi.json
```

Use it to generate client SDKs or import into tools like Postman.


# API key usage stats
Source: https://docs.gizmo.antimlabs.com/api-reference/account/api-key-usage-stats

/openapi.json get /v1/usage
Get usage statistics for all your API keys — request counts, last used timestamps, and rate limit configuration.



# Current user info
Source: https://docs.gizmo.antimlabs.com/api-reference/account/current-user-info

/openapi.json get /v1/whoami
Returns identity information for the authenticated API key — useful for verifying your key works and checking scopes.



# Delete asset
Source: https://docs.gizmo.antimlabs.com/api-reference/assets/delete-asset

/openapi.json delete /v1/assets/{asset_id}
Permanently delete an asset.



# Export a single asset to MJCF/USD/SDF
Source: https://docs.gizmo.antimlabs.com/api-reference/assets/export-a-single-asset-to-mjcfusdsdf

/openapi.json post /v1/assets/{asset_id}/export
Fetch one asset's full record from storage, build a single-asset document (geometry + joints + materials preserved), and run the export. Returns a ZIP archive (`application/zip`). GLB is not offered here — it requires a live render; use the editor for GLB.



# Generate an asset
Source: https://docs.gizmo.antimlabs.com/api-reference/assets/generate-an-asset

/openapi.json post /v1/assets
Generate a single 3D asset from a text prompt. The asset includes geometry, joints, materials, physics properties, and affordances.

The build method is chosen automatically per request: structured or jointed objects (furniture, appliances, racks) build as prim-based articulated assets (~15-20 min); organic objects (food, plants, fabric) build as mesh scans (~2-4 min). Optional `reference_image_urls` ground the geometry/texture in your photos.

Returns a `job_id` — poll or stream for progress.



# Get asset detail
Source: https://docs.gizmo.antimlabs.com/api-reference/assets/get-asset-detail

/openapi.json get /v1/assets/{asset_id}
Retrieve a single asset by ID. Use `include_record=true` to get the full geometry, joints, and materials data.



# List assets
Source: https://docs.gizmo.antimlabs.com/api-reference/assets/list-assets

/openapi.json get /v1/assets
Retrieve all assets belonging to the authenticated user. Optionally filter by scene.



# Browse premade catalog
Source: https://docs.gizmo.antimlabs.com/api-reference/catalog/browse-premade-catalog

/openapi.json get /v1/catalog
Search and browse the premade asset library. Supports full-text search across names and tags, category filtering, and pagination.



# Catalog categories
Source: https://docs.gizmo.antimlabs.com/api-reference/catalog/catalog-categories

/openapi.json get /v1/catalog/categories
Get all available categories in the premade catalog.



# Catalog item detail
Source: https://docs.gizmo.antimlabs.com/api-reference/catalog/catalog-item-detail

/openapi.json get /v1/catalog/{slug}
Get full details for a premade catalog item including download paths for GLB and USDZ files.



# Export scene to MJCF/USD/SDF
Source: https://docs.gizmo.antimlabs.com/api-reference/export-scene-to-mjcfusdsdf

/openapi.json post /v1/scenes/{scene_id}/export
Fetch the scene graph from S3 and run the export via the Node.js bundle.

The export runs in-process (subprocess) — no external service dependency.
Returns the ZIP archive directly (``application/zip``).



# Cancel a job
Source: https://docs.gizmo.antimlabs.com/api-reference/jobs/cancel-a-job

/openapi.json post /v1/jobs/{job_id}/cancel
Request cancellation of a running job. If the job has already completed, this is a no-op.



# Get job status
Source: https://docs.gizmo.antimlabs.com/api-reference/jobs/get-job-status

/openapi.json get /v1/jobs/{job_id}
Poll the current status of a generation job. Returns the job's status, timing, and optionally the full result payload once complete.

**Status values:** `queued` → `running` → `succeeded` | `failed` | `cancelled`



# Job event stream (SSE)
Source: https://docs.gizmo.antimlabs.com/api-reference/jobs/job-event-stream-sse

/openapi.json get /v1/jobs/{job_id}/events
Real-time Server-Sent Events stream of generation progress. Events include pipeline stage transitions, asset completion notifications, and error reports.

The stream closes automatically when the job reaches a terminal state (`succeeded`, `failed`, `cancelled`).

**Event types:** `stage_start`, `stage_complete`, `asset_ready`, `error`, `ping`, `done`

Use the `after` parameter to resume from a specific sequence number (e.g., after a reconnection).



# Delete scene
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/delete-scene

/openapi.json delete /v1/scenes/{scene_id}
Permanently delete a scene and its associated data.



# Edit a scene
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/edit-a-scene

/openapi.json post /v1/scenes/{scene_id}/edit
Apply a natural language edit to an existing scene. The AI agent interprets your instruction and modifies the scene graph accordingly.

Returns a `job_id` — poll or stream for progress.



# Generate a scene
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/generate-a-scene

/openapi.json post /v1/scenes
Start async scene generation from a text prompt. Returns immediately with a `job_id`. Optional `reference_image_urls` (e.g. a room photo) ground the structure build in your image.

Poll progress via `GET /v1/jobs/{job_id}` or stream real-time events via `GET /v1/jobs/{job_id}/events`.

The AI agent will:
1. Plan reusable assets from your prompt
2. Generate each asset (geometry, joints, materials, physics)
3. Create a floorplan and place assets with constraint solving
4. Run physics validation

Typical generation time: 2-5 minutes depending on scene complexity.



# Get scene detail
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/get-scene-detail

/openapi.json get /v1/scenes/{scene_id}
Retrieve a single scene by ID, optionally including the full scene graph (3D geometry, joints, materials) from S3.



# List scenes
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/list-scenes

/openapi.json get /v1/scenes
Retrieve all scenes belonging to the authenticated user, ordered by creation date (newest first).



# Scene pipeline status
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/scene-pipeline-status

/openapi.json get /v1/scenes/{scene_id}/status
Get detailed pipeline execution status for a scene — stages completed, errors, timing.



# Update scene metadata
Source: https://docs.gizmo.antimlabs.com/api-reference/scenes/update-scene-metadata

/openapi.json patch /v1/scenes/{scene_id}
Update a scene's name or description. Does not trigger regeneration.



# Core Idea
Source: https://docs.gizmo.antimlabs.com/core-idea

How Gizmo transforms text prompts into simulation-ready 3D scenes

```
text prompt + optional reference image
            |
            v
AI agent pipeline (plan → generate → assemble → validate)
            |
            v
parametric primitives, materials, modifiers, joints, physics
            |
            v
scene saved to your Gizmo library (single source of truth)
            |
            |---> USD / USDZ for Isaac Sim
            |---> MJCF package for MuJoCo
            |---> SDF world for Gazebo
            '---> GLB for visual mesh interchange
```

Every scene you generate is saved to your Gizmo library and serves as a single source of truth. From the same scene, you can export to USD, USDZ, MJCF, SDF, or GLB and run the same simulation across different backends — no re-authoring, no separate per-simulator copies to maintain.

## Generation Pipeline

When you submit a prompt, the AI agent runs through these stages:

1. **Asset Planning** — identifies what objects are needed, plans their structure
2. **Concept Images** — generates reference visuals to guide geometry creation
3. **Asset Generation** — builds each asset in parallel (geometry, joints, materials, physics)
4. **Floorplan** — creates the room layout and spatial constraints
5. **Constraint Solving** — places assets using deterministic spatial reasoning (no overlap, clearance rules)
6. **Structure** — builds walls, floors, ceilings, doors, and windows
7. **Lighting** — adds appropriate light sources
8. **Validation** — runs physics checks, connectivity verification, and robotics-readiness tests

## Geometry Pipelines

Gizmo uses two geometry approaches:

| Pipeline                 | Best For                                                 | Output                                                                               |
| ------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| **Parametric (default)** | Furniture, environments, general assets                  | Editable primitives with modifiers (bend, taper, twist, chamfer, shell, bulge, etc.) |
| **Precision CAD**        | Mechanical parts, robotic components, engineering assets | B-Rep solids generated via build123d for exact geometric tolerances                  |

The `auto` mode selects the best pipeline for each asset based on the prompt. You can also request a specific pipeline via the `asset_pipeline` parameter on `POST /v1/scenes` and `POST /v1/assets` (`auto`, `gizmo`, or `cad`).

## Reference Images

You can attach one or more reference images alongside your text prompt. The agent uses them to:

* Count and identify components
* Match proportions and spatial arrangement
* Guide material and color choices
* Verify output against the reference during review stages


# Editor Walkthrough
Source: https://docs.gizmo.antimlabs.com/editor-walkthrough

A complete guide to the Gizmo editor. Generate an asset from a prompt, build and edit a scene by hand, tune physics and robotics settings, then export to your simulator.

The Gizmo editor turns a text prompt into a simulation-ready 3D scene: meshes,
materials, articulated joints, and physics. This page walks through everything
you can do in the editor, in the order you will usually do it. It is written for
sim creators, so it errs on the side of explaining each panel rather than
assuming you already know where things live.

<Note>
  First time in the editor? An interactive in-app tour pops up automatically and
  highlights each panel described below. You can re-open it any time from the
  **?** (help) button in the top-right of the toolbar.
</Note>

## The layout

The editor has three regions:

* **Left panel** is your toolset, organized into tabs:
  * **Agent** generate with AI (this is where most scenes start).
  * **Assets** every generated or placed asset in the scene, as a list.
  * **Shapes** the individual primitives (boxes, cylinders, and so on).
  * **Lights** the lights you have added plus the global scene lighting.
  * **Robotics** robot spawns, semantic regions, and sensor anchors.
  * **Scene** scene type, physics defaults, and export settings.
* **Center** is the 3D viewport, with the transform and Play tool strip in the
  top-left corner.
* **Right panel** is the **Inspector** (properties of the selected object) and
  the **Asset Library** (every asset generated for this scene, ready to re-place).

<Frame>
  <img alt="Gizmo editor overview" />
</Frame>

You can toggle the left and right panels with the **\[** and **]** keys to give
the viewport more room.

## 1. Describe what to build

On the **Agent** tab, type what you want in plain English and press **Enter**.
You can describe a single asset, a full scene, or a robot workspace.

> a red metal toolbox with a hinged lid and a carry handle

<Frame>
  <img alt="Typing a prompt in the Agent bar" />
</Frame>

### Add a reference image (optional)

Click the **paperclip** to attach a photo or sketch, or just drag an image onto
the bar. Gizmo matches the generated asset's shape, proportions, and materials
to your reference. This is the fastest way to get a specific look.

### Write prompts that generate well

The agent builds joints and collision geometry around the parts you describe, so
the more concrete you are about structure, the better the result:

* **Name the moving parts.** Say which pieces should open, rotate, or slide (for
  example "a cabinet with two hinged doors and one sliding drawer"). Each becomes
  an articulated joint.
* **Give a rough size.** "About 1.2 m tall" keeps the asset at a realistic scale
  for a robot to interact with.
* **Call out materials and affordances.** Mention handles, knobs, or grips you
  want a robot to grasp, and the material (metal, wood, plastic) for each part.
* **Start simple, then iterate.** Generate the core object first, then refine it
  with follow-up messages (see step 3).

<Tip>
  Browse [Starter Prompts](/starter-prompts) for prompt patterns that reliably
  produce clean, articulated assets.
</Tip>

## 2. Watch the pipeline run

After you submit, a progress panel streams each stage of generation live, just
above the input bar. Under the hood the agent plans the asset, generates each
component, assembles and reviews them, refines materials, then wires up joints
and physics, validating the result for robotics use.

<Frame>
  <img alt="Generation pipeline progress" />
</Frame>

While it runs you can:

* **Queue a follow-up.** Type another instruction and it is applied after the
  current step finishes.
* **Stop.** Cancel the run with the stop button.

When generation finishes, the asset appears in the viewport and is saved to this
scene's **Asset Library** for re-use.

<Frame>
  <img alt="Completed asset in the viewport" />
</Frame>

## 3. Keep chatting to edit the scene

The Agent panel is not just for the first generation. Once a scene exists, keep
typing instructions to change it: "make the drawer deeper", "add a second shelf",
"swap the handle for a round knob", or "scatter four mugs on the counter". The
agent edits the existing scene in place rather than starting over, so you can
build up a complex environment one instruction at a time.

## 4. Navigate and edit in the viewport

The tool strip in the top-left of the viewport controls how you edit selected
objects:

| Tool       | What it does                                                  |
| ---------- | ------------------------------------------------------------- |
| **Move**   | Translate the selection along the gizmo axes                  |
| **Rotate** | Rotate the selection                                          |
| **Scale**  | Resize the selection                                          |
| **Play**   | Simulate physics in the browser to check joints and stability |

When something is selected, the strip also shows **Duplicate** (Ctrl+D) and
**Delete** (Del).

<Frame>
  <img alt="Viewport tool strip" />
</Frame>

### Camera and selection shortcuts

| Key                           | Action                         |
| ----------------------------- | ------------------------------ |
| **WASD**                      | Fly the camera                 |
| **Right-mouse drag**          | Look around                    |
| **F**                         | Focus the selected object      |
| **Esc**                       | Deselect                       |
| **Del**                       | Delete the selection           |
| **Ctrl+Z** / **Ctrl+Shift+Z** | Undo / Redo                    |
| **Ctrl+D**                    | Duplicate the selection        |
| **\[** / **]**                | Toggle the left / right panels |

### Test physics with Play

Press **Play** to drop the scene into a live physics simulation right in the
browser. Use it to confirm that doors swing the right way, drawers slide along
the correct axis, and nothing falls through the floor or jitters. **Pause** to
freeze, and **Stop** to return to editing exactly where you left off. Running
Play before exporting catches most articulation and stability problems early.

## 5. Group parts so joints work

Joints connect parts that move relative to each other (a lid to a box, a drawer
to a cabinet). Generated assets are grouped for you, but when you build or edit
by hand you may need to group parts yourself so they articulate as one mechanism.

On the **Shapes** or **Assets** tab, click **Group**, tick the parts that belong
together (you need at least two), then click **Done**. Group by *mechanical
function*: everything that should move together as one rigid body, with the parts
that rotate or slide relative to it kept as separate, jointed pieces.

See [Joints and Physics](/joints-and-physics) for how articulation is modeled.

## 6. Add things by hand

Generation gets you most of the way, but you can also build or extend a scene
manually.

* **Create menu** (toolbar) and the **Shapes** tab drop in primitives: box,
  sphere, cylinder, cone, capsule, torus, ellipsoid, wedge, tube, and more. The
  Create menu also adds a **Rope**, directional/point/spot **Lights**, and a
  **Terrain > Import DEM** option for bringing in GeoTIFF heightfields.
* **Robotics menu** (toolbar) opens the robot library and adds **robot spawns**,
  **semantic regions**, and **sensor anchors** (covered in step 8).

<Frame>
  <img alt="Create menu with primitive shapes" />
</Frame>

### Drop in premade assets

Click **Catalog** in the toolbar to browse a library of ready-made, physics-ready
props. Search by name, preview in 3D, and place directly into your scene with no
waiting for generation.

<Frame>
  <img alt="Premade asset catalog" />
</Frame>

### Build a single asset in isolation

Click **Asset Builder** in the toolbar to open a focused workspace for creating
or refining one asset on its own, away from the full scene. Save it to the Asset
Library when you are done, and it becomes available to place like any other asset.

## 7. Inspect and fine-tune

Select any object to open the **Inspector** on the right. This is where you dial
in the exact values a simulator needs.

<Frame>
  <img alt="Inspector panel" />
</Frame>

The Inspector exposes:

* **Transform** position and rotation (and scale), edited numerically or with the
  viewport gizmos.
* **Dimensions** the primitive's size parameters.
* **Material** surface type and color, with physically based presets (metal,
  plastic, wood, glass, rubber, and more).
* **Rigid physics** mass, density, friction, and restitution, plus advanced
  options like continuous collision detection, linear and angular damping, and
  center of mass.
* **Robotics properties** on assets: body type (dynamic, static, articulated,
  kinematic, or visual-only) and collision approximation (convex hull, box,
  sphere, capsule, trimesh, or compound). These map directly to how the asset
  behaves in the simulator.
* **Joints** the joint type and its limits, stiffness, and damping for articulated
  parts.

The **Asset Library** tab (next to Inspector) lists every asset generated for
this scene, so you can re-insert copies without regenerating. It also has an
**import** button for bringing in your own USD, USDZ, or GLB assets.

After generating, it is worth a quick check:

* Are the dimensions reasonable for a robot to interact with?
* Are doors, drawers, and lids grouped correctly?
* Do joints rotate or slide in the expected direction (use **Play**)?
* Are collision shapes present and is mass / friction populated?

## 8. Set up the scene for robotics

The **Robotics** tab and the **Robotics** menu add the entities a simulator
needs beyond geometry:

* **Robot spawn** marks where (and which) robot enters the scene. Use the
  **Robotics > Browse robot library** dialog to search the built-in MuJoCo
  Menagerie catalog or pick from your own uploaded MJCF/URDF robots. You can
  also embed a specific robot at export time (see step 10).
* **Semantic region** a named volume (for example "pickup zone" or "goal area")
  used for tasks, rewards, and navigation targets.
* **Sensor anchor** a placed pose for a camera, depth camera, lidar, IMU, or
  contact sensor, so your robot perceives the scene from a known location.

<Frame>
  <img alt="Robotics tab with spawn, region, and sensor anchor" />
</Frame>

Select any of these to position it and edit its properties in the Inspector, just
like a primitive. A sensor anchor, for example, exposes its sensor type (RGB,
depth, segmentation, lidar), field of view, and resolution; a robot spawn exposes
its name and base region.

## 9. Scene settings and physics defaults

Open the **Scene** tab to configure how the whole scene compiles and simulates.
These defaults apply to every object that does not override them, so setting them
once here saves a lot of per-object tuning.

* **Scene type** manipulation, navigation, loco-manipulation, dexterous, or
  custom. This signals the intended task.
* **Export target** Isaac Sim, MuJoCo, or both, so the scene compiles for the
  right backend.
* **Compile profile** preview, default, fast (low fidelity), accurate (high
  fidelity), or GPU-accelerated, trading speed against fidelity.
* **Global physics** gravity, default friction, default restitution, and the
  simulation time step.
* **Solver settings** the integrator and friction cone, the PhysX solver (for
  Isaac Sim), and the MuJoCo solver with its iteration and tolerance controls
  (important for stable RL training).
* **Aerodynamics** optional air density, viscosity, and wind for scenes that use
  soft bodies or fluid shapes.

<Frame>
  <img alt="Scene settings and physics defaults panel" />
</Frame>

<Tip>
  If you are not sure, leave these at their defaults. Gravity of -9.81 m/s²,
  default friction, and the recommended solver work well for most manipulation
  scenes. Revisit them only when simulation behavior looks off.
</Tip>

## Save your work

The scene **autosaves** as you work. The **Save** button in the toolbar turns
green whenever there are unsaved changes; click it to save immediately, and it
shows a checkmark once everything is stored. There is also a **Clear all** button
next to it that empties the scene, so use it deliberately.

## 10. Export to your simulator

When the scene is ready, use **Export** in the toolbar. The same scene can be
exported to multiple targets, and joints and physics come along, so it is ready
to simulate.

<Frame>
  <img alt="Export menu" />
</Frame>

| Target                | Format           |
| --------------------- | ---------------- |
| Isaac Sim / Omniverse | USD / USDZ       |
| MuJoCo                | MJCF zip         |
| Gazebo                | SDF world bundle |
| Mesh interchange      | GLB              |

You can optionally embed a robot at export time. The export dialog shows a
**Robot Embodiment** selector: pick "Use each spawn's robot" to keep the robots
assigned to each spawn, or choose a specific robot (Franka Panda, UR5, etc.) to
override every spawn. For the details of what each format includes, see
[Export Behavior](/export-behavior).

## A typical end-to-end flow

1. Describe the asset or scene on the **Agent** tab, optionally with a reference
   image.
2. Watch the pipeline finish, then **chat** to refine it.
3. **Navigate** the viewport and press **Play** to check joints and stability.
4. Add anything missing by hand (**Create** menu, **Catalog**, **Asset Builder**).
5. **Inspect** key objects to tune dimensions, materials, mass, and joints.
6. Add **robotics** entities (spawn, regions, sensors) and set **Scene** physics.
7. **Save**, then **Export** to your simulator.

## Next steps

* [First Workflow](/first-workflow) a condensed generate, preview, export run.
* [Starter Prompts](/starter-prompts) prompt ideas that generate well.
* [Joints and Physics](/joints-and-physics) how articulation and physics work.
* [Troubleshooting](/troubleshooting) fixes for common issues.


# Export Behavior
Source: https://docs.gizmo.antimlabs.com/export-behavior

How Gizmo exports to USD, MJCF, SDF, and GLB for different simulators

Every scene you generate stays in your Gizmo library. The same scene can be exported to any supported simulator on demand — no separate per-simulator authoring, no manual re-conversion. Robotics metadata (joints, masses, inertias, collision shapes, materials, affordances) is preserved through the simulator export paths (USD, MJCF, SDF). GLB is visual-only and does not carry physics or joints.

Gizmo supports five export formats:

* **USD / USDZ** — for NVIDIA Isaac Sim and Omniverse
* **MJCF** — for MuJoCo
* **SDF** — for Gazebo
* **GLB** — visual mesh interchange (lossy, no physics)

## USD / Isaac Sim

Gizmo exports USD/USDZ with:

* Native USD primitives where possible
* Meshes for CSG operations, modifiers, extrudes, shells, tori, tubes, and other complex geometry
* Materials and PBR texture references
* Physics collision metadata
* Rigid body metadata
* Mass and inertia
* Revolute, prismatic, spherical, and fixed joints
* Joint limits
* Mimic / coupled joint metadata where applicable
* Soft bodies as PhysX deformables — the bundle includes a
  `setup_deformables.py` script that cooks the deformable bodies through
  Isaac Sim's PhysX pipeline (run it once in **Window > Script Editor**
  after loading the stage; PhysX cooking cannot be authored in raw USDA)
* Custom attributes that preserve parametric data

Use USD when targeting Isaac Sim or Omniverse.

## MJCF / MuJoCo

Gizmo exports a zipped MJCF project with:

* Main XML file
* Mesh directory
* Texture directory
* Bodies and geoms
* Inertial properties
* Hinges, slides, ball joints, free joints, and fixed relationships
* Equality constraints for coupled joints
* Soft bodies as `flexcomp` deformables (cloth, cushions, and other soft
  materials), authored to MuJoCo's reference patterns

Use MJCF when targeting MuJoCo.

### MuJoCo version requirements

| Scene contents            | Minimum MuJoCo version |
| ------------------------- | ---------------------- |
| Rigid bodies only         | **3.3**                |
| Soft bodies (deformables) | **3.9**                |

Older MuJoCo versions crash the moment the file is opened: releases before
3.3 reject the solver configuration at parse time, and releases before 3.9
abort on deformable scenes with a constraint-allocation error
(`mj_makeConstraint: constraint Jacobian mis-allocation`) — a MuJoCo
sparse-solver bug fixed in 3.9. If MuJoCo closes instantly when you open an
exported scene, update to the latest MuJoCo release. Gizmo's in-browser
Play mode runs MuJoCo 3.10, so exports match what you previewed.

## SDF / Gazebo

Gizmo exports an SDF world bundle with:

* World file with physics and scene configuration
* Model directories with meshes (OBJ/STL) and materials
* Links, joints, and collision geometry
* Inertial properties
* Sensor definitions (camera, depth camera, GPU lidar, IMU, contact)
* Fuel robot URIs for standard robot profiles

The SDF specification has no soft-body element, so deformable prims export
as rigid bodies in SDF. Use the USD or MJCF export when soft-body physics
matters.

Use SDF when targeting Gazebo (Classic or Ignition/Garden).

## Robot Embedding

At export time, you can optionally embed a robot into your scene. The editor lets you place robot spawns from the **Robotics > Browse robot library** menu (searchable MuJoCo Menagerie + your own uploaded MJCF/URDF robots), and the export dialog lets you pick a specific robot embodiment or use each spawn's assigned robot. Supported built-in profiles range from Franka Panda and UR arms to quadrupeds (Spot, Go2, ANYmal) and humanoids (H1, G1, Digit, etc.).

## API Export

Export programmatically without the browser:

```bash theme={null}
curl -X POST "https://api.gizmo.antimlabs.com/v1/scenes/{scene_id}/export" \
  -H "Authorization: Bearer gzm_k1_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format": "mjcf"}' \
  -o scene.zip
```

Supported `format` values: `mjcf`, `usd`, `usdz`, `sdf`. Optionally include `robot_profile` to override every robot spawn with a specific embodiment.

## Cross-Simulator Testing

Because the same Gizmo scene drives all export paths, you can compare behavior across simulators directly:

1. Generate the scene once in Gizmo.
2. **Export → USD** and load it in Isaac Sim.
3. **Export → MJCF** and load it in MuJoCo.
4. **Export → SDF** and load it in Gazebo.
5. Compare physics, articulation, and contact behavior side by side.

Any change you make to the scene in Gizmo flows to all targets on the next export.


# First Workflow
Source: https://docs.gizmo.antimlabs.com/first-workflow

Step-by-step guide to generating, previewing, and exporting your first asset

## A. Generate an Asset

Open the editor, and try a prompt such as:

> industrial metal cabinet with two hinged doors and three sliding drawers

or attach a reference image alongside your prompt:

> mobile lab cart with drawers, caster wheels, and a handle

The agent can use multiple geometry pipelines:

* **Auto** (default) — lets the agent pick the best approach
* **Parametric** — editable primitives with modifiers
* **Precision CAD** — B-Rep solids for mechanical/engineering parts

The agent handles everything a robotics team cares about, end-to-end:

* **Articulated structure** — correct joints (revolute, prismatic, spherical, or fixed) with sensible limits
* **Collision geometry** — for every body, including convex decomposition for complex shapes
* **Mass, inertia, friction, and restitution** — computed per primitive from material density and geometry
* **Material assignments** — PBR textures generated to match the asset
* **Affordances** — doors, drawers, lids, knobs, handles, and wheels, correctly grouped and labeled
* **Robotics validation** — the asset is ready to drop into a downstream simulator without manual cleanup

Once generation is complete, the asset is saved to your library and ready for inspection, simulation, and export.

After generation, inspect the following:

* Are the dimensions reasonable?
* Are doors and drawers grouped correctly?
* Do joints rotate or slide in the expected direction?
* Are collision shapes present?
* Are mass, friction, and material settings populated?

## B. Use Premade Assets

For common objects, browse the premade catalog (3,000+ physics-ready assets). You can search by name or category, preview in 3D, and place directly into your scene without waiting for generation.

## C. Run the Physics Preview

Click **Play** in the editor.

The browser preview uses real-time physics, allowing you to inspect joint behavior before exporting to an external simulator. Verify that:

* Doors swing around the correct hinge edge
* Drawers slide along the correct axis
* Objects do not fall through the floor
* Collision approximations are reasonable
* Articulated parts remain attached

## D. Export

The same scene can be exported to multiple targets — choose whichever simulator you want to test in.

From the editor toolbar:

* **Export → Export USD** (Isaac Sim / Omniverse)
* **Export → Export MJCF** (MuJoCo)
* **Export → Export SDF** (Gazebo)
* **Export → Export USDZ** (single-file USDZ archive)
* **Export → Export GLB** (visual mesh interchange)

| Target                | Export Format                 |
| --------------------- | ----------------------------- |
| Isaac Sim / Omniverse | USD / USDZ                    |
| MuJoCo                | MJCF zip                      |
| Gazebo                | SDF world bundle              |
| Mesh interchange      | GLB (visual-only, no physics) |

You can also optionally embed a robot from the robot library at export time.


# Getting Started
Source: https://docs.gizmo.antimlabs.com/getting-started

How to start using Gizmo — browser editor and API access

## Browser Editor

Gizmo runs entirely in the browser — no installation required.

1. Sign up at [gizmo.antimlabs.com](https://gizmo.antimlabs.com)
2. Sign in and open the editor
3. Type a prompt or attach a reference image
4. Watch the agent build your scene in real time

Your scenes, assets, generated textures, and exports are all stored in your Gizmo workspace.

## API Access

For programmatic workflows, Gizmo provides a REST API at `https://api.gizmo.antimlabs.com/v1/`.

1. Create an API key in [**Settings → API Keys**](https://gizmo.antimlabs.com/settings#api-keys)
2. Pass it via the `Authorization` header:

```bash theme={null}
curl "https://api.gizmo.antimlabs.com/v1/whoami" \
  -H "Authorization: Bearer gzm_k1_YOUR_KEY"
```

See [API Access](/api-access) for the full endpoint reference.

## What Gets Generated

Every asset the agent produces includes:

* **Geometry** — parametric primitives or precision CAD solids
* **Materials** — PBR textures with surface type classification
* **Joints** — revolute, prismatic, spherical, or fixed, with axis and limits
* **Physics** — mass, inertia, friction, restitution, collision shapes
* **Affordances** — labeled handles, knobs, drawers, doors, wheels
* **Groups** — components grouped by mechanical function

## Credits and Billing

Generation consumes credits. Your current balance is visible in Settings. The API returns `402 Insufficient Credits` when your balance is depleted.


# What is Gizmo?
Source: https://docs.gizmo.antimlabs.com/index

AI-powered 3D simulation authoring for robotics — generate physics-ready scenes and assets from text prompts or reference images

Gizmo is a browser-based 3D simulation authoring platform built for robotics teams. An AI agent handles the full workflow end-to-end — from a text prompt or reference image, it generates fully articulated assets and complete scenes with joints, physics, collision geometry, materials, and affordances baked in.

Gizmo exports to **NVIDIA Isaac Sim (USD / USDZ)**, **MuJoCo (MJCF)**, **Gazebo (SDF)**, and **GLB** (visual mesh interchange).

<Note>
  **Gizmo is in beta** — you may see occasional asset failures while generating. Regenerating usually resolves it, and a failed asset doesn't block the rest of the scene from completing.
</Note>

## Overview

Rather than generating baked polygon meshes that are difficult to edit or simulate, Gizmo builds scenes and assets from structured, parameterized primitives. Dimensions, transforms, materials, modifiers, joints, physics, collision settings, and affordances are all represented explicitly and remain editable after generation — shapes carry modifiers like bend, taper, twist, chamfer, shell, and bulge.

## Use Cases

* Quickly generating digital-twin-style indoor environments from a text prompt or reference image
* Creating articulated assets such as drawers, cabinets, doors, appliances, lab equipment, robotic arms, and furniture
* Browsing and placing physics-ready premade assets from the built-in catalog (3,000+ objects)
* Storing every scene in your Gizmo library, with on-demand export to whichever simulator you need
* Testing the same scene across multiple simulator backends without re-authoring
* Iterating on simulation environments without weeks of manual 3D modeling
* Programmatic scene generation via the REST API for CI/CD and batch workflows

## Key Features

| Feature             | Description                                                          |
| ------------------- | -------------------------------------------------------------------- |
| Text-to-scene       | Generate full environments from natural language                     |
| Reference images    | Attach a photo or sketch to guide generation                         |
| Articulated joints  | Revolute, prismatic, spherical, and fixed joints with correct limits |
| Physics metadata    | Mass, inertia, friction, restitution, collision geometry per body    |
| Multi-format export | USD, USDZ, MJCF, SDF, and GLB from the same scene — no re-authoring  |
| Premade catalog     | 3,000+ physics-ready assets organized by category                    |
| REST API            | Programmatic access for automation, CI/CD, and batch generation      |
| Real-time preview   | Browser-based physics simulation for quick inspection                |
| Robot library       | Searchable MuJoCo Menagerie + your own uploaded MJCF/URDF robots     |
| Robot embedding     | Attach robot embodiments (Franka, UR5, etc.) at export time          |
| Precision CAD       | B-Rep solids via build123d for exact mechanical/engineering parts    |


# Joints and Physics
Source: https://docs.gizmo.antimlabs.com/joints-and-physics

Joint types, axis conventions, and physics metadata in Gizmo

Gizmo uses a consistent, robotics-oriented joint model.

## Joint Types

| Joint     | Common Use                              |
| --------- | --------------------------------------- |
| Revolute  | Doors, lids, knobs, levers, wheels      |
| Prismatic | Drawers, sliders, pistons, gripper jaws |
| Spherical | Gimbals, shoulders, ball joints         |
| Fixed     | Welded or rigid attachments             |

## Axis Convention

Joint axes are authored in the **asset-local frame**.

| Object                  | Joint                           |
| ----------------------- | ------------------------------- |
| Cabinet door            | Revolute, vertical Z-axis hinge |
| Drawer                  | Prismatic, forward/back axis    |
| Oven or dishwasher door | Revolute, bottom hinge          |
| Knob or dial            | Revolute around stem direction  |
| Wheel                   | Revolute around wheel normal    |

## Physics Metadata

For each primitive, Gizmo computes:

* Material density
* Analytical or estimated volume
* Mass
* Inertia tensor
* Friction
* Restitution
* Collision approximation
* V-HACD convex decomposition for complex collision geometry


# Practical Notes
Source: https://docs.gizmo.antimlabs.com/practical-notes

Important practical considerations when using Gizmo

* **Beta — occasional failures.** Gizmo is in beta, so you may see occasional asset failures during generation. Regenerating usually resolves it, and a failed asset doesn't block the rest of the scene from completing.
* **Generation time.** Large or complex assets can take several minutes. Progress streams into the editor as the agent works through each stage, so you can watch the asset being built rather than waiting for a single final result.
* **Browser physics.** The browser preview is intended for quick inspection, not as a replacement for final Isaac Sim, MuJoCo, or Gazebo validation.
* **Lossy formats.** GLB export is visual-only and lossy. For robotics use cases, prefer USD, MJCF, or SDF.
* **Reference images.** Attaching a reference image significantly improves output quality. The agent uses it for component counting, proportions, material identification, and final review.
* **Premade catalog.** For common objects (chairs, tables, shelves, appliances), check the premade catalog first — it's faster than generating from scratch and the assets are physics-validated.
* **Deformable physics is opt-in.** Soft-body and deformable simulation is disabled by default — most simulations do not require it, and enabling it everywhere would add unnecessary solver cost. To enable it for a specific asset, navigate to **Physics → Deformable** in the right-hand inspector and toggle it on.
* **Unexpected joint behavior.** If a joint behaves unexpectedly, check the joint axis convention first (see [Joints and Physics](/joints-and-physics)).
* **Older assets.** If a transparent surface (e.g., glass) renders as plastic on an asset generated before recent material-normalization fixes, regenerate it.
* **API rate limits.** Default rate limits are 100 requests/minute per key. Check `X-RateLimit-Remaining` headers to avoid throttling.


# Quality Checklist
Source: https://docs.gizmo.antimlabs.com/quality-checklist

Checklist for evaluating generated assets and scenes

Use this checklist when evaluating a generated asset or scene.

## Asset Generation

* Does the generated asset match the prompt or reference image?
* Are major components represented separately rather than baked into a single mesh?
* Are dimensions editable after generation?
* Are materials assigned sensibly?
* Are soft or curved details represented with modifiers where appropriate?

## Articulation

* Are doors, drawers, lids, and knobs grouped correctly?
* Are joint axes correct?
* Are limits reasonable?
* Does the browser preview match the expected physical motion?
* Does the exported simulator preserve the motion?

## Physics

* Are rigid bodies present where expected?
* Are collision shapes usable?
* Are masses and inertias populated?
* Do objects remain stable under simulation?
* Are complex shapes decomposed into practical collision geometry?

## Export

* Does the USD file open in Isaac Sim?
* Does the MJCF file compile in MuJoCo?
* Does the SDF world load in Gazebo?
* Are textures and meshes included?
* Are joints preserved?
* Are collision, mass, and material settings preserved?
* Does the same scene behave consistently across simulator backends?
* Do embedded robots (if any) appear at the correct base position?

## Workflow

* How long does it take to create a usable scene compared with manual authoring?
* Can non-3D-modelers use the workflow?
* Are generated assets easy to correct?
* Is the output structured enough for the rest of your robotics pipeline?


# Starter Prompts
Source: https://docs.gizmo.antimlabs.com/starter-prompts

Recommended prompts for quick testing across furniture, appliances, lab equipment, and scenes

These prompts are useful for quick testing across furniture, appliances, lab equipment, and full scenes. For best results, attach a reference image alongside your prompt.

## Articulated Single Assets

> industrial metal cabinet with two hinged doors and three sliding drawers

> hospital supply cart with sliding drawers, caster wheels, and push handle

> robotics lab bench with drawers, shelves, instruments, and cable trays

> front-loading washing machine with articulated circular door

> warehouse storage rack with bins, labels, and metal frame

> 6-DOF robotic arm with gripper end-effector

> standing desk with motorized height adjustment

## Full Scenes

> small apartment kitchen with cabinets, fridge, stove, sink, and island

> robotics testing room with workbench, charging dock, shelves, and floor markers

> warehouse floor with pallet racks, conveyor belt, and loading dock

> hospital room with adjustable bed, IV stand, supply cart, and monitors


# Troubleshooting
Source: https://docs.gizmo.antimlabs.com/troubleshooting

Common issues and how to resolve them

The agent gets most things right end-to-end, but if something is off, the fastest path is usually to try a quick manual fix in the editor before regenerating. Because every scene and asset is parametric, almost everything — joints, materials, dimensions, collision settings — is editable in the right-hand inspector after generation.

## Joint Moves in the Wrong Direction in MuJoCo, Isaac Sim, or Gazebo

Try fixing it manually first — this is usually a 30-second adjustment.

1. Select the problematic joint in the right-hand inspector.
2. Compare the axis (X / Y / Z), anchor point, and limits against the convention in [Joints and Physics](/joints-and-physics).
3. Flip the axis or adjust the anchor as needed.
4. Re-export and re-test in the target simulator.

If the joint still behaves incorrectly after a manual axis fix, regenerate the asset with a more specific prompt about the articulation (e.g., "front-loading washing machine with circular door hinged on the **left** side").

## Joint Behaves Correctly in the Gizmo Preview but Incorrectly After Export

Re-export the scene first — the export pipeline may have been updated since the asset was generated. If the issue persists, regenerate the affected asset; older assets may predate specific joint-export fixes.

## USD Opens but Joints or Bodies Look Wrong in Isaac Sim

Open the asset in Gizmo and check the inspector. If joints, masses, or collision shapes are present in Gizmo but missing in the export, re-export. If they are missing in Gizmo too, fix them manually in the inspector — add a joint, set mass, assign a collision approximation — and then re-export. Regenerate only if the asset is structurally too far off to repair.

## MJCF Fails to Compile in MuJoCo

Re-export the scene first. If it still fails, the MuJoCo error usually points to a specific body or joint — open that part in the inspector and adjust the offending field (often a missing inertia, an out-of-range joint limit, or a collision shape that needs a different approximation). Regenerate as a last resort.

## SDF Fails to Load in Gazebo

Re-export with the latest pipeline. Common issues: missing mesh references (re-export resolves this), unsupported joint types in older Gazebo versions, or sensor configuration mismatches. Check the Gazebo terminal output for specific element errors.

## Glass Renders as Plastic (or Any Material Appears Wrong)

Open the asset, find the primitive in the inspector, and change its surface type or material directly. This is faster than regenerating for a small material correction. If many primitives are affected, regenerate the asset.

## Generated Scene Looks Different from the Reference Image

Try editing in place first — move or rotate primitives, swap materials, or adjust dimensions in the inspector. If the issue is structural (missing components, incorrect overall layout), regenerate with a more detailed prompt that specifies counts, materials, and layout cues.

## Asset Generation Seems Stuck

Long runs can take several minutes. Watch the stage progress in the editor — each stage prints a status update. If you see no progress for an extended period, refresh the page and retry the prompt.

## API Returns 402 Insufficient Credits

Your generation credit balance is depleted. Add credits or upgrade your plan in Settings. The API will not start new generation jobs until credits are available.

## API Returns 429 Rate Limit Exceeded

You've exceeded your per-key rate limit. Back off and retry after the `X-RateLimit-Reset` timestamp. Consider spreading requests across multiple keys if you need higher throughput.


# Use Gizmo from your agent
Source: https://docs.gizmo.antimlabs.com/use-with-your-agent

Give Claude Code, Codex, or any tool-using agent the Gizmo API — generate simulation-ready scenes and assets as part of your agent's own loops.

Gizmo is built to be driven by agents, not just chatboxes. Everything the editor can generate, your agent can generate through the API — and the docs themselves are agent-readable (this site serves [`/llms.txt`](/llms.txt), every page as markdown, and a full [OpenAPI spec](/openapi.json)).

## The 60-second setup

1. Create an API key at [gizmo.antimlabs.com/developers](https://gizmo.antimlabs.com/developers) (`gzm_k1_…`).
2. Paste the prompt below into Claude Code, Codex, or any agent with shell access.

```text Copy-paste this to your agent theme={null}
You have access to the Gizmo API (3D simulation authoring). Base URL:
https://api.gizmo.antimlabs.com — auth with header "Authorization: Bearer $GIZMO_API_KEY".

- Generate a scene:  POST /v1/scenes  {"prompt": "...", "reference_image_urls": ["https://..."]}
- Generate an asset: POST /v1/assets  {"prompt": "..."}  (scene auto-created if omitted)
- Both return 202 with {job_id, estimated_seconds, estimate_note} — TELL THE USER the
  estimate, then poll GET /v1/jobs/{job_id} at a sensible interval (or stream
  GET /v1/jobs/{job_id}/events, SSE). Job statuses: queued → running → succeeded | failed | cancelled.
- When succeeded: fetch the scene (GET /v1/scenes/{id}?include_graph=true) or export it —
  POST /v1/scenes/{id}/export {"format": "mjcf" | "usd" | "usdz" | "sdf"} for MuJoCo / Isaac Sim / Gazebo.
- Build method is automatic: structured/jointed objects → prim-built articulated (~15–20 min);
  organic objects → mesh scan (~2–4 min). Reference images ground the build in real photos.
- Full reference: https://docs.gizmo.antimlabs.com/llms.txt

Task: generate {describe what you want}, wait for it, then export it for {simulator} and
report the download link.
```

## What your agent should know

* **Everything is async.** Generation returns a `job_id` immediately; the `estimated_seconds` in the 202 response is honest (minutes, not seconds) — relay it to your human and size polling accordingly. Don't hot-poll: every 30–60s is plenty.
* **No knobs needed.** The API triages each request itself (build method, structure engine). A prompt and optionally reference images are the whole contract.
* **Exports are the outcome.** The point isn't the chat — it's an MJCF/USD/SDF bundle your robotics stack can load. Pipe the export into your repo, CI, or simulator as part of the loop.

## Loop ideas

* **"Keep my sim assets fresh":** a scheduled Claude loop that reads your task list, generates missing assets via `POST /v1/assets`, and commits exports to your repo.
* **Scene-per-scenario CI:** your agent generates an environment per test scenario (`POST /v1/scenes` with a reference photo of the real space), exports MJCF, and runs your policy against it.
* **Digital-twin refresh:** when the real space changes, drop new photos in a bucket; an agent loop regenerates the scene from the latest reference images.