# OpenToonz MCP (pypi · opentoonz-mcp)

Animate in OpenToonz from an AI assistant: native vector levels, xsheet timing, rigs and physics.

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

## Components

- pypi · `opentoonz-mcp`: 75/100 (this document), [markdown](https://verifymcp.io/servers/konkomaji-opentoonz-mcp/opentoonz-mcp.md), [page](https://verifymcp.io/servers/konkomaji-opentoonz-mcp/opentoonz-mcp)

## Channel facts

- Registry: `pypi`
- Package: `opentoonz-mcp`
- Version: `0.1.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-23.

- **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 33 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to konkomaji/opentoonz-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 56/100
  - AI-judged instruction clarity (fair).
  - Context-footprint check failed: tool/resource definitions use about 5945 tokens (~114/item across 52 items; 52 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (10% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "delete_layer" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 53 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 OpenToonz MCP server?

OpenToonz MCP runs locally as a PyPI package, launched with uvx opentoonz-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 konkomaji-opentoonz-mcp -- uvx opentoonz-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "konkomaji-opentoonz-mcp": {
      "command": "uvx",
      "args": [
        "opentoonz-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "konkomaji-opentoonz-mcp": {
      "command": "uvx",
      "args": [
        "opentoonz-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add konkomaji-opentoonz-mcp -- uvx opentoonz-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add konkomaji-opentoonz-mcp --command uvx --arg opentoonz-mcp
```

### Hermes

```yaml
mcp_servers:
  konkomaji-opentoonz-mcp:
    command: "uvx"
    args: ["opentoonz-mcp"]
```

### Netclaw

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

### Vellum

```bash
assistant mcp add konkomaji-opentoonz-mcp -t stdio -c uvx -a opentoonz-mcp
```

### Other

```json
{
  "mcpServers": {
    "konkomaji-opentoonz-mcp": {
      "command": "uvx",
      "args": [
        "opentoonz-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-23 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 0 to 3. That category is still filling its 30-day observation window: 0 days of observed history at the previous scan, 1 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 74)

First indexed and scored.

## MCP tools (52)

### `opentoonz_info` (~27 tokens)

Install paths, version, scenes, and whether the OpenToonz GUI is running.

### `scene_context` (~52 tokens)

CALL FIRST. Full current state of a scene from disk: settings, layers, timing, keyframes,
outside (GUI) changes detected, notes/memory, recent journal, warnings.

Input parameters:

- `scene` (string, required)

### `add_note` (~45 tokens)

Save a memory note for this scene (story, character design, decisions, todo). Shown in scene_context.

Input parameters:

- `note` (string, required)
- `scene` (string, required)

### `get_journal` (~39 tokens)

Operation history of a scene (every MCP action, outside edits detected, errors).

Input parameters:

- `last` (integer)
- `scene` (string, required)

Output parameters:

- `result` (array)

### `style_guide` (~63 tokens)

Studio animation rules (Ghibli/Disney/anime practice) with numbers: timing, spacing, squash,
line weight, shading, camera. topic: 'rules' (numbered defaults) | 'full' | 'styles'.

Input parameters:

- `topic` (string)

Output parameters:

- `result` (string)

### `undo` (~41 tokens)

Restore the scene (and any overwritten vector levels) to the state before the last N MCP writes.

Input parameters:

- `scene` (string, required)
- `steps` (integer)

### `create_scene` (~99 tokens)

Create a scene in the OpenToonz sandbox project.
style: anime | feature | cartoon | sketch | clean (line weight, wobble, taper, default timing).

Input parameters:

- `bg_color` (string)
- `fps` (number)
- `frames` (integer)
- `height` (integer)
- `name` (string, required)
- `overwrite` (boolean)
- `style` (string)
- `width` (integer)

### `import_scene` (~94 tokens)

Bring an existing OpenToonz .tnz (made in the GUI) under MCP control. Copies it into the sandbox
scenes folder if it is elsewhere. Its columns appear as 'foreign_columns' you can key/retime.
A scene the MCP already manages is refused unless overwrite=true (its MCP layer data is reset).

Input parameters:

- `name`
- `overwrite` (boolean)
- `path` (string, required)

### `set_scene_settings` (~53 tokens)

Change scene length (frames), fps, background colour, or default drawing style.

Input parameters:

- `bg_color`
- `fps`
- `frames`
- `scene` (string, required)
- `style`

### `add_layer` (~140 tokens)

Add a column with its own drawing level. Later layers are drawn ON TOP.
mode: 'vector' (native OpenToonz vector .pli, editable in GUI, pressure lines) | 'raster' (PNG).
style: override scene style for this layer (e.g. 'clean' for BG, 'sketch' for effects).
parent: 'Table', a peg or another layer. boil: hand-drawn line boil on held drawings.

Input parameters:

- `boil` (boolean)
- `layer` (string, required)
- `mode` (string)
- `parent` (string)
- `scene` (string, required)
- `style`

### `add_peg` (~54 tokens)

Add a pegbar (invisible transform node). Parent layers to it to move groups (character rigs, BG sets).

Input parameters:

- `parent` (string)
- `peg` (string, required)
- `scene` (string, required)

### `set_parent` (~46 tokens)

Re-parent a layer or peg to 'Table', a peg, or another layer.

Input parameters:

- `parent` (string, required)
- `scene` (string, required)
- `target` (string, required)

### `set_layer` (~74 tokens)

Layer properties: visible, opacity (0-1, renders), boil, style (needs redraw), timing 'auto'|'manual'.

Input parameters:

- `boil`
- `layer` (string, required)
- `opacity`
- `scene` (string, required)
- `style`
- `timing`
- `visible`

### `delete_layer` (~35 tokens)

Delete a layer (column, level, drawings). Undo-able.

Input parameters:

- `layer` (string, required)
- `scene` (string, required)

### `draw` (~337 tokens)

Draw drawing #frame on a layer (held until the next drawing when timing is auto).

Shapes (canvas px, origin top-left), painted in order:
  circle{x,y,r} ellipse{x,y,rx,ry,rotation} rect{x,y,w,h,radius,rotation} (x,y=top-left)
  polygon{points,smooth} path{points,smooth=true,closed} text{x,y,text,size,anchor='mm'}
  svgpath{d:'M.. C.. A.. Z', transform?} - any SVG path data (detailed art: hair, hands, folds)
  brush{points:[[x,y,pressure 0-1],...], width:px max, color} - inked stroke with per-point pressure
Paint/ink: fill, stroke, stroke_width (px; default from style), opacity, interior=true (thinner
interior line), trace_line=true (iro-tore coloured line), shadow=true|{light:deg,depth:px,color}
(anime cel shadow; light 90=top, 135=top-left), or shadow={style:'hatch', spacing:px, angle:deg,
cross:true, gradient:0-1, jitter:0-1, width:px} for pen hatching of the shadow side (real ink strokes),
human=false (perfect geometry), wobble (px).
Colours: '#rrggbb', css names or [r,g,b,a].

Input parameters:

- `force` (boolean)
- `frame` (integer, required)
- `layer` (string, required)
- `scene` (string, required)
- `shapes` (array, required)

### `draw_many` (~61 tokens)

Batch draw: drawings=[{"frame": n, "shapes": [...]}, ...]. Use for frame-by-frame animation.

Input parameters:

- `drawings` (array, required)
- `force` (boolean)
- `layer` (string, required)
- `scene` (string, required)

### `inbetween` (~226 tokens)

Generate in-betweens (douga) between two key drawings (genga).

start/end_shapes default to the drawings already on start_frame/end_frame.
easing: slow_in_out (studio chart) | snappy | linear | in | out | bounce | elastic | back.
step: 1 ones, 2 twos, 3 threes (default: style timing, anime=3, feature=2).
arc: bow of the travel path (0.15 = natural arc). squash: 0-1 stretch round shapes along motion.
Studio rule: only auto-inbetween 'tight' moves (rotation<=30deg, scale change<=25%); add a breakdown key otherwise.

Input parameters:

- `arc` (number)
- `easing` (string)
- `end_frame` (integer, required)
- `end_shapes`
- `force` (boolean)
- `layer` (string, required)
- `scene` (string, required)
- `squash` (number)
- `start_frame` (integer, required)
- `start_shapes`
- `step`

### `set_exposure` (~109 tokens)

Xsheet timing for a layer (sets timing=manual). cells[i] = drawing at frame i+1 (0 = blank),
or run-length text '1x6 2x6 3x4 0x2' (drawing x frames). Cycle example on twos: '1x2 2x2 3x2 4x2 1x2 ...'.

Input parameters:

- `cells` (required)
- `layer` (string, required)
- `scene` (string, required)

### `set_keyframe` (~164 tokens)

Keyframe a layer, peg, or 'camera' (real OpenToonz keys, editable in GUI Function Editor).
x/y: px offset from rest (+y down). rotation: deg CCW. scale*: 1.0=100%. z: depth.
interp (segment starting at this key): ease | linear | constant | speed | exp.
Camera: scale<1 zooms IN; use exp interp for trucks (natural zoom).

Input parameters:

- `frame` (integer, required)
- `interp` (string)
- `rotation`
- `scale`
- `scale_x`
- `scale_y`
- `scene` (string, required)
- `target` (string, required)
- `x`
- `y`
- `z`

### `set_pivot` (~110 tokens)

Set the rotation/scale pivot of a layer or peg without moving it (OpenToonz 'center').
x,y: canvas px. x='auto': from the layer's drawing bounds; anchor 'bottom' (feet - use for squash
on the ground) | 'center' | 'top'. Do this BEFORE squash/stretch or rotation keys.

Input parameters:

- `anchor` (string)
- `scene` (string, required)
- `target` (string, required)
- `x`
- `y`

### `clear_keyframes` (~67 tokens)

Remove keys from a target (optionally one param: x,y,rotation,scale,scale_x,scale_y,z; optional frame range).

Input parameters:

- `end`
- `param`
- `scene` (string, required)
- `start`
- `target` (string, required)

### `animate_action` (~186 tokens)

Move a layer/peg/camera with animation principles baked in (Illusion of Life numbers):
anticipation (opposite move, 15% amplitude, 25% of duration, min 3f), main move with slow-in/out,
overshoot (10% past target) and damped settle (x0.45 swing) over settle_frames AFTER 'end'.
to/from_: {x,y,rotation,scale,scale_x,scale_y} (px/deg/factor). from_ defaults to current value at start.

Input parameters:

- `anticipation` (number)
- `easing` (string)
- `end` (integer, required)
- `from_`
- `overshoot` (number)
- `scene` (string, required)
- `settle_frames` (integer)
- `start` (integer, required)
- `target` (string, required)
- `to` (object, required)

### `camera_move` (~195 tokens)

Camera work (satsuei):
kind='pan': move view by dx,dy px from start..end (eased 8f). parallax={layer: ratio} makes layers
  move at ratio of camera speed (sky 0.05, far BG 0.3, mid 0.6, char 1.0, FG 1.8).
kind='truck': zoom to 'zoom' scale (0.75 = push in 25%) with exponential interpolation.
kind='shake': impact shake starting at 'start', strength px (8 default), decays x0.7/frame on ones.

Input parameters:

- `dx` (number)
- `dy` (number)
- `end`
- `kind` (string, required)
- `parallax`
- `scene` (string, required)
- `start` (integer, required)
- `strength` (number)
- `zoom`

### `import_image` (~197 tokens)

Bring a picture (sketch, scanned drawing, painting, photo, AI image) into a layer.

Raster layer (mode 'raster'): the image is placed as-is. Traced layer (add_layer mode='traced'):
OpenToonz's own vectorizer turns it into editable vector strokes and fills on compile.
trace: set the traced layer's method once: 'outline' (colour regions) | 'centerline' (ink lines).
box [x,y,w,h] px (default whole canvas); fit contain | cover | stretch | none.

Input parameters:

- `accuracy` (integer)
- `box`
- `despeckling` (integer)
- `fit` (string)
- `frame` (integer)
- `layer` (string, required)
- `max_colors` (integer)
- `path` (string, required)
- `scene` (string, required)
- `threshold` (integer)
- `trace`

### `import_svg` (~128 tokens)

Import an SVG file (Inkscape/Illustrator/free assets) as editable vector shapes on a drawing.
Every path becomes an 'svgpath' shape you can tween, recolour or humanize (human=true adds the
hand-drawn wobble/pressure of the layer style). box [x,y,w,h] fits the art (default whole canvas).

Input parameters:

- `box`
- `force` (boolean)
- `frame` (integer)
- `human` (boolean)
- `layer` (string, required)
- `path` (string, required)
- `scene` (string, required)

### `save_part` (~137 tokens)

Save a reusable part to the global model-sheet library (head, eye, hand, mouth chart, prop).
shapes use the part's own coordinates; anchor [x,y] is its attachment/pivot point.
variants: alternative drawings by name, e.g. {"closed": [...], "A": [...], "O": [...]}.
Use in any drawing as {"type":"part","name":..,"variant":..,"x","y","scale","rotation","flip"}.

Input parameters:

- `anchor`
- `name` (string, required)
- `notes` (string)
- `shapes` (array, required)
- `variants`

### `list_parts` (~18 tokens)

Parts in the model-sheet library with their variants.

Output parameters:

- `result` (array)

### `physics_bounce` (~221 tokens)

Physically exact bouncing (gravity parabolas, coefficient of restitution) on a layer/peg.
The drawing must rest on the ground line; y offsets go UP from there. height px.
fall_frames: frames for the first drop (default: real gravity for a 1.7 m character = 1080 px tall,
i.e. 14.1*sqrt(height/1080)). material: rubber_ball | table_tennis | basketball | tennis |
soft_rubber | bowling | balloon (sets restitution and squash). travel_x: px moved over the whole bounce,
slowing with each contact. squash: area-preserving contact squash (set_pivot at the feet first).

Input parameters:

- `bounces` (integer)
- `fall_frames`
- `height` (number, required)
- `material` (string)
- `scene` (string, required)
- `squash` (boolean)
- `start` (integer, required)
- `start_on_ground` (boolean)
- `target` (string, required)
- `travel_x` (number)

### `physics_jump` (~115 tokens)

Recipe jump on a layer/peg: anticipation crouch -> takeoff stretch -> exact parabola -> landing
squash -> recovery. style: realistic | feature | cartoon (crouch depth, stretch and squash amounts).
air_frames default: real gravity for the scene height (1.7 m character = frame height).

Input parameters:

- `air_frames`
- `height` (number, required)
- `scene` (string, required)
- `start` (integer, required)
- `style` (string)
- `target` (string, required)

### `follow_through` (~272 tokens)

Overlapping action / follow-through from a damped spring (second-order system).
The target reacts to the driver's motion (driver's `param`, exact OpenToonz values).
mode 'follow': target_param = spring(driver)  (a separate object trailing the driver).
mode 'offset': target_param = gain * (spring(driver) - driver)  (a part PARENTED to the driver:
  hair, ears, tail, cloth; use target_param='rotation' with gain in deg per px for a swing).
frequency Hz (hair 2-2.5, ears 3, belly 4-5, cape 1.2), damping 0.25-0.5 (overshoot 15-45%),
response < 0 anticipates. Keep frequency <= 4 Hz on ones, <= 2.5 Hz on twos (aliasing).

Input parameters:

- `damping` (number)
- `driver` (string, required)
- `end` (integer, required)
- `frequency` (number)
- `gain` (number)
- `mode` (string)
- `param` (string)
- `response` (number)
- `scene` (string, required)
- `start` (integer, required)
- `target` (string, required)
- `target_param`

### `camera_follow` (~106 tokens)

Follow a layer/peg with the camera using critically damped smoothing (game-camera SmoothDamp).
smooth_time in frames (7 = 0.3 s); axis x | y | xy; offset px added to the followed position.

Input parameters:

- `axis` (string)
- `end` (integer, required)
- `offset` (number)
- `scene` (string, required)
- `smooth_time` (number)
- `start` (integer, required)
- `target` (string, required)

### `blink` (~120 tokens)

Insert a blink into a layer's xsheet at `start` (switches the layer to manual timing).
pattern: standard (H C C H) | quick | anime_twos | physiological | sleepy | double.
Drawings: the eye open/half/closed drawing numbers on that layer.

Input parameters:

- `closed_drawing` (integer, required)
- `half_drawing`
- `layer` (string, required)
- `open_drawing` (integer, required)
- `pattern` (string)
- `scene` (string, required)
- `start` (integer, required)

### `lip_sync` (~172 tokens)

Animate a mouth from text (no audio): each mouth shape is a VARIANT of a library part
(anime3: closed/half/open; blair: AI E O U WQ MBP FV L etc rest). Draws one drawing per shape on
the layer and writes the xsheet from `start` (2-frame minimum holds). Shift `start` 2 frames
earlier than the audio (mouths lead sound).

Input parameters:

- `chart` (string)
- `frames_per_syllable` (integer)
- `layer` (string, required)
- `part` (string, required)
- `scale` (number)
- `scene` (string, required)
- `start` (integer, required)
- `text` (string, required)
- `x` (number, required)
- `y` (number, required)

### `anatomy_reference` (~254 tokens)

Body proportions for drawing a person, from anthropometric data (Drillis-Contini segment
lengths, de Leva masses, CDC/NHANES stature, growth-standard head ratios).
person: baby | toddler | boy | girl | child | teen | teen_boy | teen_girl | young_man | young_woman |
man | woman | old_man | old_woman (or give age years / label and sex). Returns heights from the floor,
segment lengths, front widths, side depths (px), heads tall, mass fractions, centre of mass, notes.
Scale: height_px, or px_per_m (340 = 1.75 m adult about 600 px; keep one px_per_m per scene).
region (list_regions): population averages from national health surveys (stature, leg length via
sitting-height ratio); bmi: a number, or 'average' for the region's surveyed mean (default: a
neutral build). Averages only: individuals vary far more than regions do.

Input parameters:

- `age`
- `bmi`
- `height_px`
- `person`
- `px_per_m` (number)
- `region`
- `sex`

### `list_regions` (~24 tokens)

Regions with surveyed body averages for anatomy_reference / build_character (region=...).

### `build_character` (~280 tokens)

Build a side-view cut-out character rig with real proportions for the age and sex.
Creates a root peg '<name>' at the hips and 16 vector layers '<name>_<part>' (torso, head, upper arm,
forearm, hand, thigh, shin, foot, toe; far side darker and behind), parented like a skeleton with
each pivot on its joint. Animate it with walk_cycle / run_cycle, or key the parts directly
(rotation on a part turns it about its joint). x: hip x px (default centre); ground_y: floor line px
(default 90% of the frame). hair: short | long | bob | ponytail | bun | none.
colors: {skin, hair, top, bottom, shoes, line}. region / bmi: as in anatomy_reference (population
averages; faces and heads are never varied by region). Every layer stays an editable vector level.

Input parameters:

- `age`
- `bmi`
- `colors`
- `facing` (string)
- `ground_y`
- `hair` (string)
- `name` (string, required)
- `person`
- `px_per_m` (number)
- `region`
- `scene` (string, required)
- `sex`
- `style`
- `x`

### `walk_cycle` (~368 tokens)

Walk a build_character rig with biomechanically correct timing for its age and sex.
Feet stay planted and roll heel -> flat -> ball -> toe; legs use two-bone IK; the hips ride an
inverted-pendulum arc (low at contact, high at passing); arms swing opposite the legs.
Defaults come from gait studies (e.g. adult man 108 steps/min at 1.4 m/s; toddler 154 at 0.86;
old age shorter steps). speed m/s, cadence steps/min override them. cycles (default 2) or end.
travel=false walks in place (pan the BG). on=2 holds every pose 2 frames (keys become constant).
bounce, arm_swing scale the motion (1 = natural; >1 = cartoon); lean adds forward trunk lean (deg).
mood (Williams beat chart and character walks): natural | brisk | stroll (16 frames a step) |
tired (20, head down, low clearance) | proud (chest out) | happy (double bounce) | sneak (crouched,
24 frames) | heavy (long contact, deep down) | cartoon (8 frames). speed/cadence still override.
Returns the self-check: cadence, step length, vertical oscillation, knee flexion, foot slip.

Input parameters:

- `arm_swing` (number)
- `bounce` (number)
- `cadence`
- `character` (string, required)
- `cycles`
- `end`
- `lean` (number)
- `mood` (string)
- `on` (integer)
- `phase` (number)
- `scene` (string, required)
- `speed`
- `start` (integer)
- `travel` (boolean)

### `run_cycle` (~172 tokens)

Run a build_character rig: spring-mass physics (exact gravity in the flight phase, a spring arc
in contact, lowest at mid-stance), planted feet, high knee recovery, bent arms. Defaults by age and
sex from jogging norms (adult man about 166 steps/min at 3.3 m/s). Same options as walk_cycle;
bounce=1 keeps gravity exact.

Input parameters:

- `arm_swing` (number)
- `bounce` (number)
- `cadence`
- `character` (string, required)
- `cycles`
- `end`
- `lean` (number)
- `on` (integer)
- `phase` (number)
- `scene` (string, required)
- `speed`
- `start` (integer)
- `travel` (boolean)

### `compile_vectors` (~56 tokens)

Convert pending vector drawings to native OpenToonz .pli levels with pen-pressure lines.
Runs automatically before preview/render/open. force=true also overwrites GUI-edited levels.

Input parameters:

- `force` (boolean)
- `scene` (string, required)

### `preview_frame` (~47 tokens)

Render one frame through OpenToonz and return the image (check your work visually).

Input parameters:

- `frame` (integer)
- `max_width` (integer)
- `scene` (string, required)

### `contact_sheet` (~48 tokens)

Render several frames into one labelled grid (default 6 spread over the scene) to review motion.

Input parameters:

- `frames`
- `scene` (string, required)
- `thumb_width` (integer)

### `render` (~81 tokens)

Render with OpenToonz (tcomposer), then double-check: frame count, blank frames, flashing.
format: mp4 | gif | png (sequence). shrink 2 = half size (faster drafts).

Input parameters:

- `end`
- `format` (string)
- `scene` (string, required)
- `shrink` (integer)
- `start`

### `open_in_opentoonz` (~55 tokens)

Open the scene in the OpenToonz GUI for hand editing (vector levels compiled first).
After editing: SAVE in OpenToonz, then the MCP picks up your changes automatically.

Input parameters:

- `scene` (string, required)

### `validate_scene` (~60 tokens)

Double-check a scene: structure, missing files, layer/column mapping, timing gaps, studio rule
warnings (holds, pan speed), and optionally a 1-frame test render.

Input parameters:

- `render_test` (boolean)
- `scene` (string, required)

### `learn_lesson` (~75 tokens)

Record an insight from reviewing your own output (e.g. 'squash 0.8 looks rubbery; 0.4 reads better
for a heavy ball'). Lessons are shown in every later scene_context so future work improves.

Input parameters:

- `lesson` (string, required)
- `scene`
- `tags`

### `feedback` (~60 tokens)

Store the USER's rating (1-5) and comment about a result. Ranked highest in lessons/preferences.
Ask the user for this after showing a render.

Input parameters:

- `comment` (string)
- `rating` (integer, required)
- `scene` (string, required)

### `tune_style` (~94 tokens)

Permanently adjust a style preset's defaults (learned from feedback). Keys: line, interior, wobble,
wavelength, taper_start, taper_end, min_ratio, pressure_var, loop_var, exposure, squash [lo,hi],
shadow, overshoot_ends. Applies to all future drawings using that style.

Input parameters:

- `changes` (object, required)
- `reason` (string, required)
- `style` (string, required)

### `knowledge` (~37 tokens)

Search accumulated lessons (errors seen, quality issues, insights, user preferences) with advice.

Input parameters:

- `limit` (integer)
- `query`

Output parameters:

- `result` (array)

### `list_scenes` (~15 tokens)

Scenes known to the MCP.

Output parameters:

- `result` (array)

### `list_looks` (~28 tokens)

Studio looks apply_look can build from real OpenToonz fx, with what each does.

### `apply_look` (~195 tokens)

Give the scene a studio look made of real OpenToonz fx nodes (open the FX Schematic to tweak them).
look: ghibli | klaus | spider_verse | comic | anime_satsuei | painterly | cartoon_saloon (list_looks).
Whole-frame fx go just before the output; per-layer fx (e.g. Klaus form shadow and rim light) go on
\`layers` (default: every layer except ones named like bg/background/sky). strength scales the
amounts (0.5 subtle, 1 default, 1.5 strong). light_angle: degrees, 90 = light from above,
135 = top-left. Re-applying replaces the previous look; fx you made by hand are kept.

Input parameters:

- `layers`
- `light_angle` (number)
- `look` (string, required)
- `scene` (string, required)
- `strength` (number)

### `remove_look` (~33 tokens)

Remove the fx apply_look added (fx you made in OpenToonz stay).

Input parameters:

- `scene` (string, required)

## Diagnostics

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

## Score history

- 2026-10-23: 75
- 2026-10-22: 74

## Common questions

### What is the OpenToonz MCP server?

OpenToonz MCP is listed in the public MCP registry as io.github.konkomaji/opentoonz-mcp. Animate in OpenToonz from an AI assistant: native vector levels, xsheet timing, rigs and physics. This page covers its PyPI package (opentoonz-mcp).

### Is the OpenToonz MCP server safe to use?

OpenToonz MCP scores 75 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 23 October 2026. Its build provenance is signed and verified. 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 OpenToonz MCP server expose?

OpenToonz MCP exposes 52 tools: opentoonz_info, scene_context, add_note, get_journal, style_guide, and 47 more. Their descriptions and schemas cost roughly 5,785 tokens of context every time the server is loaded.

### Is the OpenToonz MCP server still maintained?

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

OpenToonz MCP 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/opentoonz-mcp/
- Socket report: https://socket.dev/pypi/package/opentoonz-mcp
- Repository: https://github.com/konkomaji/opentoonz-mcp
- Website: https://konkomaji.com/
- Changelog RSS feed: https://verifymcp.io/servers/konkomaji-opentoonz-mcp/opentoonz-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/konkomaji-opentoonz-mcp/opentoonz-mcp.json
- HTML version of this page: https://verifymcp.io/servers/konkomaji-opentoonz-mcp/opentoonz-mcp