mcp-for-maya
mcp-for-maya is an MCP server that connects AI agents to Autodesk Maya for scene inspection, spatial reasoning, auditing, asset import/export, and controlled code execution.
Scene inspection & spatial awareness: snapshot the whole scene, inspect objects/zones, and measure distances, clearances, and bounding-box overlaps.
Verification & audits: assert expected scene state, validate spatial constraints, run 11-check scene reviews, perform aesthetic analysis, and generate layout plans with optional auto-fixes.
Recovery: create, list, and roll back scene checkpoints.
Camera planning: create industry-standard shot cameras and orbiting turntable animations.
Visual feedback: capture GUI viewport snapshots and render single-frame playblast previews.
Assets: search and import Poly Haven models with automatic texture wiring and safety guards.
Export: export full scenes or selected objects to FBX, OBJ, or USD.
Node/API inspection: describe node types, attributes, and connections, and enumerate scene nodes with pagination.
Session management: list/add Maya sessions and diagnose or install connection setup.
Code execution & modules: run arbitrary Python/MEL in Maya and inject reusable in-memory Python modules.
Enables AI agents to directly drive Autodesk Maya for 3D modeling, scene planning, and engineering-grade delivery. Provides tools for spatial scene awareness, inspection and measurement, aesthetic analysis, camera planning, checkpoint/rollback, engineering audits, arbitrary Python execution inside Maya, viewport snapshots and render previews, session management, asset import, and FBX/OBJ/USD export.
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., "@mcp-for-maya inspect my current Maya scene and measure the tabletop thickness"
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.
English | 简体中文
mcp-for-maya
MCP server giving AI agents spatial awareness of Autodesk Maya scenes
What this is
mcp-for-maya is a Model Context Protocol (MCP) server that lets AI agents (such as Codex and Claude) directly control Autodesk Maya for 3D modeling, scene planning, and production-ready work.
Core capability: AI no longer writes code blindly. It inspects scene objects, materials, and spatial relationships at any time, auditing changes against real engineering rules.
This server runs Python code directly inside Maya by design, not by accident. For details, seedocs/threat-model.md.
For live captures and examples, see docs/assets/showcase.md.
1. Install
# Install from PyPI (recommended)
pip install mcp-for-maya
# Or run instantly with uvx without installing
uvx mcp-for-maya
# Alternative: install directly from git with uv
uv tool install git+https://github.com/Xxx91n/mcp-for-maya.git
# Or install from cloned source
git clone https://github.com/Xxx91n/mcp-for-maya.git
cd mcp-for-maya
pip install -e .2. Connect Maya
Option A: Automatic setup (recommended)
Once the MCP server is running, the agent automatically calls maya_setup_guide to guide you through connecting:
Make sure Maya is open
Give the agent any instruction (like "check my Maya scene")
If not connected, the agent runs diagnostics and can install
userSetup.py(merges safely with backup before writing)Restart Maya, and the command port opens automatically
Option B: Manual setup
Run this in Maya's Script Editor:
import maya.cmds as cmds
cmds.commandPort(name=":7001", sourceType="python")Tip: Open Script Editor via Maya menu → Windows → General Editors → Script Editor. Make sure the tab language is set to Python (not MEL).
Option C: Persistent auto-connect
Save the following code as userSetup.py in your Maya scripts folder:
Platform | Path |
Windows |
|
Linux |
|
macOS |
|
import maya.cmds as cmds
cmds.evalDeferred('cmds.commandPort(name=":7001", sourceType="python")', lowestPriority=True)Multiple Maya instances
Each commandPort binds to a specific host:port. A second instance cannot use the same port, so each Maya instance must use its own port. Typical layout:
Maya instance | commandPort | Notes |
Instance A |
| Main workspace |
Instance B |
| Second instance |
Instance A |
| MEL port (auto-detected and skipped to avoid spamming errors) |
Run cmds.commandPort(name=":<port>", sourceType="python") in each instance's Script Editor (or each one's userSetup.py). Auto-scan is the primary method — the server regularly scans local Maya listening ports and sets up connections. If an instance is missed, call add_session(host, port) manually. If port scanning touches other local TCP services, set MAYA_MCP_INCLUDE_PORTS=7001,7002 (comma-separated, ranges like 7005-7010 supported) to limit the scan, or use MAYA_MCP_EXCLUDE_PORTS=<port> to ignore specific ports.
Note: A commandPort does not persist across sessions — it closes when Maya quits. To keep it persistent, add it to userSetup.py (Option C).
Troubleshooting
Issue | Solution |
| Run |
Port already in use | Close the other Maya instance or pick another port |
userSetup.py does not run | Check that the file is in the right scripts folder, then restart Maya |
Blocked by firewall | Make sure localhost:7001 can be accessed locally |
Second Maya instance not found | Each instance needs its own port (same port causes bind conflicts); if scanning still misses it, use |
Script Editor spams syntax errors | An older symptom of scanning MEL ports. Current versions ignore non-Python ports automatically; if it still happens, exclude the port with |
3. Configure your MCP client
Codex ~/.codex/config.toml:
[mcp_servers.maya]
command = "uvx"
args = ["mcp-for-maya"]
tool_timeout_sec = 120For git source installs: args = ["--from", "git+https://github.com/Xxx91n/mcp-for-maya.git", "mcp-for-maya"]. For local source builds, set command = "python", args = ["-m", "maya_mcp_server"], and point PYTHONPATH to <repo>/src in env.
4. Start using it
Chat naturally in your agent:
"Check out what's in my Maya scene, then put together a display shelf by the entrance"
The AI automatically calls scene_snapshot() → inspects the scene → builds the model → audits the result with scene_review().
Every scene edit follows the ICEV workflow (also provided as an agent skill card in skills/icev-workflow):
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ INSPECT │ ──→ │ COMPUTE │ ──→ │ EXECUTE │ ──→ │ VERIFY │
│ snapshot │ │ plan │ │ apply │ │ audit │
└──────────┘ └──────────┘ └──────────┘ └──────────┘INSPECT: Call
scene_snapshot()to capture full spatial scene dataCOMPUTE: Calculate positions, sizes, and spacing from the spatial data
EXECUTE: Run Maya Python code via
execute_code()VERIFY: Check the outcome with
scene_assert()+scene_review(); GUI sessions can use visual tools to verify visually
Capability | Tools | Notes |
🧊 Spatial awareness |
| Single call gets the full scene spatial model; precise distance, overlap, and gap measurements |
🎨 Aesthetic analysis |
| 5 dimensions: color balance (60-30-10), spatial composition (golden ratio / rule of thirds), proportion & scale (ergonomics), lighting quality (three-point setup, fill ratio, color temperature, decay), visual flow |
🎬 Camera planning |
| 8 industry-standard camera types + orbit animation |
🛡️ Disaster recovery |
| In-memory scene snapshots; rollback rebinds the scene back to the original file |
🧠 Scene planning |
| Scene health checks, zone balance, layout tips, conflict prevention, natural-language planning |
📋 Engineering audit |
| 11 deterministic checks (0-100 score) + custom constraint checks + scene assertions |
⚡ Code execution |
| Run arbitrary Python in Maya / inject reusable modules |
👁️ Visual loop |
| WYSIWYG viewport capture + single-frame playblast preview (GUI sessions only) |
🔌 Session management |
| Multi-session discovery/attachment + setup diagnostics and installation guidance |
📦 Asset library |
| Poly Haven CC0 models — downloads over HTTPS on the host (domain allowlist, MD5 check, size limits, local cache), Maya imports FBX with auto-wired textures, face-count guards, and duplicate prevention via |
📤 Scene export |
| Export whole scenes or selected objects to FBX/OBJ/USD; format auto-detected from file extension (no guesswork), auto-creates folders, explicit overwrite opt-in, restores selection afterward |
🔎 Scene-graph inspection |
| Node self-description (exact types, attribute details, connection wiring with size caps) + bounded enumeration including materials and tool nodes, with clean pagination |
25 MCP tools in total.
Related MCP server: Maya MCP Server
Tools in detail
Spatial awareness
# Full scene snapshot (one call returns spatial data for all objects)
scene_snapshot(detail="compact", format="cos")
# Inspect a specific object (including neighboring objects)
scene_inspect(target="wall_entrance", include_neighbors=True)
# Precise measurement (4 modes)
scene_measure(obj_a="wall_north", obj_b="counter_A", mode="clearance")
# Verify scene state
scene_assert(expectations='{"wall": {"exists": true, "position": [0,0,500]}}')Engineering audit
# 11 deterministic checks (returns 0-100 score)
scene_review()
# Spatial constraint validation
scene_validate(rules='[{"type": "min_clearance", "value": 180}]')Camera planning
# Create camera (8 industry-standard types)
camera_create(target="product_display", shot_type="medium", azimuth=30, elevation=15)
# Types: extreme_wide / wide / medium / close / extreme_close / bird_eye / low_angle / over_shoulder
# Orbit animation camera
camera_orbit(center=[0, 100, 0], radius=500, frames=120)Disaster recovery
# Save checkpoint (in-memory snapshot via exportAll; no undo history)
scene_checkpoint(name="before_renovation")
# List all checkpoints
scene_checkpoint_list()
# Rollback (saves a safety snapshot first, then rebinds the scene name back to the original file; run scene_snapshot afterward to refresh scene state)
# Scope: Snapshots are self-contained; file references are flattened without modifying reference sources; assumes one scene file per session
scene_rollback(filename="cp_before_renovation.ma")Assets (Poly Haven, host-side download)
asset_search(query="camera", asset_type="models", limit=20) # Search Poly Haven index
# Each result includes dimensions ([x, y, z] in metres, Poly Haven order) and polycount (int).
# Either is null when Poly Haven publishes no valid value. Search makes no file downloads.
asset_import(asset_id="Camera_01", resolution="1k")
# Downloads via HTTPS to local cache (MD5 verified + SHA-256 audit),
# then Maya imports the local FBX grouped under GRP_asset_<asset_id>
# (duplicate calls skip re-importing; force=True forces a re-import).
# Textures wire up automatically by file suffix
# (diff/rough/metal/nor_gl/ao/disp...), using sRGB/Raw color spaces and bump2d normals.
# Single-part assets with simple texture names (Diffuse/Rough/Metal...)
# are also recognized and connected to the asset's material.
# Safety guards: default 100k polygon cap (bypass with allow_high_polycount), dimension sanity check.Scene export
scene_export(path="D:/out/scene.fbx") # Full scene export; format inferred from .fbx extension
scene_export(path="/tmp/kit", format="obj") # Missing extension gets appended -> kit.obj
scene_export(
path="D:/out/kit.usd", objects=["GEO_box"]
) # Export selected; restores selection afterward
# format in {fbx,obj,usd}: format and extension conflicts throw an error immediately, never guess.
# Existing files are protected unless overwrite=True. prompt=False is forced
# (avoids dialog popups that could freeze the connection); does not touch the scene dirty flag.
# Alembic is not supported (AbcExport is outside the cmds.file interface).Visual loop (GUI sessions only)
# Viewport WYSIWYG screenshot (includes HUD and selection highlights — see what the artist sees)
scene_viewport_snapshot(max_size=800, format="jpeg")
# Single-frame playblast preview (clean preview without HUD; supports camera selection, dimensions rounded up to multiples of 4)
scene_render_preview(camera="CAM_hero", width=640, height=360)
# Both tools return [image, JSON metadata]; headless sessions return a gui_session_required error
# Use format="png" for wireframe or line-art review; always rely on returned metadata for actual dimensionsCoS notation
Default output uses Chain-of-Symbol notation to compress scene data. The original research paper reports roughly 65% token savings compared to JSON on demo scenes (arXiv:2305.10276, -65.8%).
SCENE[164obj, 5zones] UNIT=cm UP=y
shell (23obj) @(-11.8,178.8,145.7)
GRP_floor[mesh]@(0,0,0) 1121.5x20x1530.5
pasted__arch_wall[mesh]@(0,0,0) 100x300x10
entrance (6obj) @(157.3,162.6,-111.6)
GRP_workshopFront[group]@(1162,-17,103) 227.4x200.9x193.3Agent skills
The repository includes two Experimental skill cards (under the skills/ folder):
Skill | Purpose |
| ICEV workflow discipline: every scene edit must follow Inspect→Compute→Execute→Verify |
| Audit guide: scoring details for the 11 checks and how to turn findings into actions |
scene_review() provides 11 universal checks (scores 0-100, normalized by rule weight):
Check | Points | What it checks |
spatial | 10 | Object, camera, and light counts |
overlaps | 10 | Bounding box collisions (excluding parent-child) |
conflicts | 10 | Object penetration checks |
zones | 5 | Zone naming coverage |
naming | 5 | Production naming conventions |
components | 10 | GRP_ grouping and hierarchy nesting depth <= 4 |
orphans | 5 | Empty groups and default object names |
aesthetics | 15 | 5 aesthetic dimensions (color, composition, scale, lighting, flow) |
lighting | 10 | Three-point lighting, fill ratio, and decay |
organization | 10 | Overall hierarchy health |
constraints | 5 | Custom rule violations |
Security & privacy
Zero telemetry: No tracking, no phone-home. This project contains zero tracking or unsolicited outgoing network code, as you can verify in source. The only outgoing network calls are from the two asset tools: they access
api.polyhaven.com/dl.polyhaven.org|.comover HTTPS only when invoked (with domain allowlist, MD5 check, and file size limits inpolyhaven.py).Local single-user: The command port binds to localhost only. Connected MCP clients are treated as trusted callers.
Safety net: A unified pipeline (
pipeline.py+security.py) checks parameters, enforces token-bucket rate limits (~100 calls/60s for reads, ~20 calls/60s for writes per session), scans patterns (warn-only by default), and maintains an independent JSONL audit log across all 25 tools. It catches accidental mistakes rather than malicious clients. See docs/threat-model.md for the complete threat model.Transactional safety:
scene_checkpointandscene_rollbackoffer in-memory snapshots and explicit rollback (snapshots do not keep undo history; file references are flattened).Strict policy mode (optional): Set
MAYA_MCP_DISABLE_EXECUTE=1,MAYA_MCP_DISABLE_WRITE_MODULE=1, orMAYA_MCP_DISABLE_ARBITRARY=1(disables all three) to remove code execution tools fromtools/listand reject calls with[policy_disabled]. Read-only tools remain active. These are guardrails against misuse, not impenetrable security boundaries against a malicious agent—agents holdingexecute_codeare already inside the trust boundary. They simply reduce the blast radius during demos, testing, or in CI sandboxes. See docs/threat-model.md and error codes in docs/guide/error-codes.md.safe_modeAST gate (optional): WhenMAYA_MCP_SAFE_MODE=1is set (off by default), code payload tools remain listed, but theircodeparameters must pass an AST allowlist that denies everything else by default: imports are limited to standard packages (maya,math,json,re,collections,itertools,functools,dataclasses,typing), blocked builtin functions reject upon reference rather than just call (eval,exec,open,__import__, getattr, setattr, etc.), accessing__builtins__or dunder attributes is rejected, and unparseable input is rejected immediately. Blocked calls fail with[safe_mode_rejected], reporting the violated rule ID and logging to the audit trail. Successful calls return amode: "safe"field, and the tool description adds aBoundary:notice. DISABLE flags take priority by removing tools first—safe_mode only restricts what stays. Like DISABLE flags, this serves as a safety net against accidents, not an impenetrable barrier. See docs/threat-model.md and error codes in docs/guide/error-codes.md.Vulnerability reporting: See SECURITY.md.
Requirements
Environment | Requirement |
Host (runs the MCP server) | Python >= 3.10 ( |
Injected helper (runs inside Maya) | Maya >= 2023 (bundled Python >= 3.9, relies on |
Verified against | Maya 2024 GUI |
Development
uv sync --frozen # Set up locked dev environment from uv.lock (or: pip install -e . --group dev, requires pip>=25.1)
python -m pytest tests/ -q # Run tests
ruff check src tests # Lint
mypy src # Type check
python -m maya_mcp_server -vv # Run with DEBUG logging (-v=INFO, -vv=DEBUG)For contribution workflow, see CONTRIBUTING.md; for changelog, see CHANGELOG.md.
Credits
Forked from chadrik/maya-mcp-server, retaining its MIT license.
Available Tools
25 toolsadd_sessionAdd SessionA
Manually add a Maya session at a specific host and port.
Boundary: Disambiguated from list_sessions (report the sessions the SessionManager already discovered) and maya_setup_guide (diagnose and repair a connection) — add_session registers a host:port you already know.
Use this when auto-discovery doesn't find your Maya session, or to connect to a Maya instance on a specific port.
Inputs: host, port. Returns: Information about a Maya session.
asset_importAsset ImportAIdempotent
Import a Poly Haven CC0 model into Maya (find ids via asset_search).
Boundary: Disambiguated from asset_search (host-side id and metadata lookup that touches no Maya session) — asset_import is the mutating half and needs a live session to import into.
Pipeline: host downloads FBX + textures from the Poly Haven whitelist (https-only, size caps, per-file md5 verify) into the platformdirs cache -> Maya imports the local FBX (explicit meters unit handling) -> texture maps auto-wire by PH naming convention (diff/albedo -> color sRGB; rough/metal -> Raw single-channel; nor_gl -> bump2d normal) -> polycount gate -> group as GRP_asset_ -> bbox/metadata report.
Idempotent by default: a second call with the same asset_id reports the existing group instead of duplicating (force=True re-imports).
Inputs: asset_id (required), force, resolution, session_key, +2 more. Returns: result
asset_searchAsset SearchARead-onlyIdempotent
Search the Poly Haven CC0 asset index (host-side, no Maya needed).
Boundary: Disambiguated from asset_import (downloads the asset into a live Maya scene and mutates it) — asset_search only resolves ids and metadata, so it needs no session and changes nothing.
Queries https://api.polyhaven.com/assets and returns matching asset metadata. Read-only and idempotent - pure lookup.
Inputs: limit, query, asset_type. Returns: result
camera_createCamera CreateA
Create a camera positioned for a specific shot type.
Boundary: Disambiguated from camera_orbit (animates a turntable around a point over many frames) — camera_create frames one static shot and adds no animation.
Supports industry-standard shot types: extreme_wide, wide, medium, close, extreme_close, over_shoulder, bird_eye, low_angle.
Inputs: target (required), name, azimuth, elevation, +2 more. Returns: result
camera_orbitCamera OrbitA
Create an orbiting camera with turntable animation around a point.
Side effects: creates a new camera and animation curves in the scene and marks the scene dirty. Not idempotent — each call adds another camera. Requires an active Maya session.
Boundary: Disambiguated from camera_create (static shot-type framing; use camera_orbit only when an animated orbit is needed).
Inputs: center (required), name, frames, radius, +1 more. Returns: result
execute_codeExecute CodeADestructive
Execute arbitrary Python or MEL code in an active Maya session.
Runs arbitrary code with full session privileges of the connected Maya process. Execution is irreversible and cannot be undone (modifications do not register an automatic undo chunk). The return value shape is governed by the result_type envelope parameter. Requires an established Maya session (discoverable via list_sessions).
Inputs: code (required), result_type, session_key.
list_sessionsList SessionsARead-onlyIdempotent
List all active Maya sessions.
Boundary: Disambiguated from add_session (register a host:port by hand) and maya_setup_guide (diagnose an empty result) — list_sessions only reports what is already connected.
Returns a list of session information including:
session_key: Session key used to interact with tools and resources
host: Session host address
port: Session port number
pid: Maya process ID
user: Logged-in user
maya_version: Maya version string
scene_name: Current scene filename
scene_path: Full path to current scene
Note: To detect new or removed sessions, clients should call this tool periodically (e.g., every 10-30 seconds) and compare results. The SessionManager automatically scans for new Maya sessions in the background.
If this returns an empty list, call maya_setup_guide() for connection help.
Inputs: no named parameters. Returns: result
maya_setup_guideMaya Setup GuideADestructive
Maya connection setup guide and diagnostics.
Boundary: Disambiguated from list_sessions (read the current session set) and add_session (attach a host:port you already know) — maya_setup_guide diagnoses and repairs the connection itself.
Use this tool when list_sessions returns empty or when setting up Maya MCP for the first time. Provides platform-aware diagnostics, auto-installation of userSetup.py, and step-by-step fallback instructions.
Inputs: port, action, confirm, dry_run, +2 more. Returns: object
scene_aestheticsScene AestheticsARead-onlyIdempotent
Professional-grade aesthetic analysis with 5 design dimensions.
Analyzes scene aesthetics across 5 professional design dimensions:
Color Theory: 60-30-10 rule, temperature balance, harmony type, saturation variety, contrast
Spatial Composition: golden ratio proportions, rule-of-thirds alignment, visual weight balance
Proportion & Scale: human ergonomic reference, size hierarchy (hero/secondary/tertiary)
Lighting Quality: layer composition (key/fill/rim/accent), color temperature consistency
Visual Flow: sight line clarity, circulation paths, visual rhythm patterns
Returns an overall score (0-100) with grade (S/A/B/C/D/F) and improvement suggestions.
Boundary: Disambiguated from scene_review (scene_aesthetics evaluates visual design theory and artistic harmony in depth, while scene_review is a broad multi-system scene health audit).
Inputs: format, session_key. Returns: result
scene_assertScene AssertARead-onlyIdempotent
Verify scene state matches expected values.
Use this after modifications to confirm the scene is in the desired state. Enforces the VERIFY step of the ICEV workflow.
Boundary: Disambiguated from scene_validate (checks relational spatial constraints across zones rather than exact expected values for named objects).
Inputs: expectations (required), format, session_key. Returns: result
scene_checkpointScene CheckpointA
Save a real scene snapshot (exportAll of in-memory state).
Boundary: Disambiguated from scene_checkpoint_list (enumerate the checkpoints already written) and scene_rollback (open one and rebind the scene to it) — scene_checkpoint is the write half.
Writes a self-contained .ma into a checkpoints/ directory next to the scene file. On untitled (never-saved) scenes an explicit name is required and produces an ad-hoc snapshot under the Maya workspace — returned with original_file_status="no_original_file" and scene_rebound_to=null. Same-name checkpoints are rejected unless overwrite=True (the old file is preserved via rename).
Honest bounds: the snapshot contains no undo history — after scene_rollback, call scene_snapshot to rebuild context. References are flattened (self-contained, no write-back). Assumes one scene file per session.
Inputs: name, overwrite, session_key. Returns: result
scene_checkpoint_listScene Checkpoint ListARead-onlyIdempotent
List all saved checkpoints for the current scene state.
Boundary: Disambiguated from scene_checkpoint (write a new checkpoint) and scene_rollback (open one and rebind the scene to it) — scene_checkpoint_list only reads what is already on disk.
Saved scenes list <scene_dir>/checkpoints; untitled scenes list the workspace ad-hoc snapshots (adhoc flag per entry).
Inputs: session_key. Returns: result
scene_describeScene DescribeARead-onlyIdempotent
API-level self-description of ONE node (not spatial).
Boundary: scene_inspect answers WHERE an object is (position, bbox, neighbors); scene_nodes discovers candidate node names; scene_describe answers WHAT the node is at the API level - exact node type, per-attribute metadata, and connection wiring - so you can compose accurate execute_code/setAttr/connectAttr calls against real names.
Inputs: node (required), attrs, limit, session_key, +2 more. Returns: result
scene_exportScene ExportA
Export the Maya scene (or named objects) to a local file.
Writes through cmds.file with prompt=False forced (a modal dialog would hang the command channel). Formats: fbx, obj, usd (Alembic is not supported - its AbcExport API is not a cmds.file surface). The selection set is restored after every objects= export and the scene's modified flag is untouched.
destructive_hint is False but note: overwrite=True permanently replaces the target file - that path is not recoverable.
Inputs: path (required), format, objects, overwrite, +1 more. Returns: result
scene_inspectScene InspectARead-onlyIdempotent
Deep inspection of a specific object or zone.
Returns detailed properties including transform, BBox, material, mesh stats, and optionally nearby objects with distances.
Boundary: Disambiguated from scene_snapshot (broad whole-scene spatial overview) and scene_describe (API-level attribute metadata, types, and connection wiring).
Inputs: target (required), format, session_key, include_neighbors. Returns: result
scene_measureScene MeasureARead-onlyIdempotent
Measure the spatial relationship between two objects.
Call this in the COMPUTE step of the ICEV workflow, to turn a spatial question into a number before you execute a change: size a clearance before moving something, prove two objects interpenetrate before you separate them, or get the axis detail behind an overlap that scene_validate reported.
Read-only and idempotent: it queries world-space bounding boxes and never modifies the scene, so no undo checkpoint is created. Requires an active Maya session.
Every mode measures world-space AABBs, not the mesh surface and not the object origin. The modes differ in what the number means: center distance between the AABB midpoints. surface distance between the closest facing AABB corners — an axis-aligned approximation, so it over-reports clearance for rotated or concave geometry. clearance SIGNED, and 0 is NOT a "merely touching" signal. Per axis the gap is +separated / 0=touching / -penetrating: > 0 euclidean distance across the STRICTLY SEPARATED axes only. Penetrating axes contribute 0, so they are invisible in this number. = 0 no axis is strictly separated and at least one axis is exactly touching. The other axes may be deeply penetrating, so 0 does NOT mean the boxes just touch. < 0 all three axes penetrate; the value is the SHALLOWEST penetration depth, the minimum translation needed to pull them apart. bbox_overlap is true if and only if all three axes strictly penetrate. A single penetrating axis already makes it read false, so it can never be read as "no penetration". Read details.clearances_xyz for the signed per-axis truth before concluding anything from distance alone. bbox overlap test. On overlap, distance is 0 and overlap_dims holds the per-axis penetration extents; otherwise distance is euclidean and gaps_xyz holds the per-axis gaps.
Distances are in the scene's current linear unit (cm, m or mm), not always centimetres.
Boundary: Disambiguated from scene_inspect (per-object property deep-dive), scene_snapshot (whole-scene spatial overview) and scene_assert (checks the scene against expected values rather than measuring one pair).
Inputs: obj_a (required), obj_b (required), mode, format, +1 more. Returns: result
scene_nodesScene NodesARead-onlyIdempotent
Bounded enumeration of scene nodes - including non-DAG nodes.
Boundary: scene_snapshot is the low-resolution spatial overview you call once per workflow; scene_nodes is the name-discovery complement for the API layer - it lists nodes a spatial view never shows (materials, shadingEngines, tool nodes) and pages honestly: has_more/next_cursor tell you when the list was cut (for attribute schema and connection inspection, call scene_describe).
Inputs: type, limit, cursor, pattern, +4 more. Returns: result
scene_planScene PlanA
Holistic scene planning with organization validation and layout optimization.
Performs comprehensive scene health check and generates actionable plans:
Organization validation: detects orphan meshes, empty groups, default names
Zone analysis: coverage and spatial balance across functional zones
Layout suggestions: spacing, overlap, and clustering detection
Conflict prevention: near-miss collision prediction
Action plan: prioritized step-by-step execution guide
Based on blockout-first methodology: validate organization and proportions before committing to detailed modeling. Supports natural language objectives.
Boundary: Disambiguated from scene_review (scene_plan focuses on forward-looking layout planning and actionable auto_fix reorganization, whereas scene_review provides an overall diagnostic audit score).
Inputs: format, auto_fix, objective, session_key. Returns: result
scene_render_previewScene Render PreviewARead-onlyIdempotent
Single-frame playblast preview from a camera (clean, no HUD).
Boundary: Disambiguated from scene_viewport_snapshot (capture the panel as the artist sees it, HUD and selection highlights included) — scene_render_preview renders a chosen camera with the HUD suppressed.
GUI sessions only - headless sessions get a structured gui_session_required error.
Side-effect disclosures (read_only_hint is honest):
Switching the panel camera via the modelPanel camera flag is instantaneous, visible, and NOT undoable in Maya.
Net-zero side effect: the panel camera is restored on every path - success or failure - so terminal state equals entry.
The current time may visibly jump during capture; it is restored afterwards (playblast timeline quirk).
viewer=False: no playblast window pops up.
On failure the restore is still attempted; a failed restore is logged, never raised over the error result.
Only a killed Maya process can skip the restore.
Inputs: width, camera, format, height, +3 more.
scene_reviewScene ReviewARead-onlyIdempotent
Comprehensive scene audit - reviews all aspects after operations.
Runs spatial integrity, overlap detection, zone coverage, aesthetics, constraint validation, orphan detection, naming, componentization, conflicts, lighting quality, and scene organization. Returns a score (0-100) and detailed issue list.
Rules registered in the Maya session with
_mcp_scene.register_validator(...) (call it through execute_code) are
reported in a separate "custom" section - validators per rule,
score/max_score in weight points, issues for what did not pass.
The built-in score is unchanged and the section is absent when nothing
is registered.
Boundary: Disambiguated from scene_validate (narrow rule-based spatial constraint checking) and scene_aesthetics (in-depth 5-dimension aesthetic theory scoring).
Use this after any major scene modification to verify quality.
Inputs: checks, format, session_key. Returns: result
scene_rollbackScene RollbackA
Open a checkpoint and rebind the scene to its original path (S2).
Boundary: Disambiguated from scene_checkpoint (write a checkpoint from the current state) and scene_checkpoint_list (enumerate the ones already written) — scene_rollback is the restore half.
Before opening, the current in-memory state is exported to an auto_before_rollback safety snapshot; if that fails, the rollback aborts — pass discard_current_state=True to escape (the result reports safety_snapshot="skipped_by_user"). Untitled scenes and ad-hoc snapshots have no original path, so the scene stays on the checkpoint path (S1) and scene_rebound_to is null.
The snapshot carries no undo history — call scene_snapshot afterwards to rebuild context.
Inputs: filename (required), session_key, discard_current_state. Returns: result
scene_snapshotScene SnapshotARead-onlyIdempotent
Get a complete spatial overview of the current Maya scene.
Returns a structured description of ALL objects with positions, sizes, and types. Call this once at the start of each workflow to establish spatial awareness.
Boundary: Disambiguated from scene_inspect (deep-dive inspection of specific objects or zones) and scene_nodes (granular DAG/DG node name discovery with pagination).
Inputs: detail, format, session_key. Returns: result
scene_validateScene ValidateARead-onlyIdempotent
Validate scene against spatial constraints.
Checks the scene for constraint violations like minimum clearance, object limits, overlaps, and height requirements. This is a read-only check without auto_fix mutations (it cannot modify or repair objects; for automated fixes, see scene_plan with auto_fix=True). Because it is non-destructive, no undo rollback checkpoint is created. Requires an active Maya session.
Boundary: Disambiguated from scene_review (full scene quality audit across 11 checks) and scene_assert (verifies specific numeric values or object existence).
Inputs: rules (required), format, session_key. Returns: result
scene_viewport_snapshotScene Viewport SnapshotARead-onlyIdempotent
Capture the active viewport as an image (WYSIWYG).
Boundary: Disambiguated from scene_render_preview (playblast a frame from a chosen camera with the HUD suppressed) — scene_viewport_snapshot captures the panel exactly as the artist sees it, HUD included.
GUI sessions only - headless (mayapy/batch/native-channel) sessions get a structured gui_session_required error.
The capture is what the artist sees: viewport HUD, selection highlights and ornaments included. That is a feature - the agent verifies exactly what the user is looking at. A cmds.refresh(force=True) runs first so the frame is current.
Inputs: format, quality, max_size, session_key.
write_moduleWrite ModuleADestructive
Create a virtual in-memory Python module in an active Maya session.
Injects reusable Python functions into the target Maya session's sys.modules. Modules are virtual and in-memory: they do not persist across Maya restarts, and existing modules are protected unless overwrite=True is explicitly set. Requires an active Maya session.
Boundary: Use write_module to define reusable libraries and helper functions; use execute_code for one-shot imperative execution or expression evaluation.
Inputs: code (required), name (required), overwrite, session_key. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 25 tools
Most tools have clearly distinct purposes, and the descriptions go to unusual lengths to document boundaries (e.g., scene_snapshot vs scene_inspect vs scene_describe, and scene_review vs scene_plan vs scene_aesthetics). However, the large cluster of scene_* analysis tools means more than one or two could still be confused without careful reading.
Names are consistently snake_case and grouped with predictable prefixes such as scene_, camera_, and asset_. A few tools use different conventions (maya_setup_guide as a noun phrase, list_sessions/add_session vs scene_*), but overall the pattern is readable and stable.
At 25 tools, the surface is at the heavy end for a single MCP server. The tools span several domains (scene analysis, checkpoints, cameras, assets, sessions, code execution), but the set feels broad enough that some consolidation could improve usability.
The server covers scene inspection, validation, planning, checkpoints, export, cameras, asset import, code execution, and session management. Direct object manipulation (create/transform/delete) is missing, but execute_code provides a workaround for those operations.
Maintenance
Related MCP Connectors
Parametric 3D CAD for AI agents: build print-ready parts, check them, export STL, 3MF or STEP.
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Build and run visual creative-production workflows from your AI agent.
Blender-as-a-service for agents: search 3D assets, run Blender Python, or brief the studio agent.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to programmatically control Autodesk Maya via natural language using over 30 tools for 3D modeling, lighting, and animation. It connects through Maya's command port to facilitate procedural scene generation and complex production-ready workflows.1-
- AlicenseNot gradedqualityDmaintenanceEnables AI-assisted 3D modeling and scene control in Autodesk Maya through natural language commands, supporting object creation, transformation, material application, and more.36 npm8MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to control Autodesk Maya through natural language for scene creation, modeling, material assignment, and object manipulation.1MIT
- AlicenseBqualityCmaintenanceEnables AI agents to drive Autodesk Maya through semantic tools covering scene, object, material, animation, and rendering operations, paired with execute_python/execute_mel escape hatches and read-only resources. Also supports multi-instance routing, viewport capture for visual iteration, and asynchronous render job polling.221MIT