Agents that model, rig and animate 3D characters.

Add it to your agent in one line

The public demo needs no token. It is rate limited and keeps your files (separate per client IP) for a day. Point any MCP client that speaks Streamable HTTP at the /mcp URL.

claude mcp add --transport http rig-worker \
  https://rig-worker-demo.epinnock.workers.dev/mcp

{
  "mcpServers": {
    "rig-worker": {
      "type": "http",
      "url": "https://rig-worker-demo.epinnock.workers.dev/mcp"
    }
  }
}

Or run the whole example from a terminal

git clone https://github.com/epinnock/rig-worker && cd rig-worker
node examples/pip/run.mjs            # model -> bind -> walk -> qa on the public demo, pictures in out/pip

From shapes to a walking character

Every picture on this page came out of the tools, the same pictures an agent sees after each call. The calls below are the ones in examples/pip; on the public demo the whole run takes about 23 seconds.

Model it from shapes

A model is a list of signed-distance shapes (spheres, capsules, tapered tubes, lathes, boxes...) combined in order with smooth unions, cuts and paint. The Worker meshes it into one closed, watertight mesh with vertex colours, ready to rig, and returns a preview in the same call.

{ "name": "model", "arguments": { "out": "pip.glb", "preview": {}, "model": { "shapes": [
  { "name": "head", "type": "sphere", "at": [0, 0.84, 0], "radius": 0.2, "blend": 0.04, "color": "#f1c6a6" },
  { "name": "arm", "type": "tube", "mirror": "x", "points": [[0.12, 0.64, 0, 0.052], [0.22, 0.52, 0.01, 0.046], [0.27, 0.41, 0.03, 0.043]], "blend": 0.03 },
  { "name": "eye", "type": "ellipsoid", "mirror": "x", "radii": [0.026, 0.032, 0.014], ... },
  ...
] } } }

19 shapes · 56,790 vertices · 1 piece · 8.0 s

Check the skeleton before binding

preview overlays a proposed skeleton on the mesh, so the agent can see a knee sitting outside the leg before it spends a bind. Bones are plain JSON: a head, a tail and a parent, in metres.

{ "name": "UpperLeg.L", "parent": "Hips",
  "head": [0.075, 0.36, 0], "tail": [0.08, 0.2, 0.005] }

14 bones, including a bobble on the hat · 0.6 s

Bind with automatic weights

