Molayo Unity MCP

In-house Unity MCP built for token-cheap profiling and project checking. All C# — no Python, no uvx.

Tools

Tool	What it covers
exec	Arbitrary C# in the editor — the full Unity API when no shaped tool fits
project	How the project is wired: assembly graph, build scenes, reverse dependencies ("who actually uses this script"), and the inspector reference graph of a scene or prefab
api	Reflection lookup: search types, list members, and list this project's custom inspectors, property drawers, MonoBehaviours, ScriptableObjects, editor windows — then get/set/invoke one of those members, private ones included, on a static, an open editor window, an asset or a scene component
menu	Run any menu command by path, and search [MenuItem] paths
gameobject	Create/inspect/modify/delete objects, components and serialized properties (undoable)
asset	AssetDatabase: find, inspect, edit properties, create, move, duplicate, trash, reimport — plus import settings (they live on the importer, not the imported object) and material shader properties (not plain serialized fields)
settings	Render pipeline (URP path — Forward/Forward+/Deferred — MSAA, HDR, render scale, shadows, SRP batcher, renderer features), quality, player, physics, time; plus generic list/set over every file in ProjectSettings/ — audio, presets, version control, memory and whatever a package puts there resolve by name, so the section list follows the project rather than a hardcoded enum. Per-build-target player settings (scripting backend, stripping, defines, bundle id) are reachable as named properties, since they are not plain serialized fields. export/baseline/diff/apply work on whole snapshots: what a project's settings are, what changed since a known starting point (that list is a setup guide), and putting one back — dry_run first
prefab	Prefabs as prefabs: structure, nested prefabs, instances in the scene, overrides, apply/revert, variants, prefab-stage editing
shader	Shader and Shader Graph at the asset level: which materials use a shader, Blackboard properties parsed from the graph JSON, create_material, compile errors
vfx	ParticleSystem and VFX Graph as one job — including simulate(time, seed), which is what makes a capture of a stochastic effect comparable across iterations
camera	Cameras and Cinemachine: list/set/frame, activate that cuts instead of blending, shot (deterministic setup → render → diff vs the last shot of that name), and visibility — why an object is or is not drawn by a camera, without rendering anything
lighting	Bake settings, ambient/fog/environment, lights, probes, and a real lightmap diagnostic (size on disk, renderers with no bake or no lightmap UVs)
volume	Post-processing volumes, URP and HDRP alike (override types resolve by name, custom VolumeComponents included). get is a diagnosis — which volumes reach a camera, in priority order, and the reasons a look does not arrive: post-processing off, HDR off on the pipeline asset, a volume on an unsampled layer. set turns on the overrideState a value needs, adds the override if the profile lacks it, refuses the whole request if any parameter is wrong, and verifies the write became a real sub-asset
animation	AnimatorController outline, clips and curves, parameters, live state, simple clip authoring
timeline	Timeline as a first-class subject: the track tree with bindings and markers, create asset/tracks/clips (custom track types included — kind takes any TrackAsset subclass, bindings resolve from the track's own output type), place and trim clips with ClipCaps honesty, and evaluate {time} to pose the scene at a moment for screenshot/compare
record	The Game view to MP4 or a PNG sequence, in one call that returns the file path, size, and the luminance of a frame sampled mid-take — a black recording says so instead of looking like a healthy file. Frame-exact (Constant + CapFrameRate), director plays a timeline from 0 as recording starts
input	Synthetic keyboard/mouse/gamepad into the running game, so the agent can play it rather than only inspect it. sequence runs a timed script in one call, which is what makes it compose: between play enter and record it films the game being played, and as each arm of a compare it guarantees the arms differ by the change rather than by the playing
ui	Why an element is invisible or unclickable, RectTransform/Canvas facts, UI hierarchy, and pointer raycast — layout questions answered without a screenshot
build	Target list and switching, player builds with a summarised BuildReport, the build scene list
package	Package Manager: list, add, remove, registry search — plus scoped registries (UPM has no API for those, so they are read and written in manifest.json directly) and .unitypackage import/export, which is callback-driven and so cannot be awaited from exec
editor	Selection, undo, focus, gizmos, physics raycast, the preferences that explain why a refresh seemed to do nothing — EditorPrefs by key or substring search, read and write, being the machine-local settings that are in no project and no repo — and open_settings to open a named Project Settings or Preferences page
scene	Structured hierarchy snapshot; describe for the scene's geometry — extents, floor height, unit scale, size distribution and anomalies (strays, unsupported objects, collapsed scale, props buried inside geometry); near for what surrounds one object and how. Plus scene lifecycle (open/save/new/unload) and lighting/NavMesh bakes — the File menu can't be driven remotely because its commands open native dialogs
screenshot	Capture, compare against a baseline (numbers + changed region, image only past a threshold), exposure stats with no image, and multi-angle contact sheets; resolution always clamped. view:window photographs an EditorWindow — the editor's own UI, docked or floating — which is what documentation figures are made of
frames	One camera rendered N times, answering how the picture changes over the sequence — per sample a reference-free noise estimate plus the delta against the previous sample and the first, then a verdict (static / converging / settled at sample N / drifting / unstable). spacing:"doubling" samples at render 1,2,4,8… for an accumulating renderer; settle skips the warm-up so you measure steady-state boiling. Numbers only
test	Run EditMode/PlayMode tests and report failures — impossible through exec, since the Test Runner API is callback-based
custom	Call this project's own [McpExpose] helpers — a first-class home for the probe methods you'd otherwise paste into exec every session
console	Structured, deduplicated console entries
status	Editor state; wait_for_idle blocks through compiles
refresh	Refresh + wait for compile + report errors, in one call
play	Enter/exit/pause/resume/step play mode; enter and exit wait for the switch to land, so nothing follows them
hot_reload	Edited method bodies into the running play session, by redirecting them to freshly compiled ones — no domain reload, so the game state you are debugging survives. Verified on instance methods, property getters, virtual methods, lambdas, and coroutines already running. Refuses, by name and reason, what would be silently wrong instead: structural edits, and any body that reaches its own assembly's statics, a typeof or a cast — following the calls it makes, not just the body — plus yield/await point changes. probe writes nothing, watch applies on every save, on_unsupported:recompile falls back to a real recompile. mayBeInlined flags patches the JIT may have inlined past
batch	Several tool calls in one round trip, in order, with one consolidated answer — for a sequence you already know (answered by the bridge, and it survives a reload mid-sequence)
compare	A/B in one call: set up each arm, take the same measurement after every one, median the repeats, and answer with a metric table and deltas against the first arm
perf	Verdicts, not numbers: bound says what the frame waits on (main / render / GPU / present, via FrameTimingManager), spikes finds outlier frames by median + k·MAD and names the counter that fires only on them, io samples FileIO, memory does snapshot → run → snapshot → diff in one call, budget checks ProjectSettings/MolayoPerfBudget.json. Every answer carries a trust block; time budgets measured under a throttled editor are skipped, not failed
profile_counters	60-frame live counter sample (~300 bytes); action:"list" searches every counter the project exposes, counters:[...] samples any by name, series:true returns per-frame values
profile_capture	N-frame capture → ~1KB summary + saved .data
profile_query	Drill into one marker
profile_diff	Compare two captures
doctor	One-call health check: bridge version/mode, whether the verification hooks are installed, and whether each running editor actually answers a handshake (answered by the bridge, works while editors are down)
instances	Which Unity editors are running and which one is the session default (answered by the bridge, works while the editor is down)
use	Set the session default project a routing bridge sends calls to; every editor tool also takes a per-call project override (router mode only)
wake	Activate the editor window, to release a domain reload stalled by an inactive editor (answered by the bridge, Windows only, and usually refused — see below)

---

이 문서는 README의 공개 소개 구간에서 자동 갱신됩니다.