# Pose Lab (pypi · poselab-mcp)

Measured spatial answers for posing first-person arms and a rifle in Blender

- Trust score: 65/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-16

## Components

- pypi · `poselab-mcp`: 65/100 (this document), [markdown](https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp.md), [page](https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp)

## Channel facts

- Registry: `pypi`
- Package: `poselab-mcp`
- Version: `0.7.0`
- 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-10-16.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 53/100
  - AI-judged instruction clarity (fair).
  - Context-footprint check failed: tool/resource definitions use about 4587 tokens (~147/item across 31 items; 31 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 79/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 36% 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 31 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 32 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Pose Lab MCP server?

Pose Lab runs locally as a PyPI package, launched with uvx poselab-mcp. 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 hpdkhoa-poselab-mcp -- uvx poselab-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "hpdkhoa-poselab-mcp": {
      "command": "uvx",
      "args": [
        "poselab-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "hpdkhoa-poselab-mcp": {
      "command": "uvx",
      "args": [
        "poselab-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add hpdkhoa-poselab-mcp -- uvx poselab-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "hpdkhoa-poselab-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "poselab-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add hpdkhoa-poselab-mcp --command uvx --arg poselab-mcp
```

### Hermes

```yaml
mcp_servers:
  hpdkhoa-poselab-mcp:
    command: "uvx"
    args: ["poselab-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "hpdkhoa-poselab-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "poselab-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add hpdkhoa-poselab-mcp -t stdio -c uvx -a poselab-mcp
```

### Other

```json
{
  "mcpServers": {
    "hpdkhoa-poselab-mcp": {
      "command": "uvx",
      "args": [
        "poselab-mcp"
      ]
    }
  }
}
```

## 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-10-15 (score 65, +26)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Tool coverage: 36
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: fair
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail

### 2026-10-14 (score 39, 0)

- [functional regression] Security disclosure: fail → unverified
- [functional] Package version: 0.5.0 → 0.7.0
- [functional] Package version: 0.5.0 → 0.6.0

### 2026-10-13 (score 39, +15)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.4.0 → 0.5.0

### 2026-10-12 (score 24)

First indexed and scored.

## MCP tools (31)

### `list_rigs` (~31 tokens)

The rigs to load: the built-in sample and those in the rigs file (POSELAB_RIGS).

### `load_rig` (~55 tokens)

Loads a rig: the arms on their idle pose, the rifle on the gun bone, its clips. Returns the frames, sign rules,
named points, clips and moving parts. Call first.

Input parameters:

- `rig` (string, required)

### `describe` (~17 tokens)

What is loaded and the conventions every tool uses.

### `pose_idle` (~21 tokens)

The arms back on the idle pose, every rifle part home.

### `pose_clip` (~52 tokens)

The arms as a clip has them at a time in seconds. The rifle follows the gun bone; its parts stay where move_part
left them.

Input parameters:

- `clip` (string, required)
- `seconds` (number, required)

### `move_part` (~44 tokens)

Draws a moving part of the rifle (such as carrier) back along the barrel, cm from home.

Input parameters:

- `cm` (number, required)
- `part` (string, required)

### `move_gun` (~180 tokens)

Moves the rifle from where it stands: roll + turns its right side up (about the bore); swing + takes the muzzle
left, pitch + the muzzle up (about the pivot); right, forward, up move it in the view, cm. The hands in keep_hands
keep their hold. Returns how far each hand ended from its hold and the barrel's angle off the view line.

Input parameters:

- `forward` (number)
- `keep_hands` (array): hands that keep their hold on the rifle as it moves (arm IK)
- `pitch` (number)
- `pivot`: a rig point (stock, bore) or [x, y, z] in the gun frame
- `right` (number)
- `roll` (number)
- `swing` (number)
- `up` (number)

### `reach` (~171 tokens)

Puts a wrist on a point by arm IK; the hand keeps its turn. Returns how far the wrist ended from the point.
Trying poles while the wrist stays put moves only the elbow: a way to clear a forearm.

Input parameters:

- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `pole`: where the elbow points, arms frame cm
- `side` (string, required)
- `target` (required): a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame

### `turn_bone` (~180 tokens)

Turns one bone by degrees about an axis through its head; the bones below it follow and nothing else moves. Use
it to bend or straighten a finger joint, turn a wrist, or turn a whole arm at the shoulder. bone: a bone's name (an
unknown name lists them all). The two signs of degrees turn opposite ways. The rifle does not move: use move_gun.

Input parameters:

- `axis` (array, required): [x, y, z]: the axis's direction in the frame
- `bone` (string, required)
- `degrees` (number, required)
- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)

### `snapshot` (~36 tokens)

Saves or loads a named pose (the arms and the rifle's parts).

Input parameters:

- `action` (string, required)
- `name` (string, required)

### `where` (~92 tokens)

Where bones, fingertips (<finger>_tip_<l|r>) and rig points are, in a frame.

Input parameters:

- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `names` (array, required)

### `distance` (~162 tokens)

The distance between two points, cm, and b minus a in the frame.

Input parameters:

- `a` (required): a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame
- `b` (required): a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame
- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)

### `clearance` (~158 tokens)

How deep the rifle sits inside the arms (capsules: forearm 3 cm, palm 1.8 cm, finger segments 0.75 cm).
worst_cm 0 means nothing touches. The deepest contacts by segment, with the rifle point in the frame.

Input parameters:

- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `ignore` (array): segment names, prefixes or wildcards to leave out (thumb, index3_r, *_l)
- `parts` (string)
- `top` (integer)

### `anatomy` (~378 tokens)

Each arm against the human arm's limits. Rules: the elbow stays at least 2 cm below the shoulder while the hand
works the gun; the elbow is a hinge bent 5 to 150 degrees; the wrist stays within 30 degrees of the forearm's line
and inside its joint range (flexion 80, extension 70, radial 20, ulnar 30: the AAOS normal values); the hand's roll
belongs to the forearm, not the wrist joint: the forearm turns at most 80 degrees each way from thumb up (pronation
and supination, forearm_rotation_deg), and on a rig with forearm twist bones no link along the forearm rolls more
than 50 degrees (forearm_links_deg: the skin wrings there); without twist bones, the wrist's own twist against the
idle grip stays within 30 (wrist_twist_deg). Each finger joint curls only toward the palm within its range
(knuckle -30..100, middle joint -5..110, end joint -10..90) and stays in the finger's own plane: no hyperextended
or twisted finger. The thumb's knuckle bends -10..60 and its end joint -15..90 across the palm; its base spreads at
most 80 from the index metacarpal and sits at most 20 behind the palm. A rig's limits, finger_limits and
thumb_limits override these. Each rule reads the value as reported (whole degrees). ok false lists every rule a
pose breaks. Fix a
broken rule by moving the rifle, the grip or the elbow's pole, never by bending a joint further. arm_ranges gives
the research behind each limit.

Input parameters:

- `fingers` (boolean)
- `side` (string)

### `grip` (~495 tokens)

How each hand touches the rifle: with the palm or with the back. A hand holds with its palm and the palm sides of
its fingers. The back of the hand toward the rifle, or the rifle inside the back of the hand or of a finger, is a
physical error; clearance with palms and fingers ignored never shows it. For each hand: touching (some part within
hold_within_cm), holding (touching, the palm facing the rifle and its surface within palm_within_cm: palm_gap_cm;
a fingertip on the rifle with the palm off it is not holding), palm_faces_rifle (1 square on, below 0 the back of
the hand toward it), palm_contact_cm and
back_contact_cm (the deepest rifle point inside the hand on each side), and bad: every rule broken. ok false
lists them. The palm side may press in up to palm_max_cm (the capsules are rounder than a palm); the back side
only up to back_max_cm. hold true: a hand that is not holding breaks a rule (use it to check a hand really holds
something). Fix a wrong-side hold by turning the hand or the grip, not by moving a finger through the rifle.
grasping: the thumb and a finger pinch the rifle from opposite sides, each within contact_cm of it and their
directions from its surface at least 180 - 2 atan(friction) degrees apart (127 at friction 0.5);
grasp_opposition_deg is the widest thumb to finger angle, digits_touching the digits on the rifle. grasp true: a
hand that is not grasping breaks a rule (use it for a hand meant to hold a part, such as a magazine).

Input parameters:

- `back_max_cm` (number)
- `contact_cm` (number)
- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `friction` (number)
- `grasp` (boolean)
- `hold` (boolean)
- `hold_within_cm` (number)
- `palm_max_cm` (number)
- `palm_within_cm` (number)
- `side` (string)

### `arm_ranges` (~119 tokens)

The research behind anatomy's limits: for each joint of the arm (shoulder, elbow, forearm, wrist, finger
knuckle, middle and end joints, thumb), the AAOS normal range (the 1965 table; tables_differ shows where other
tables disagree), the range daily tasks use (Morrey 1981, Palmer 1985, Ryu 1991, Bain 2015), the value anatomy
checks, and why it differs from the standard where it does. Full citations included. Needs no rig.

### `faces_eye` (~100 tokens)

How squarely a surface faces the eye: facing 1 square on, 0 edge on, below 0 turned away.

Input parameters:

- `normal`: the surface's normal, gun frame; a rig normal by the point's name if left out
- `point`: a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame

### `visible` (~81 tokens)

The share of a small disc round a point that the eye sees with nothing (arms, rifle) in the way.

Input parameters:

- `point`: a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame
- `radius_cm` (number)

### `screen` (~85 tokens)

Where a point falls on a 90 degree, 16:9 screen from the eye: x and y from -1 to 1, and whether it is on screen.

Input parameters:

- `point` (required): a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame

### `solve` (~196 tokens)

Searches rifle moves from the current pose for one meeting every goal, and leaves the scene there. Reports each
goal at the best move and how often it was met across samples: a goal never met is a fact of the geometry.

Input parameters:

- `dofs` (object, required): roll, swing, pitch, right, forward, up -> [min, max]
- `goals` (array, required): each {type: faces_eye|visible (point, min), on_screen (point), clearance (parts, ignore, max_cm), anatomy (side, fingers), grip (side, back_max_cm, palm_max_cm), barrel (max_deg), distance (a, b, max…
- `keep_hands` (array): hands that keep their hold on the rifle as it moves (arm IK)
- `maximize`: a goal's index to push higher once all are met
- `pivot` (string)
- `samples` (integer)

### `record_clip` (~101 tokens)

Builds a clip from poses you set: start (a name), key (the current pose at a time in seconds), stop (bakes the
frames, each bone eased from key to key). Between keys the bones blend by rotation, so hands can drift off the
rifle between keys.

Input parameters:

- `action` (string, required)
- `clip`
- `ease` (boolean)
- `fps` (number)
- `seconds` (number)

### `load_clip` (~90 tokens)

Adds a clip from a file: .pose.json bone data, an FBX animation, or a BVH (for example a text-to-motion
model's output). A relative path is taken from the rigs file's folder. Reports how well its skeleton fits.

Input parameters:

- `bone_map`: the file's bone names -> this rig's
- `clip` (string, required)
- `path` (string, required)

### `scan_clip` (~196 tokens)

Plays a clip frame by frame and runs each check. Reports for each check whether it passed, the worst value
and when, and the time spans where it fails.

Input parameters:

- `checks` (array, required): each {type, ...}: clearance (parts, ignore, max_cm), anatomy (side both|l|r, fingers: the rules broken, counted), grip (side, back_max_cm, palm_max_cm: the hand's wrong-side or too-deep contacts, cou…
- `clip` (string, required)

### `fix_clip` (~314 tokens)

Mends a clip against the checks and stores a new clip (out, default <clip>_fixed): pops are blended again from
the good frames round them; a hold puts the hand back on its grip; a contact moves the wrist until the point
touches its mark; clearance swings each elbow about its shoulder-wrist line (the wrist kept) by the least angle
that clears, spread over neighbouring frames; anatomy swings the elbow the same way until it sits under the
shoulder inside its bend, then turns the wrist back inside its limits and each finger joint back inside its range.
Reports the scan before and after.

Input parameters:

- `checks` (array, required): each {type, ...}: clearance (parts, ignore, max_cm), anatomy (side both|l|r, fingers: the rules broken, counted), grip (side, back_max_cm, palm_max_cm: the hand's wrong-side or too-deep contacts, cou…
- `clip` (string, required)
- `max_swing_deg` (number)
- `out`
- `spread_frames` (integer)

### `view_cover` (~60 tokens)

The share of the player's view the arms cover (all, its lower left third, its bottom middle third): the arms
rendered alone from the eye as a mask. A forearm or sleeve that fills the lower left hides the gun and the world.

### `solve_grip` (~311 tokens)

Searches a hand's hold on the rifle: the palm on mark (moved along the barrel), the elbow toward each pole. A hold
counts when the palm holds the rifle (grip), nothing clips past clearance_max_cm (ignore: declared contacts), every
arm and finger rule holds, and the view stays within view_budget. The nearest hold to the mark that counts wins and
the rig is left in it; the table shows what failed where.

Input parameters:

- `along` (array): [from_cm, to_cm] along the barrel from the mark
- `clearance_max_cm` (number)
- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `ignore` (array)
- `mark` (required): a name (a bone such as hand_l, a fingertip such as index_tip_l, a rig point such as port) or [x, y, z] in the frame
- `poles`: elbow poles, arms frame cm; the idle elbow and four round it if left out
- `rolls` (array): the hand's roll about the barrel to try, degrees
- `side` (string, required)
- `steps` (integer)
- `view_budget`: {lower_left, bottom_middle}: the most of each third the arms may cover

### `retarget_clip` (~265 tokens)

Plays another rig's clip on this rig with one hand held on this gun's own hold (its rest hold, or mark) by arm
IK, fingers mended: shared motion, the gun's own grip. keep_from_s..keep_to_s: a span the hand leaves the gun (a
reload), kept as the clip has it. Stores the result as out (default <clip>_retarget).

Input parameters:

- `clip` (string, required)
- `frame` (string): gun: the gun bone, cm (+X gun's left, +Y barrel, +Z up); arms: the arms' space, cm; view: from the eye, cm (+X right, +Y forward, +Z up)
- `gun_move`: move_gun's arguments applied to every frame first (the other hand keeps its hold): a rifle carried lower or closer
- `hold` (string): the rig's idle hold, or the hold it stands in now (after solve_grip)
- `keep_from_s`
- `keep_to_s`
- `mark`
- `out`
- `pole`: where the elbow points (arms frame, cm), as solve_grip's best gives it
- `side` (string, required)

### `shift_hand` (~124 tokens)

Moves one hand frame by frame by the given deltas (gun frame, cm): a hand that holds a part whose track changed
follows the part's new path. The hand keeps its turn against the gun, its elbow its direction, its fingers their
curl; the wrist and fingers are mended.

Input parameters:

- `clip` (string, required)
- `deltas` (array, required): [[seconds, [x, y, z]], ...]: the hand's move in the gun frame (cm), straight lines between
- `out`
- `side` (string, required)

### `check_set` (~94 tokens)

Every check on a clip in one summary for a gate: the worst clearance and when, the frames that break an arm or
finger rule, the frames a hand in hold_sides is not holding, and each frame's numbers.

Input parameters:

- `clearance_max_cm` (number)
- `clip` (string, required)
- `hold_sides` (array)
- `ignore` (array)
- `sides` (string)

### `save_clip` (~69 tokens)

Writes a clip to the output folder's clips/: pose.json bone data, and fbx for a game engine.

Input parameters:

- `clip` (string, required)
- `formats` (array)
- `root_name`: the armature's name in the FBX (Unreal reads it as the root bone)

### `render` (~63 tokens)

Renders the pose as one labelled contact sheet: eye is the player's camera (90 degrees, 5 cm near plane); right,
left, top and front look at the rifle from outside. Every tile is a Blender view, labelled so.

Input parameters:

- `views` (array)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp#diagnostics

## Score history

- 2026-10-16: 65
- 2026-10-15: 65
- 2026-10-14: 39
- 2026-10-13: 39
- 2026-10-12: 24

## Common questions

### What is the Pose Lab MCP server?

Pose Lab is an MCP server listed in the public MCP registry as io.github.hpdkhoa/poselab-mcp. Measured spatial answers for posing first-person arms and a rifle in Blender. This page covers its PyPI package (poselab-mcp).

### Is the Pose Lab MCP server safe to use?

Pose Lab scores 65 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 16 October 2026. 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 Pose Lab MCP server expose?

Pose Lab exposes 31 tools: list_rigs, load_rig, describe, pose_idle, pose_clip, and 26 more. Their descriptions and schemas cost roughly 4,340 tokens of context every time the server is loaded.

### Is the Pose Lab MCP server still maintained?

Pose Lab is still listed as active in the MCP registry. We last reached this channel on 16 October 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 Pose Lab MCP server under?

Pose Lab 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

- PyPI project: https://pypi.org/project/poselab-mcp/
- Socket report: https://socket.dev/pypi/package/poselab-mcp
- Repository: https://github.com/hpdkhoa/poselab-mcp
- Changelog RSS feed: https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp.json
- HTML version of this page: https://verifymcp.io/servers/hpdkhoa-poselab-mcp/poselab-mcp