bind solves bone heat (Baran & Popović 2007, the method behind Blender's Automatic Weights) on a closed voxel proxy, so it also works on broken scan or AI-generated meshes. A weights preview shows which bone owns each vertex.

{ "name": "bind", "arguments": { "file": "pip.glb", "out": "pip_rig.glb", "skeleton": { "bones": [...] } } }
// -> { createdSkin: true, vertices: 56790, bones: 14, bonesOwningNoVertex: [] }

9.0 s on the demo Worker

Animate, then check it

animate writes keyframes as Euler degrees per bone. qa samples the clip and reports frames that sink below the floor, stretched or squashed edges, and hotspots with a ready-made region to repair with paint_weights.

{ "name": "qa", "arguments": { "file": "pip_rig.glb", "animation": "walk", "frames": 24 } }
// -> summary: { framesSinkingBelowGround: 0, maxSink: 0.002, worstEdgeRatio: 4.88 }
//    hotspots: [{ dominantBone: "LowerLeg.L", restBox, surfacePoint, points, ... }]

walk: 15 channels, 8 keys, 1 s loop · qa 1.4 s

Build a model on the public demo

This calls the model tool on the demo Worker straight from your browser. Edit the JSON (change a colour, move the pompom, add a shape) and build. The demo allows 6 builds a minute.

The 14 tools

Files are GLBs in the Worker's R2 bucket, named with letters, digits, . _ -. Tools that change a file take out to save under a new name (default: overwrite). The full JSON schemas come from tools/list.

Conventions

• Space: glTF metres, +Y up, +Z front, +X the character's left. Stand characters on y = 0 facing +Z.
• Rotations: Euler degrees [x, y, z], applied X, then Y, then Z, about the world axes through the joint for bones bind made (+X swings a leg back, +Y turns toward the character's left, +Z raises the left arm), and about the joint's own rest axes for rigs made elsewhere. The bones themselves are stored pointing along the limb, as Blender expects.
• Views: azimuth degrees, 0 = front, 90 = the character's left side. The default camera frames the rest-pose bounds and stays the same between calls, so pictures compare.

A viewer the agent can hand you

Ask the agent to show you a model and it calls view. In Claude, and in other hosts that support MCP Apps, the viewer opens right in the chat. Everywhere else the tool returns a signed link that opens the same viewer in a browser for an hour (up to a week on a self-hosted Worker). Orbit and zoom, play or scrub every clip or go to the bind pose, colour the mesh by skin weights (by region, or one bone as a heat map), and turn on the wireframe, skeleton and bounds. The panel lists triangles, bones, size and every clip.

It is live. Every open copy of a file, inline or from a link, reloads within a few seconds when the agent saves that file again under the same name. You keep your camera, clip, time and shading. An old link shows the latest version until it expires.

Pip as the demo makes it. Open the viewer on its own page and drop in any .glb; the file stays in your browser.

Sculpting with clay primitives

Each shape is combined, in list order, with everything before it. Because the result is one signed distance field, the mesh is always closed and in one piece when the parts overlap, which is exactly what rigging wants.

{ "out": "pip2.glb", "from": "pip.glb", "patch": [
  { "name": "beanie", "color": "#cc3344" },
  { "name": "scarf", "type": "torus", "before": "head",
    "at": [0, 0.66, 0], "radius": 0.12, "thickness": 0.03 },
  { "name": "pocket", "remove": true }
] }

The loop an agent runs

inspect → preview with a proposed skeleton → bind → preview mode: "weights" → animate → preview frames + qa → paint_weights fixes → export. The same loop works on a GLB you upload: bind voxelizes the mesh into a closed proxy first, so hollow or many-piece meshes still get clean weights.

Skeleton JSON

{ "bones": [
  { "name": "Hips",  "parent": null,   "head": [0, 0.38, 0], "tail": [0, 0.5, 0] },
  { "name": "Spine", "parent": "Hips", "head": [0, 0.5, 0],  "tail": [0, 0.66, 0] },
  { "name": "Nose",  "parent": "Head", "head": [...], "tail": [...],
    "falloff": { "radius": 0.04, "power": 2, "at": "tail" } }
] }

falloff gives tiny bones (a nose, an ear tip) distance weights instead of heat. Bind again with an edited skeleton to move bones; bone names must match the existing skin.

Fixing weights

{ "bone": "Spine", "op": "set", "value": 1, "falloff": "smooth",
  "region": { "sphere": { "centre": [0, 0.52, -0.2], "radius": 0.11 } } }

Prefer a smooth sphere to a hard box: a box with set 1 leaves a seam where it ends (on Pip it raised the worst edge ratio from 5 to 20).

Your own private Worker

Self-hosting removes the demo limits and keeps your files private behind a token. You need a Cloudflare account on the Workers Paid plan, because a bind on a large mesh can use up to a minute of CPU (the config allows 5 minutes).

git clone https://github.com/epinnock/rig-worker && cd rig-worker
npm install
npx wrangler deploy                 # creates the R2 bucket on first deploy
openssl rand -hex 32 | npx wrangler secret put RIG_TOKEN
claude mcp add --transport http rig-worker https://rig-worker.<you>.workers.dev/mcp \
  --header "Authorization: Bearer <RIG_TOKEN>"

Develop and test locally

cp .dev.vars.example .dev.vars      # put a token in it
npm run dev                         # wrangler dev on :8799, local R2
npm test                            # model -> bind -> animate -> qa in Node, no network, ~15 s
RIG_TOKEN=... node examples/pip/run.mjs http://127.0.0.1:8799

Plain HTTP, besides MCP

Public demo limits

The demo is the same code with DEMO=1 (npx wrangler deploy --env demo): no token, so everything is capped.

Opens in Blender as it looks here

Every GLB rig-worker writes imports into Blender (tested with 4.5) with the default glTF settings and no clean-up, and Blender's own export comes back the same. A test in the repo checks this end to end: Blender builds a textured mesh and a rig of its own, rig-worker models, binds, paints and animates, Blender imports each result and compares it with rig-worker's numbers, then re-exports it for rig-worker to read back.

Run it with BLENDER=/path/to/blender npm run test:blender (about 30 s). Two things in the files exist for Blender's sake: animate keys every bone in every clip (bones a clip leaves alone hold their rest pose, because Blender otherwise keeps them where the last clip put them), and it adds keys every 20° on big turns, because Blender blends quaternion keys linearly where glTF asks for a slerp.

Speed, cost and accuracy

How it works

• Modelling (src/sdf.js): shapes compile to signed distance functions with bounding-sphere pruning; the field is sampled on a sparse grid (one sample per 4³ block away from the surface), meshed with surface nets, each vertex projected onto the true surface, coloured by the shape that owns it.
• Weights (src/heat.js): voxelize, close small gaps and flood-fill to a solid; extract and smooth a closed proxy surface; solve (L + A·H) w = A·H·p per bone with a cotangent Laplacian and visibility-tested nearest bones; copy weights back by nearest point; keep 4 influences.
• Pictures (src/render.js): a small software rasterizer writes PNG tiles with skeleton overlays, so the agent can look at its own work.
• Everything is plain JavaScript on typed arrays. The only dependency is glTF Transform for reading and writing GLB.

Known gaps

• No smoothing or removing of weights as an operation, and no undo for paint_weights (use out to keep versions).
• qa flags edges by length ratio and does not yet say stretched or squashed; tiny surface-net edges near creases can show high ratios.
• Rebuilding a model with a patch gives an unrigged mesh: bind it again (the skeleton JSON is reusable).
• model makes vertex colours only, no UVs or textures (meshes you bring keep theirs); linear blend skinning with 4 influences.