# afk.ai Auto-Rig (npm · afk-rig)

Auto-rig 3D models (GLB, glTF, FBX) with skeleton, skin weights and 170+ animations via afk.ai.

- Trust score: 51/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `afk-rig`: 51/100 (this document), [markdown](https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig.md), [page](https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig)

## Channel facts

- Registry: `npm`
- Package: `afk-rig`
- Version: `1.3.5`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 63/100
  - No malware found by supply-chain analysis.
  - Known CVEs could not be checked: the version this server declares is not published in its registry.
  - No install/post-install scripts declared.
  - Dependency health could not be checked: the version this server declares is not published in its registry.
- **Provenance & Transparency**: 19/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 53/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 2840 tokens (~284/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 10/100
  - Stability observed for 3 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 94% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 10 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 11 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the afk.ai Auto-Rig MCP server?

afk.ai Auto-Rig runs locally as an npm package, launched with npx -y afk-rig. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add dyoburon-afk-rig -- npx -y afk-rig
```

### Cursor

```json
{
  "mcpServers": {
    "dyoburon-afk-rig": {
      "command": "npx",
      "args": [
        "-y",
        "afk-rig"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "dyoburon-afk-rig": {
      "command": "npx",
      "args": [
        "-y",
        "afk-rig"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add dyoburon-afk-rig -- npx -y afk-rig
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dyoburon-afk-rig": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "afk-rig"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add dyoburon-afk-rig --command npx --arg -y --arg afk-rig
```

### Hermes

```yaml
mcp_servers:
  dyoburon-afk-rig:
    command: "npx"
    args: ["-y", "afk-rig"]
```

### Netclaw

```json
{
  "McpServers": {
    "dyoburon-afk-rig": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "afk-rig"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add dyoburon-afk-rig -t stdio -c npx -a -y afk-rig
```

### Other

```json
{
  "mcpServers": {
    "dyoburon-afk-rig": {
      "command": "npx",
      "args": [
        "-y",
        "afk-rig"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 51, −10)

- [security regression] Known CVEs: pass → unverified
- [security regression] Tool safety: pass → unverified
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Capabilities: pass → unverified
- [functional regression] Dependency health: 0.85 → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional improvement] Stability: unverified → 0.10
- [functional] First check of Schema quality: unverified
- [functional] Package version: 1.3.2 → 1.3.5
- [functional] Package version: 1.3.2 → 1.3.4

### 2026-11-03 (score 61, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-02 (score 46)

First indexed and scored.

## MCP tools (10)

### `rig_model` (~235 tokens)

Auto-rig a 3D model file (.glb, .gltf with everything embedded, or .fbx; up to 200 MB) and write the rigged .glb with its animations. Takes about a minute. Returns where the file was written.

Input parameters:

- `animations`: all (default), none (just the rig), or animation names from list_body_types
- `facing`: which way the model faces, in degrees about its up axis; auto works it out
- `keep_arms_out` (boolean): humans: keep the arms out of the body in every animation, on this computer after the download, as afk.ai/rig does (seconds to a minute)
- `output` (string): where to write the rigged .glb (default: <model>.rigged.glb next to it)
- `path` (string, required): the model file (absolute, or relative to the server's working directory)
- `type` (string): what the model is: human for anything on two legs, fox for dogs/cats/wolves, horse for hoofed animals, and so on

### `image_to_character` (~268 tokens)

Make a rigged, animated 3D character from a picture (.png, .jpg or .webp of one character, whole; up to 20 MB): a 3D model made from the picture, rigged with every animation for its body type, written as a .glb. Takes about 2 to 3 minutes (up to 5 when the GPU is starting) and costs $0.25 of API credits, refunded if it fails. Returns where the file was written, what was charged and the credits left.

Input parameters:

- `animations`: all (default), none (just the rig), or animation names from list_body_types
- `keep_arms_out` (boolean): humans: keep the arms out of the body in every animation, on this computer after the download, as afk.ai/rig does (seconds to a minute)
- `output` (string): where to write the rigged .glb (default: <picture>.rigged.glb next to it)
- `path` (string, required): the picture (absolute, or relative to the server's working directory)
- `type` (string): what the character is: human for anything on two legs, fox for dogs/cats/wolves, horse for hoofed animals, and so on

### `get_account` (~51 tokens)

How many rigs the account can make (rigs_left: its free rigs this month, then its Lifetime API credit this month with afk.ai Lifetime, then its API credits), and its credit balance for characters.

### `list_body_types` (~37 tokens)

The body types a model can be rigged as, and (with type) that type's animations.

Input parameters:

- `type` (string)

### `rig_status` (~37 tokens)

A rig's status by id (rig_model waits for its rig, so this is for rigs started elsewhere).

Input parameters:

- `id` (string, required)

### `inspect_rig` (~260 tokens)

Measure a rigged .glb: its bones (names, parents, positions), meshes, height, the animations with problems, worst first, each with the moment it's worst at to render (ground: % of height its lowest point goes below the rest floor or stays above it, and which bone; stretching: % of skin torn at worst; humans: frames with a forearm or hand through the body, and the deepest) and the animation controls adjust_animation takes. Flying, swimming and other animations that leave the floor on purpose are marked in_the_air and not judged against it. Runs on this computer, free: about a second, a few for a human's 196 animations.

Input parameters:

- `animations` (array): only these animations, each listed whether it has a problem or not
- `file` (string, required): a rigged .glb (absolute, or relative to the server's working directory): one rig_model wrote, or any model on afk.ai's skeletons
- `limit` (integer): at most this many animations with problems, worst first (default 40; the rest are named)
- `type` (string): the body type, when it can't be told from the file (afk.ai's files say)

### `render_rig` (~415 tokens)

Draw a rigged .glb as an image to look at: at rest, or posed at a moment of one of its animations, with its skeleton over it (blue: its left, red: its right, orange: the middle) and rulers in model units. Pinkish-red skin is the inside of the mesh showing (a tear, or a part pushed through another). Also returns every joint drawn in the image with its pixel position and, posed, how far its lowest point is from the rest floor (lowest_point_vs_floor, % of height). Runs on this computer, free.

Input parameters:

- `animation` (string): pose it in this animation (inspect_rig lists them); default: at rest
- `file` (string, required): a rigged .glb (absolute, or relative to the server's working directory): one rig_model wrote, or any model on afk.ai's skeletons
- `focus`: zoom on a joint (name) or a point [x, y, z]
- `joints`: joints to draw (default main: no fingers or tips)
- `radius` (number): the zoomed area's radius in model units (default 15% of the height)
- `save_to` (string): also write the PNG here
- `size` (integer): pixels per view (default 640)
- `time` (number): seconds into the animation (default: its middle; inspect_rig gives each problem's worst moment)
- `type` (string): the body type, when it can't be told from the file (afk.ai's files say)
- `views` (array): default front and left (front looks from +Z, so the model's left is on the image's right)
- `weights` (boolean|string): true: color the skin by the bone each part follows; a bone name: how much each part follows that bone (blue none, red all)
- `xray` (boolean): the mesh see-through, to see joints inside it

### `adjust_animation` (~427 tokens)

Change animations of a rigged .glb as afk.ai/rig's Adjust > Animation does, and write a new .glb: turn parts of the body (controls such as armsUp, posture, headUp in degrees), change how it moves (speed, motion, bounce, sway, lag, lookAhead, width, lift, part:arms...), move a hand, foot or the body (positions, the limb reaching for it), and for humans keep the arms out of the body. inspect_rig lists the controls this body type has, with their ranges. Reports each changed animation's ground [before, after] (and arms-through-body frames with keep_arms_out). Runs on this computer, free.

Input parameters:

- `animations`: the animations to change: all (default) or names
- `controls` (object): control id -> value, e.g. {"armsUp": 15, "speed": 1.2}. Turns are degrees; movement multiplies (1 leaves it) except lag (seconds), lookAhead (0-1) and width (model units)
- `file` (string, required): a rigged .glb (absolute, or relative to the server's working directory): one rig_model wrote, or any model on afk.ai's skeletons
- `keep_arms_out` (number): humans: turn the arms, spine and neck as little as possible so arms and hands stay out of the body (1: all of the correction)
- `output` (string): where to write the result (default: the next free <model>-v2.glb, -v3... beside it; never the input)
- `positions` (object): hand_l, foot_r... or body: moved by an offset, the limb bending to reach it (feet stay planted)
- `ranges` (object): only part of each animation for a control or position id (seconds), eased in and out
- `type` (string): the body type, when it can't be told from the file (afk.ai's files say)

### `fix_stretching` (~184 tokens)

Find where the skin of a rigged .glb stretches or tears across its animations and heal it (afk.ai/rig's Fix stretching), writing a new .glb. Reports torn skin [before, after] overall and per animation. Runs on this computer, free.

Input parameters:

- `animations`: the animations to check and heal across (default all)
- `file` (string, required): a rigged .glb (absolute, or relative to the server's working directory): one rig_model wrote, or any model on afk.ai's skeletons
- `output` (string): where to write the result (default: the next free <model>-v2.glb, -v3... beside it; never the input)
- `type` (string): the body type, when it can't be told from the file (afk.ai's files say)

### `fix_spot` (~298 tokens)

Fix the skin weights of one spot of a rigged .glb (afk.ai/rig's Fix a spot) and write a new .glb. Pick the spot with where (every given condition must hold), then: follow (it moves with the wrong part: give it to bone), smooth (pinched, jagged or creased: strength light, medium or strong) or redo (it tears or sticks to another part: its weights worked out again from the nearest bones). Reports the bones the spot follows [before, after]. Runs on this computer, free.

Input parameters:

- `bone` (string): follow: the bone the spot should move with
- `file` (string, required): a rigged .glb (absolute, or relative to the server's working directory): one rig_model wrote, or any model on afk.ai's skeletons
- `fix` (string, required)
- `output` (string): where to write the result (default: the next free <model>-v2.glb, -v3... beside it; never the input)
- `strength` (string): smooth: how far (default medium)
- `type` (string): the body type, when it can't be told from the file (afk.ai's files say)
- `where` (required): the spot: near a joint, moving with bones, a mesh, a piece, a box or a sphere (all given must hold)

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig#diagnostics

## Score history

- 2026-11-05: 51
- 2026-11-04: 61
- 2026-11-03: 61
- 2026-11-02: 46

## Common questions

### What is the afk.ai Auto-Rig MCP server?

afk.ai Auto-Rig is an MCP server listed in the public MCP registry as io.github.dyoburon/afk-rig. Auto-rig 3D models (GLB, glTF, FBX) with skeleton, skin weights and 170+ animations via afk.ai. This page covers its npm package (afk-rig).

### Is the afk.ai Auto-Rig MCP server safe to use?

afk.ai Auto-Rig scores 51 out of 100 on VerifyMCP. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the afk.ai Auto-Rig MCP server expose?

afk.ai Auto-Rig exposes 10 tools: rig_model, image_to_character, get_account, list_body_types, rig_status, and 5 more. Their descriptions and schemas cost roughly 2,212 tokens of context every time the server is loaded.

### Is the afk.ai Auto-Rig MCP server still maintained?

afk.ai Auto-Rig is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the afk.ai Auto-Rig MCP server under?

afk.ai Auto-Rig declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/afk-rig
- Socket report: https://socket.dev/npm/package/afk-rig
- Website: https://afk.ai/developers
- Changelog RSS feed: https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig.xml
- Changelog JSON feed: https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig.json
- HTML version of this page: https://verifymcp.io/servers/dyoburon-afk-rig/afk-rig