ART-PIPELINE-MCP
Provides tools for taking layered PSD artwork through a deterministic Spine production pipeline: inspecting and classifying PSD layers, rigging with Spine 4.2 meshes, bones, weights, IK, physics, turn rigs, and slot juice; creating animations and procedural FX; validating runtime behavior; checking mobile budgets; and exporting game-ready .spine, JSON, and atlas packages. Also supports importing After Effects FX results back into Spine as sequence attachments.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ART-PIPELINE-MCP Rig bomb.psd into a game-ready Spine package with preview"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ART-PIPELINE-MCP
One neutral production toolchain that takes a layered PSD to a game-ready Spine package, with After Effects used only where raster FX genuinely earn it. Any MCP client can drive it: Codex, the OpenAI Responses API, ChatGPT (where custom MCP is available) and Claude Code.
One server. Multiple brains. The model reasons; the MCP does deterministic production work.
Status: v0.2.0, roadmap steps 1-3 done. The full tested engine (Spine 4.2 meshes, heat weights, IK, physics, turn rigs, slot juice, ~28 FX recipes, AE bridge, budget QA; 49 tools, 1169 tests) now lives here as the art_pipeline package, ported from CLAUDE-SPINE with no algorithm changes. claude_spine and the claude-spine command remain as aliases. Orchestration (pipeline.*), manifests and HTTP transport are next, see docs/ROADMAP.md.
Quick start
uvx --from git+https://github.com/kumikilongyeyo/ART-PIPELINE-MCP art-pipelineCodex: docs/CODEX.md
Claude Code:
claude mcp add -s user art-pipeline -- uvx --from git+https://github.com/kumikilongyeyo/ART-PIPELINE-MCP art-pipeline
Engine reference: docs/RIGS.md, docs/FX_RECIPES.md.
Related MCP server: Spine MCP Server
Why not GPT-SPINE?
GPT is a client, not part of the architecture. The Spine/PSD/AE logic never depended on a model; only naming, install instructions and transport did. Making a per-vendor fork means maintaining two Spine backends. This repo is the single backend.
┌─ Codex
│
ART-PIPELINE-MCP ───┼─ OpenAI Responses API
│
├─ ChatGPT MCP (where available)
│
└─ Claude CodePipeline
PSD ─ inspect layers ─ classify artwork ─ crop/export
│
▼
SPINE
mesh · bones · weights · IK · physics · animation · procedural FX
│
┌──────────┴──────────┐
▼ ▼
native FX AE FX (glow/bloom, fire, lightning,
│ fluid, distortion, shockwave)
aerender
│
frame sequence ──► back into SPINE
│
runtime validation (spine-core)
mobile budget check
preview GIF
│
▼
.spine / JSON / atlasRule of thumb for AE: Spine's procedural FX are far cheaper at runtime, so use Spine for motion, scale, squash, trails, particles, coins, sparkles, UI and win feedback. Use AE only for glow/bloom, fire, lightning, fluids, distortion, complex shockwaves, caustics and optical flare. ae_fx_to_spine brings the result back as a sequence attachment.
Tool surface
Raw tools stay internal. By default the server exposes a small set of high-level tools so the agent does not burn context choosing between 50-100 low-level calls. Low-level tools are reachable through spine.edit for corrections.
Namespace | Default tools |
|
|
|
|
|
|
|
|
|
|
|
|
Target example:
Import
bomb.psd, identify the bomb, liquid splash and droplets. Rig the bomb, give the liquid secondary deformation, create anticipation, explosion and win_loop. Use AE for the flash and bloom only. Keep it under themobile_symbolbudget. Give me the Spine file and a preview GIF.
Asset manifest
The model edits a manifest; the tools consume predictable structured data, so bone and layer names are never hallucinated per run. See examples/bomb_candy.asset.json.
Project state
.artmcp/project.json records which PSD produced which Spine project, the AE source comp, animation list, atlas settings and validation status, so jobs resume instead of being rediscovered each session.
Transports
stdio (local): Codex, Claude Code.
Streamable HTTP (planned): OpenAI Responses API remote MCP, and private servers via Secure MCP Tunnel.
FRONTEND Slots Agent
This repo includes a Claude Code specialist rebuilt from the actual Slot Engines Source Pack:
Agent docs: docs/agents/frontend-slots-agent/
Source-engine selection map: SOURCE_ENGINE_MAP.md
Source-pack audit: AUDIT.md
Install or update (any project, macOS or Windows)
Installs the agent for your user, so it shows up in every project, not only this repo. Run the same command again to update.
macOS / Linux (Terminal):
curl -fsSL https://raw.githubusercontent.com/kumikilongyeyo/ART-PIPELINE-MCP/main/scripts/install-frontend-slots-agent.sh | bashWindows (PowerShell):
irm https://raw.githubusercontent.com/kumikilongyeyo/ART-PIPELINE-MCP/main/scripts/install-frontend-slots-agent.ps1 | iexFrom a clone: double-click scripts/install-frontend-slots-agent.command (macOS) or scripts\install-frontend-slots-agent.cmd (Windows). It pulls the latest commit, then installs. Add --uninstall / -Uninstall to remove it.
It writes ~/.claude/agents/frontend-slots-agent.md plus the playbooks in ~/.claude/agent-docs/frontend-slots-agent/ (with a VERSION file), and points the agent's playbook links there, so they resolve from any project. Open a new Claude Code session afterwards: agents are only read at startup.
The agent combines the Showcase engine's clean result-provider/QA boundary with the Jeepney 4x3+1 engine's stronger timing, skip/slam, wheel, Spine and VFX presentation patterns. It also standardizes reel-symbol payout inspection, reward eye-leading, bonus transitions, RTP/math version boundaries, deterministic replay and mobile recovery.
pages-site skill: edit a website from its link
skills/pages-site/ lets Claude Code change a Cloudflare Pages site from just its *.pages.dev link, on any
device: it pulls exactly what is live, edits, deploys to a preview, verifies every file, then deploys live.
The site's file list is kept privately in Workers KV, and a deploy is refused if another device deployed
since the pull, so two machines can't overwrite each other. The FRONTEND Slots installer above installs it too.
License
MIT. Spine engine derived from egorfedorov/spine-mcp via CLAUDE-SPINE; see LICENSE.
Available Tools
49 toolsadd_bonesB
Add bones in WORLD coordinates (y up). Each item: {"name", "parent" (default "root"), "x", "y", "rotation" (world degrees, default 0), "length" (default 0)}. Art never moves; only bones are added.
Inputs: bones (required), project (required).
add_chainA
Bones along a polyline of world points (n points → n-1 bones, each reaching the next point). Use for limbs, spines, tails, tentacles.
Inputs: name (required), points (required), project (required), parent.
add_eventC
Fire a Spine event (SFX cue, rollup start/stop, particle trigger) in an animation.
Inputs: name (required), time (required), project (required), animation (required), +3 more.
add_keysB
Key one timeline with named easing (Spine curves are written for you).
Bone timelines: rotate [t, deg], translate/scale/shear [t, x, y],
translatex/translatey/scalex/scaley [t, v]. Slot timelines: rgba/rgb
[t, "RRGGBBAA"], attachment [t, name-or-null]. Values are offsets from the
setup pose (Spine semantics). Append an easing name to a key to override
ease for the segment leaving it.
Easings: anticipate, back_in, back_in_out, back_out, cubic_in, cubic_in_out,
cubic_out, ease, expo_in, expo_in_out, expo_out, in, in_out, linear, out,
quad_in, quad_in_out, quad_out, sine_in, sine_in_out, sine_out, snap,
stepped
Inputs: project (required), animation (required), bone, ease, +4 more.
ae_fx_to_spineA
Render an After Effects comp and play it in Spine as a frame sequence, timing matched to the comp.
Source: aep + comp (rendered headless with aerender from the SAVED .aep, over the work area, never touching the project open in the AE window), or frames_dir + fps (frames already rendered: .tif premultiplied, or .png). mode: "alpha" (the comp's own transparency; normal blend) or "additive" (light on black: alpha from brightness; additive blend). blend overrides the slot blend. Timing: playback speed equals the comp's (delay = 1/comp fps). Place it with start= (seconds into the Spine animation) or, to land an AE moment on a Spine one, hit_ae= (seconds in the comp, e.g. the impact) + hit_at= (Spine time it should coincide with). fit_duration= stretches the sequence to span that many seconds (loops that must divide the symbol's loop). seq_mode: once | loop | pingpong; a loop runs to until= (default: the end of the animation it is merged into). max_frames/max_size shrink it (every Nth frame; longest side in px), scale = game units per comp pixel, fade = fade-out seconds. animation= merges into an existing animation, otherwise ae_ is created. Leading and trailing empty frames are trimmed. Frames land in images/ae/NN.png; an event ae fires at the start.
Inputs: name (required), project (required), x, y, +24 more.
ae_templateA
Build an After Effects FX comp from a template: returns a script to run in AE (nothing is rendered here).
name="" lists the templates with their parameters and defaults. Otherwise name is one of: glow_pulse,
shockwave, sparkle, relief_shimmer (light wave over a picture, traced by its relief or a depth map),
fire, fire_aura (flame ring shooting out of a hole: fists, scatters, power-ups), lightning, burst (parabolic sparks),
splash. params override the defaults (comp= names the comp;
save_as= saves the open AE project to that .aep right after, which aerender needs).
Then: run the returned run_with with the After Effects MCP's ae_run_script (it creates the comp in an
ae_fx_templates folder of the OPEN project and returns its name, size, fps, frames), save the project, and
pass the comp to ae_fx_to_spine (use mode="additive" when the result says so). After Effects caches
rendered frames by comp name: when tuning, give each attempt a new comp name.
Inputs: name, params, out_dir.
attach_rigA
Plug a sub-rig into a named bone of ANY rig; its clips MERGE by name into the host's clips (same name = same animation, timelines added; a host clip keeps its length, loops refit to divide it exactly, one-shots retime).
kind="" lists the kinds with their layer names, default bones and options. Kinds (default bone): ears (head): ear_l/ear_r 2-bone strands with physics; clips ear_perk (exact spring overshoot), ear_flatten, ear_swivel (toward options.sound, the far ear lags), idle twitches. tail (hips): strand with physics; options.tail_mood happy | alert | angry drives idle; clips tail_happy, tail_alert, tail_angry; reacts in walk / run / win if the host has them. wings (chest): wing_l/wing_r (+ wing__feather); options.wing_type feathered | bat | insect; idle = slow breathing fold, excited = flutter; win reaction. horns (head): horn*/antler*: rigid, tiny inertia lag on head turns (physics on shear only). digitigrade (hips): leg_l/leg_r zigzag layers -> thigh, shin, metatarsus with the reversed hock, IK feet (foot_l/r ride them); walk (planted feet, sfx_step with l/r in the string), run reaction. mermaid (hips): mermaid_tail (+ fluke) as a rig_serpent chain; legs hidden; swim, idle_float, idle. snake_hair (head): snake (8-12): each a serpent with its own randomised idle; snake_look (shared IK target). fur (any): options.slots or fur*/coat*/mane*/ruff*: outline bones with physics; fur_ruffle (wind gust). glow (any): options.slots or eye*/rune*/vein*: the FX shine pulse (eyes) or electric_frame (runes) via fx_recipes.apply, tiled into options.clips (default idle) with exact loops and fx* events. name prefixes the new bones (attach the same kind twice).
Inputs: bone, kind, name, options, +1 more.
clip_setA
The character contract: the SAME clip names for every character, so game code never changes.
idle (loop 4 s: one real breath), idle_fidget, walk (loop), run (loop), jump, land, hit, attack, win, lose, talk (loop). Loops close exactly, one-shots end exactly on the setup pose, the artist's setup never moves. Events: sfx_step on every footfall (string = the foot bone, float = the ground speed in px/s: move the character at that speed and the feet do not slide), sfx_jump, sfx_land, sfx_hit, sfx_attack + attack_hit (damage frame), sfx_win, sfx_lose, sfx_talk, sfx_idle_fidget. Physics: walk = inverted pendulum, run = spring-mass + gravity-parabola flight, land = exact spring squash 0.85 → overshoot 1.05 (volume kept), hit = 2-frame anticipation against the blow then a spring recoil lagging up the chain, attack = wind-up, strike, spring follow-through. Strands get a headwind ~ v^2 in walk/run.
Works on any rig that has the bones a clip needs (canonical names from rig_biped; bone_map renames them, e.g. {"hips": "hip", "ik_hand_r": "arm_r2_ik"}); clips whose bones are missing are skipped and listed with what is missing. intensity 0.5 subtle … 1 standard … 1.6 cartoon. durations {clip: seconds}. blow_from front|back.
Inputs: project (required), wind, clips, facing, +5 more.
doctorA
Check the toolchain: Python deps, Node (official spine-core runtime for validation and previews) and the Spine editor CLI (editable .spine export).
Inputs: no named parameters.
export_runtimeC
Export a .spine project to runtime data with the Spine CLI (json|binary or a path to an export-settings JSON).
Inputs: out_dir (required), spine_project (required), fmt.
face_clipA
(Re)build one face clip on a rigged face: idle | happy | sad | angry | surprised | talk. duration 0 = the clip's default (idle 4 s loop, expressions ~1.8-2 s; talk = the speech + 0.35 s). intensity scales amplitudes, seed drives idle's Poisson saccades/blinks, text/phonemes/wpm feed talk, name renames the animation (e.g. happy_big).
Inputs: clip (required), project (required), wpm, name, +6 more.
fx_generateB
Add an FX preset built from Spine primitives with procedural textures (tinted per slot, so the atlas stays tiny).
presets: explosion (flash + shockwave + sparks + smoke), shockwave, coin_burst (spinning flipbook coins on true parabolas), coin_shower, ripple (seamless water rings), glow_pulse, sparkle, shine_sweep (needs slot=; light band clipped to that part's outline). into: merge into an existing animation (e.g. "win") instead of a new one. Each preset fires an event fx_ so the engine can add heavy particles (pixi emitters) at the same moment.
Inputs: preset (required), project (required), x, y, +11 more.
fx_recipeA
Authored FX layers lifted from real reference clips: lotus set (rune_ring, burst_flare, rim_wisps, bloom_aura, floor_glow, fireflies, twinkles, plus magic_reveal = all seven timed like the clip, 13.2 s), light_beam (style gold | ribbon | blue), crosshair / hit_burst / lock_on (reticle locks on, fires, impact), cell_glow (resizable 9-slice glowing cells that pop), puff (cartoon smoke puff, or flash + ring for an AE smoke_puff), smoke_glow (rising haze with a base glow), meteor_trace (comet racing around a frame), projectile (shot on an arc + impact), ice and water (frost, icicles, ice_shatter, bubbles, water_splash; AE template caustics), explosion and shine, the reel moments reel_stop (spring thud, squash, dust, screen shake on your reel/screen bones through inserted carrier bones) and anticipation_reel (accelerating heartbeat glow, edge flames or sparks, dimmed neighbours), the slot families (spin: near_miss, spin_blur, turbo_spin, screen_shake; wins: payline, win_highlight, multiplier_stack, win_rollup; payouts: coin_fountain, cascade_pop; features: wild_land, expanding_wild, scatter_trigger, free_spins_transition; bonus: pick_reveal, hold_respin, jackpot_wheel, meter_fill; ambient: weather, god_rays, water_surface, heat_shimmer, fog_roll, lightning_storm; UI: button_press, idle_shimmer, focus_glow, padlock, popup; saber = a port of Video Copilot's Saber beams with 12 presets and an ae_hint for the saber AE template; pinata family = wild_glow, wild_transform, mult_cell_glow, cell_pop, confetti_burst, mult_streak, wild_merge, coins_to_bar, bar_sweep, pinata_hit, jar_burst, banner_backdrop from one picture kit (swap a texture pack in by name with art=, retune it with options gain / thick); recipes that move your reel / symbol / screen / button bones do it through inserted carrier bones, never your own keys), and the hybrids portal and electric_frame, whose plasma / lightning part is After Effects: they return a ring_hint to pass to ae_fx_to_spine (guide explains). Procedural textures, additive only (one draw call), one group bone per recipe so it recolours, resizes and retimes as one piece, and it merges into any animation with into=.
recipe="" lists every recipe with its options and defaults; recipe="guide" returns the guide (how to use, fork and mix them, how they were made, and the traps). x, y = the subject centre in the parent bone's space; scale 1 = a ~720-unit canvas with a ~420-wide subject; start = seconds into the animation; duration = life window (window recipes) or a time scale (one-shots); color = main tint; intensity = alpha gain; count = tufts / motes / stars / sparks; options = recipe-specific values (see the listing). magic_reveal takes options={skip: [recipe, ...], overrides: {recipe: {param: value}}}. Each recipe fires an fx_ event.
art = your own pictures instead of the generated ones, keeping all the motion: {role: "file.png" | "file.psd#Layer" | {path, blend, scale, slice, px, anchor}}; the roles of each recipe are in the listing (e.g. crosshair: reticle). For lock_on / magic_reveal key it by member: {"crosshair": {"reticle": ...}}.
tier = small | medium | big | mega | epic: one recipe covers every win size (scale, counts, one-shot time and the
recipe's own tier overrides; see the listing's tiers). Bundles: sequence = any list of recipes with offsets into one
animation (options={steps: [{recipe, start, dx, dy, ...any fx_recipe argument}]}); win_banner = Big/Mega/Epic banner
from one recipe (tier= picks the layers; options={banner: bone} slams your banner art in on an exact spring).
Inputs: x, y, art, into, +15 more.
gaitA
Key a gait on ANY rig that has foot IK targets and a body bone: planted stance, swing arc, toe roll, body bob and pitch coupled to the footfalls, and an sfx_step event (string = leg name) at every touch-down. Call with no project to list the gaits.
gait: walk (4-beat LH LF RH RF), trot (diagonals), pace (laterals), canter (3-beat), gallop (rotary, two
flights), bound (hind pair / fore pair) for 4 legs; tripod (L1 R2 L3 / R1 L2 R3) and wave for 6;
biped_walk / biped_run for 2 ("walk"/"run" resolve by leg count).
legs: the foot IK target bones, e.g. ["ik_front_L", "ik_front_R", "ik_hind_L", "ik_hind_R"]; side and end are
read from the name (_L/_R, front/hind/middle, LF, RH, L1..R3) or given as dicts
{"target", "side": "L|R", "end": "front|middle|hind", "name", "roll", "hip", "reach", "offset", "bias"}.
Hip, reach and the hock offset are found from the IK constraint that serves each target.
body: the bone that bobs and pitches (its children carry the hips/shoulders; the targets must NOT be under it).
speed: units/s (default: the gait's typical speed in leg lengths/s x the hip height). The cycle is in place;
the game scrolls the world at this speed. Frequency f = c sqrt(speed / leg_length), stride = speed / f,
so speed scales both by sqrt; if a stride would over-stretch a leg the frequency is raised (reported).
frequency / duty / clearance / bob / pitch / roll: overrides (0 or -1 = gait default; clearance and bob in units,
pitch and roll in degrees). exaggerate scales clearance, bob, pitch and roll. facing: 1 right, -1 left,
0 auto (front feet ahead of hind feet). Loops close exactly; keys go into animation name (default the
gait's name), at start, cycles strides long.
Inputs: bob, body, duty, gait, +14 more.
import_psdC
PSD → project: one slot per visible layer, placed exactly as on the canvas, PNGs cropped to content, Photoshop blend modes mapped. origin "center" for symbols, "bottom" for characters standing on y=0.
Inputs: psd (required), out_dir (required), name, scale, +3 more.
inspect_psdA
List a PSD's layers (names, groups, visibility, blend, bounds, [tags]) without writing anything. Run before import_psd.
Inputs: psd (required).
juice_applyB
Slot-symbol juice. Default clips = the symbol contract: idle, land, win, win_loop, anticipation, dim. Extras: scatter_trigger, wild_expand, flip, flip_depth, multiplier_fly, win_big, win_mega, win_epic.
Animates only two inserted bones (juice_ground at the base, juice_core at the centre) so the artist's own keys are never touched. One-shots end on the setup pose; loops are seamless; events fire for SFX (sfx_land, sfx_win…). intensity 0.5 subtle … 1.6 loud. fx=True layers matching FX. shine_slot adds a clipped shine sweep in win. options: back= (flip), rows (wild_expand), to=[x,y] (multiplier_fly), darkness (dim).
Inputs: project (required), fx, clips, merge, +4 more.
lipsyncA
Viseme + jaw keys from text or phonemes into an animation (works on any rig with a mouth slot whose attachments are named A E I O U M F L [rest], and/or a jaw bone).
text: plain English through a tiny grapheme-to-viseme table (digraphs th/sh/ch/ee/oo/ou..., a silent final e
dropped), timed by wpm (each word 60/wpm s, vowels 1.6x a consonant, , ; . ! ? pause). phonemes: ARPAbet
(HH AH0 L OW1), viseme letters or rest/sil, optionally [phoneme, seconds]; durations={viseme: s} sets defaults.
Visemes are stepped attachment keys lead s ahead of the sound; the jaw (default face_jaw) eases between
openness values (A 1, O .8, L .55, E .5, U .4, I .35, F .15, M 0) by scale. A missing viseme falls back to the
nearest shape. Ends on rest. Events: sfx_talk, talk_word (string = word), talk_end.
Inputs: project (required), wpm, lead, text, +8 more.
look_atA
Bake a lagged look chain into an animation: eyes -> head -> spine (or any bones: works for bodies).
gaze [[t, gx, gy], ...]: fixations in normalised gaze units (-1..1, +x = viewer's right, +y = up); saccades are instant. Or target = a bone whose translate keys in that animation are the gaze path (divided by target_range, default the length of the target's parent bone: face_look_base on a face rig). levels [{bone, channel: translate|rotate, range: [x, y] (px, or degrees per unit gaze), weight (share of the gaze it takes), lag (dead time s), hz + zeta (damped-spring response), limit (normalised radius for translate, degrees for rotate), role: "eyes"}]. Default on a face rig: face_look (eyes, instant), turn_ctrl (0.4 of the gaze, 100 ms later, slight overshoot), and spine= (0.15, two frames after the head, via an inserted carrier bone so the artist's keys stay). counter=True: the eyes take gaze minus the other levels, so they jump first and roll back as the head arrives (vestibulo-ocular reflex). loop=True solves the response periodically.
Inputs: project (required), animation (required), fps, gaze, +7 more.
make_biped_sampleA
Create a procedural biped (a chibi adventurer, side view) whose layers follow BIPED_LAYERS, exactly as import_psd would bring in a PSD with origin="bottom": torso, head, arm_l/r, hand_l/r, leg_l/r, foot_l/r (or upper_arm/lower_arm and thigh/shin with split_limbs=true), plus cape, ponytail, belt_tail, pouch and head features (eye_r, brow_r, mouth, ear_r, hat). Try rig_biped → clip_set → qa_character on it.
Inputs: out_dir (required), name, facing, split_limbs.
make_creature_sampleA
Procedural sample for rig_creature (slime | golem | ghost | tentacle | dragon | insect | plant | mimic): simple readable parts drawn with PIL, one image per layer, named exactly as import_psd names a PSD that follows the kind's convention. Not rigged: run rig_creature on it.
Inputs: kind (required), out_dir (required).
make_editableB
Import the project into an editable .spine file with the licensed Spine editor CLI. Reports any repairs the importer made.
Inputs: project (required), out_spine.
make_face_sampleB
Create the procedural sample face: a mascot head drawn as separate layers named exactly as import_psd names a PSD that follows the face convention (face/head, face/eye_L/{white,iris,pupil,highlight,lid_upper,lid_lower}, face/brow_L, face/nose, face/mouth/{A,E,I,O,U,M,F,L,smile,frown}, face/jaw, face/cheek_L, face/ear_L, hair/back, hair/bangs, hair/strand_L ...), all on root. Run rig_face on it.
Inputs: out_dir (required).
make_flier_sampleB
Procedural front-view bird for rig_flier: tail, wing_l/r with wing_feather1..N, body, head, beak, eyes.
Inputs: out_dir (required), feathers.
make_host_sampleA
Procedural minimal biped host for attach_rig (bones root > hips > chest > head, legs, arms; clips idle
2.4 s loop, walk 1.0 s loop, win 1.2 s one-shot) with the layers for the add-ons in parts
(ears, tail, wings, horns, snake_hair, mermaid, fur, glow, digitigrade; default ears, tail, wings).
Inputs: out_dir (required), parts.
make_quadruped_sampleB
A procedural dog-like side view (faces right, stands on y = 0) with one layer per part, named by the QUADRUPED_LAYERS convention, to try rig_quadruped and gait on. rig=True also runs rig_quadruped (all clips). with_mid=False leaves out the metapodial layers (the rig then splits the lower legs).
Inputs: out_dir (required), rig, name, leg_type, +1 more.
make_sampleC
Create a procedural sample project to try the tools on. kind: "symbol" (slot symbol: plate, gem, letter, highlight) or "character" (mascot with arms, cape, hair locks, face features, ears).
Inputs: kind (required), out_dir (required).
make_serpent_sampleB
Procedural sample for rig_serpent. kind "fish": a koi (body, head, eye, fin_dorsal, fin_pectoral, tail_fin), head to the right. kind "tentacle": one tapered tentacle with suckers, base at the bottom.
Inputs: out_dir (required), kind.
pack_atlasB
Pack every image the skeleton references (sequence frames included) into a Spine 4.x .atlas + pages. Copies the skeleton JSON next to it, so out_dir is a ready runtime folder.
Inputs: project (required), pma, name, scale, +3 more.
previewC
Render animations through the official spine-core runtime (IK, physics, clipping all solved) to GIFs + contact sheets, plus a setup-pose PNG.
Inputs: project (required), fps, size, wire, +2 more.
project_infoC
Bones (with world head positions), slots (bone, attachment type, blend), constraints and animations of a project.
Inputs: project (required).
qa_budgetB
Performance budget for mobile web. Profiles: mobile_symbol, mobile_banner, mobile_character, desktop. Counts bones, slots, vertices, weighted vertices, clipping, physics, deform keys, influences, atlas pages, and estimates draw calls (every blend-mode or page change along the draw order breaks the batch). Returns what is over budget and how to fix it.
Inputs: project (required), atlas, profile.
qa_characterC
Character QA played in spine-core: joint cracks (where two parts' art separates at a bending joint, or a
single mesh folds), foot slide (a planted foot drifting from the clip's ground speed) and the mobile bone budget
for the rig type (biped, quadruped, flier, serpent, face; auto detects) plus mobile_character. Returns fix:
what to change, joint by joint and clip by clip.
Inputs: project (required), fps, rig_type, animations, +1 more.
reparent_slotB
Move a slot to another bone without moving its art.
Inputs: bone (required), slot (required), project (required).
rig_bipedA
Rig a biped from its PSD layers in one call (import_psd origin="bottom" first).
Layers are recognised by name (BIPED_LAYERS, case-insensitive, sides _l/_r, "Arm L", "arm.l", "left_arm"): required torso (body), head, arm_l/r (or upper_arm + lower_arm / forearm), leg_l/r (or thigh + shin / calf); optional pelvis, neck, hand_l/r, foot_l/r (boot/shoe), eye*, mouth, and strand layers (hair, cape, scarf, belt_tail, chain, feather, tail, pouch...). Missing required layers → a clear error listing them.
Builds root → ground → hips → spine1-3 → chest → neck → head, shoulders/arms/hands, thighs/shins, floor-pinned
foot IK (ik_foot_l/r under ground: the body bobs and the feet stay put), arm IK (ik_hand_l/r ride the chest),
bones placed from each layer's own centre line, the knee/elbow bend taken from the art (straight art: knees
forward, elbows back). One weighted mesh across each joint (shoulders, hips, elbows, knees) so bends cannot
crack. breathing adds the 4 s breathe loop; look_at adds the look_target hook (eyes first, head
look_lag_frames behind at 30 fps, spine twists spine_twist of the turn); secondary_motion runs secondary.
Facing: auto (the way the feet point) | right | left.
Inputs: project (required), detail, facing, meshes, +5 more.
rig_creatureA
Rig a non-humanoid creature from its layers and build its clip set, composing the existing rigs (gait / rig_quadruped, rig_serpent chains, rig_flier wings, clip merge by name, fx recipes). kind="" lists every kind with its layer convention (case-insensitive, last group/ part of a PSD name counts), clips and options.
Kinds (clips): slime (idle, hop, hit, win): body = one mesh on a core + n_outline (6-8) outline bones with soft physics; squash keeps the volume (scaleY 0.7 -> scaleX 1.195; options.law="area" -> 1/scaleY); hop = anticipation squash, ballistic parabola (stretch ~ speed), splat recovering on an exact spring; outline wobble in Rayleigh drop modes (mode 3 at 1.936 x mode 2). Events sfx_hop, sfx_land, sfx_hit, sfx_win. golem (idle, stomp, hit): rigid parts with gaps, each lagging its parent through a critically / over-damped filter (zeta >= 1: never overshoots; fists lag two levels); glowing seams (additive glow slot per crack*); stomp = slow heavy rise, gravity drop, dust, event screen_shake (float = px, int = ms) + sfx_stomp. ghost (idle, swoop, fade_out, fade_in): strand-chain body with physics, no legs; bob and sway from two incommensurate periods closed exactly over the loop; alpha breathing; trailing wisp* strands. fade_out ends invisible (bones on setup), fade_in starts there. tentacle (idle, reach, slam): tentacle layers each a rig_serpent tentacle chain off the core with reach IK on the tip; idle phases per tentacle; reach = spring strike + IK grab (sfx_reach, sfx_grab); sucker template clones swap to stretched art while the tentacle stretches; slam whips (screen_shake). dragon (idle, walk, fly, breath, roar): rig_quadruped body + serpent neck and tail + bat wings (rig_flier stroke); breath = generated fire flipbook from the mouth (fx_fire, sfx_breath) with an ae_hint for the AE fire template; roar with screen_shake. insect (idle, walk, fly): leg_{L|R}{1|2|3}_{upper|lower}, tripod (or wave) gait with sfx_step per foot, antenna strands, wing-blur flipbook in fly. plant (idle, grow, attack): trunk chain, branch* strands, root* IK feet, leaf* physics fans; grow is diffusion-limited (front s = sqrt(2 k t)), leaves pop on a spring; attack whips a branch (screen_shake). mimic (idle, open, bite, land, win): spring hinge lid (exact overshoot), gravity close with restitution bounces, tongue strand, teeth; open fires the FX shine; land / win through the juice_apply contract.
Loops close exactly, one-shots end on the setup pose; the artist's setup never moves. The result reports the bones / slots / constraints and qa.budget(mobile_character).
Inputs: kind, seed, clips, options, +2 more.
rig_faceA
Rig a whole face from named layers in one call, then build its clips.
Recognises parts by layer name (case-insensitive, L/R sides, any group prefix): face/head (REQUIRED; also face, skin, base), face/eye_L/{white, iris, pupil, highlight, lid_upper, lid_lower}, face/brow_L, face/nose, face/mouth/{A,E,I,O,U,M,F,L} (+ rest, smile, frown) or one plain mouth layer, face/jaw (chin art), face/cheek_L, face/ear_L, hair/back, hair/bangs (fringe), hair/strand* / lock*. Missing parts are skipped and reported. project="" returns the naming convention (FACE_LAYERS) without changing anything.
Builds: the 2.5D turn (rig_turn) as the base layer; eyes whose iris follows face_look and is CLAMPED inside the socket ellipse (one-bone IK with compress inside a (1, ry/rx)-scaled space) with pupil dilation and lid meshes that blink to the white's own 70/30 meeting line; 3-bone brows on a mesh; a viseme mouth slot riding a jaw that opens by stretching the lower face (scaleX = scaleY^-1/2); cheek bones in the face mesh, stretched by the jaw and lifted by face_smile (which also pushes the lower lids: smiling squints); hair strands (chain + mesh + physics) and a separate bangs swing bone.
clips (default all): idle (seamless: breath, Poisson micro-saccades with the head 100 ms behind, Poisson blinks 80 ms down / 160 ms up), happy, sad, angry, surprised (spring envelopes with exact overshoot, brows a frame ahead, surprised anticipates with a 2-frame squash), talk (lipsync of talk_text). Events: sfx_blink, sfx_, sfx_talk, talk_word (string = word), talk_end. parent = the character's head bone (default juice_core or root); spine = a body bone that joins look_at two frames after the head. Scales are stored in bone lengths (face_rig = face height, turn_base = turn range, face_look_base = full gaze, lid bones = blink travel).
Inputs: seed, clips, pitch, spine, +8 more.
rig_flierB
Bird / flier (front view, wings to the sides). Layers by name: body (required), head (stabilised), beak/eye*/head_* (ride the head), wing_l / wing_r (3-bone chains, shoulder = the end nearest the body), wing__feather (primary feathers fanning off the hand, strands with physics), tail (strand, physics).
flap: a warped sine per joint, downstroke = 58% of the beat, each joint lag degrees of phase behind the last
(shoulder leads, tip trails), the hand flexes and the primaries fan shut on the upstroke; the body bobs once per
beat (lift on the downstroke) while the HEAD stays still (transform constraint to a non-bobbing anchor).
amp = [shoulder, elbow, hand] degrees (default 40, 15, 20). Clips: flap (loop, sfx_flap per downstroke),
glide (loop), perch (folded, body bobs, head still with a glance), takeoff (crouch, launch, power strokes; ends
on setup; sfx_takeoff, sfx_flap), land (flare, braking strokes, touchdown spring; ends EXACTLY on perch's first
frame so land -> perch is seamless; sfx_land).
Inputs: project (required), amp, bob, lag, +7 more.
rig_ikC
1- or 2-bone IK (e.g. ["upper_arm", "forearm"]). Creates a target bone at
the chain tip unless target names one. Bend direction defaults to the
setup pose's own bend. The target goes under juice_core when juice bones
exist (so slams carry it), else under root.
Inputs: bones (required), project (required), mix, target, +4 more.
rig_meshB
Turn a slot's region into a clean contour mesh (or re-mesh a mesh) with bone-heat weights.
Outline traced from alpha and simplified without clipping art; interior vertices denser at joints; conforming Delaunay (valid for Spine's importer). Weights diffuse from bone segments over the mesh, so they blend smoothly across joints and never leak across gaps in the art.
bones bones to weight to; omit with auto_bones=True to pick the slot bone + descendants that touch the part; [] with auto_bones=False gives an unweighted mesh. detail vertex density (0.5 light … 1 balanced … 2 dense) smooth >1 widens weight blending across joints, <1 tightens
Inputs: slot (required), project (required), pad, bones, +7 more.
rig_physicsC
Spine 4.2 physics constraints (runtime secondary motion, no baked keys).
presets: hair, cloth, tail, ribbon, jiggle, antenna, tassel. Down a chain
each bone is taper looser. overrides: any physics field (inertia,
strength, damping, mass, wind, gravity, limit, rotate, x, y, scaleX, shearX).
Inputs: bones (required), project (required), taper, preset, +1 more.
rig_quadrupedA
Rig a four-legged animal from its layers and build its clips in one call.
Layers (case-insensitive, R = near side, L = far side, the animal faces right or left; see QUADRUPED_LAYERS): REQUIRED body, head, {front|hind}{upper|lower|foot}{L|R}; optional {front|hind}mid{L|R} (metapodial), neck, tail, ear_L/ear_R, eye_L/eye_R, mane*, tuft*, wattle*, snout/nose/jaw/... (ride the head); anything else rides the nearest body bone. Missing optional parts are skipped; missing required ones are listed in the error.
leg_type: plantigrade (2-bone IK, flat foot), digitigrade (3 segments: 2-bone IK to a hock/carpus target + 1-bone IK on the metapodial; made by splitting the lower leg if there is no mid layer), unguligrade (long cannon + pastern bone for the hoof). Spine q_body -> spine_back/hips + spine_front/shoulders, neck1/neck2, head, eye bones, physics strands (tail loose and wild, ears, mane, tufts, wattles).
clips (default all): idle, alert, walk, trot, gallop, bound, pounce, sleep, shake (+ pace, canter). Loops are exact, one-shots end on the setup pose. Events: sfx_step (string = foot), sfx_idle (ear_flick / tail_swish / blink), sfx_alert, sfx_pounce, sfx_sleep, sfx_shake. speeds: {clip: units/s} for the gait clips. seed drives the idle's ear flick / tail swish / blink timer. exaggerate scales every amplitude.
Inputs: project (required), seed, clips, speeds, +3 more.
rig_serpentA
Fish, eel, snake, dragon body or tentacle: ONE long chain along the body layer with a travelling wave.
Layers by name (case-insensitive): body (required, one long layer), head + eye*/jaw/mouth (ride the first bone), fin* (2-bone strands with physics on the nearest body bone), tail_fin / fluke (strand on the last bone).
Physics: y(s,t) = A(s) sin(2 pi (s/lambda - f t)) head -> tail, amplitude growing toward the tail
(head_amp = the head's share). speed (body lengths/s) sets the beat like a fish: f = speed / (0.7 lambda);
the tail amplitude follows Strouhal St = 0.3 (x exaggerate) unless amp (fraction of length) is given; the head
recoils sideways and thrust surges the body at 2f. Clips: swim (exact loop, cycles beats, event sfx_swim per
beat), idle_float (slow hover wave + heave), turn (fish C-start: curl, tail kick, spring decay; sfx_turn).
mode="tentacle": the root is the base (root_end auto = the bottom), wave 1.3 lengths, plus 2-bone reach IK on
the tip and a reach clip (wind-up, constant-curvature strike on an exact spring, grab; sfx_reach).
reach = [x, y] in the tentacle's frame (x along it from the base). Clips merge by name into existing ones.
Inputs: project (required), amp, mode, name, +13 more.
rig_strandC
Hair lock / cape / ribbon / tail in one call: a bone chain along the part's own centre line, a heat-weighted mesh and physics. root_end: auto(top)|top|bottom|left|right. physics: preset name or "none".
Inputs: slot (required), project (required), detail, parent, +3 more.
rig_transformC
Transform constraint: bones copy target's transform by the mixes.
local+relative adds the target's local offset (drivers, parallax).
Inputs: bones (required), target (required), project (required), local, +8 more.
rig_turnA
2.5D head turn driven by ONE control bone (turn_ctrl).
face_slot becomes a mesh whose middle travels with the control while its
outline stays pinned (a surface turning, not a sticker sliding).
features {slot: depth}: nose 1.25, mouth 1.0, brows 0.95, eyes 0.9,
fringe 0.8; parts behind the head negative: ears -0.35, back hair -0.5.
Adds a turn_test animation. Animate turn_ctrl's translate to turn.
Inputs: project (required), features (required), face_slot (required), head_bone (required), +3 more.
secondaryA
Secondary motion in one call: find every strand-like layer and give it a chain along its own centre line, a weighted mesh and Spine physics. By name (hair/lock/ponytail/braid → hair; cape/cloak/skirt → cloth; scarf/ribbon/sash → silk; belt_tail/strap → leather; chain/necklace → chain; feather/plume → feather; tail; pouch/bag/charm/pendant → a one-bone pendulum) and, with by_shape, any other elongated layer (cloth). The chain starts at the end that overlaps the body and hangs from the body bone nearest it. presets {slot: hair|cloth|silk|leather|chain|feather|tail|ear|pouch} overrides; n_bones 0 = the preset's.
Inputs: project (required), slots, detail, exclude, +3 more.
squash_stretchB
Volume-preserving squash & stretch of any bone chain on an exact spring, keyed into clip from start.
The first extreme of the along-chain scale is exactly squash (< 1 squashes first, > 1 stretches first), the
next exactly overshoot on the other side of 1, then it settles exactly to rest. volume 3d: across =
along^-1/2 (a cylinder keeps its volume); area: across = 1/along. Keys go on a carrier bone ss_<chain[0]> inserted
at the chain base and aligned with it (the artist's bones and keys are never touched); several calls multiply.
Inputs: clip (required), chain (required), project (required), hz, +7 more.
validateC
Structural validation (references, weights, triangulations, UV range, curves, events) plus — when Node is available — loading the skeleton in the official spine-core runtime and applying every animation frame by frame (non-finite vertices, missing regions).
Inputs: project (required), runtime_check.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 49 tools
Several tool families overlap: rig_mesh and secondary both build weighted meshes, rig_strand and secondary add physics strands, make_sample and specialized make_*_sample creators overlap, and fx_generate and fx_recipe both add FX. Detailed descriptions help, but with 49 tools an agent can easily misselect among the rigging and sample-generation clusters.
All names use snake_case and are generally readable, but the set mixes verb_noun (add_bones, rig_biped, make_sample) with bare nouns (doctor, validate, preview, gait, secondary) and prefix families (fx_, ae_, qa_). The convention is not uniform, though it remains consistent enough to follow.
49 tools far exceeds the 3-15 sweet spot; although the domain is broad, the server is heavy and many tools are variants of sample/rig generators. An agent faces a very large decision space.
Covers import, sample generation, many rig types, animation, FX, AE integration, QA, preview, export, and atlas packing—a very wide lifecycle. Minor gap: no explicit delete/remove or general editing tools for existing bones/slots/constraints/animations, though make_editable offers an external workaround.
Related MCP Connectors
Split character art into named layers and export PSDs for Live2D and Spine.
Create App Store screenshots, icons, ASO copy, localization, and revisions via hosted MCP.
Render Spine 3.8 skeleton animations to PNG frames or GIF. Pay per call with points.
Build editable 3D scenes, direct characters and cameras, and export AI video references with MCP.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server that converts layered PSD characters into Spine 4.2 rigs with deterministic, parametric 2D/2.5D animations (idle, walk, run, jump, attack, hit) ready for the Spine editor and Unity.45MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI clients to directly control Spine 3.8.75 animation workflows through 55 MCP tools, including reading projects, editing keyframes, manipulating skeletons, constraints, meshes, atlases, and rendering previews.27 npm28MIT
- FlicenseAqualityBmaintenanceEnables converting layered PSD or PhotoshopToSpine exports into validated Spine 2D rigs, animations, atlases, previews, runtime JSON, and optionally editable .spine projects. It provides MCP tools and an OpenAI/Codex workflow for rigging, animation generation, validation, preview auditing, and batch processing.14-
- AlicenseAqualityCmaintenanceEnables an AI assistant to create, edit, validate and animate Esoteric Software Spine 2D skeletons without the editor running, covering bones, slots, attachments, skins, events, constraints, keyframes and reference-safe renames or deletions. When the Spine editor is installed, it also drives the official CLI to import skeleton JSON into a project and export runtime JSON/binary with atlases.261MIT