Tools

Skywalker exposes 238 tools (engine 0.1.0). The editor, its in-app agents, the CLI and every MCP client call the same tools with the same JSON arguments, so anything you read here works everywhere. 137 tools change the project; every such change is undoable and attributed to whoever made it.

Arguments are validated before a tool runs: unknown keys, wrong types and bad enum values fail with a did you mean …? hint. Each tool page shows the arguments, the annotations MCP clients use for approvals, and the same call as a tool call, a CLI command and a raw MCP request.

Category	Tools	What for
Scene	11	Orient yourself, query and save scenes, and batch many edits into one undo step.
Entity	10	Create, read, change, move, duplicate and delete entities; read component schemas.
History	1	Undo, redo and the attributed edit history.
View	9	See the scene: captures with entity boxes, debug views, multi-view sheets, selection and the editor camera.
Render	27	Environment, effects, hair, shaders, render layers, impostors, benchmarks and the movie renderer.
World	15	Terrain, foliage, water queries and spatial placement on real geometry.
Asset	28	The asset database, import and download, materials, textures, prefabs, audio generation and previews.
Wander	19	Write, check, test, graph and inspect Wander behaviors.
Code	4	Native code: ahead-of-time compiled behaviors and C++ modules (trusted local code; clients ask first).
Simulation	15	Play, pause, step and stop; inject input; trace and inspect what runs.
Physics	16	Rigid bodies, characters, queries, settling and navigation meshes.
Animation	15	Skeletal animation, controllers, IK, bone attachments and cinematic sequences.
UI	4	Build, style, inspect and drive user interfaces.
Dialogue	3	Lint, preview and control branching dialogue.
Studio	26	The multi-agent studio: roster, board, feedback, decisions, loops, messages and playtests.
DCC	15	Design-app bridge: run scripts in Blender (and other apps), convert, generate and live sessions.
Files	4	Project settings, packaging the game as an app, running it in the real player, and the legal notices.
Network	1	Licensed downloads from the web, recorded with provenance and credits.
Custom tools	9	Define, test, inspect, approve and manage the project's own tools (Wander, composite and hosted).
Agent layer	6	The event log and hosted tools that external agent processes (such as the Python agent layer) use.

Every tool

Tool	Category	Summary
batch	Scene	Run many tool calls atomically as ONE undo step.
engine_info	Scene	Version, renderer, play state, component types and tool categories.
scene_additive_load	Scene	Adds a scene's entities to the running game (a room, a streaming chunk, a UI overlay) with fresh entity ids and returns its handle.
scene_additive_unload	Scene	Removes a sub-scene loaded with scene_additive_load or Wander's load_additive: exactly the entities it created.
scene_change	Scene	Moves the running game to another scene, as Wander's change_scene does: the scene is a game.json "scenes" alias or a .sky.json path (unknown names get a did-you-mean).
scene_flow_info	Scene	The running game's scene flow: the current scene (alias or path), the pending change (target, preloaded assets, loading scene), loading progress, the transition (kind, phase out|loading|in|idle, alpha), loaded sub-scenes with their entity counts, the carried entities (carried: carry components, game.json sceneFlow.carry), game.json scene aliases and every scene file.
scene_load	Scene	Load a scene file (replaces the current scene and clears history).
scene_new	Scene	Start a new scene.
scene_overview	Scene	Compact outline of the whole scene: every entity as one line (id, name, mesh/color, position, tags) in hierarchy order, plus environment, selection and the scene file (path; empty until saved).
scene_query	Scene	Find entities by name glob (e.g.
scene_save	Scene	Save the scene as JSON (.sky.json).
component_schema	Entity	JSON schema of components (transform, mesh, light, camera) and the environment, with field docs, ranges and enums.
entity_copy	Entity	Copy entities (with children) to a clipboard document for entity_paste — in this scene or after scene_load in another.
entity_create	Entity	Create an entity.
entity_delete	Entity	Delete an entity and all its children (undoable).
entity_duplicate	Entity	Copy an entity (with children, components and behaviors).
entity_get	Entity	Full data of one entity: components (all fields), tags, vars, behaviors (intent + Wander source).
entity_paste	Entity	Create copies of a clipboard document from entity_copy.
entity_refs	Entity	Who references an entity and what it references (joint targets, camera follow, look-at, bone attachments, IK, groom/particle colliders...).
entity_update	Entity	Change an entity.
transform	Entity	Move/rotate/scale an entity.
history	History	Undo or redo edits (by anyone), or list recent history entries with who made them.
camera_set	View	Point the editor camera (what the human sees and the default capture view).
scene_audit	View	Quality gate before filming or screenshots (read-only, CPU, no GPU needed).
selection_get	View	Entities the human currently has selected in the editor ("this", "these" usually means them).
selection_set	View	Select entities in the editor to show the human what you mean.
viewport_capture	View	Render the scene and return a PNG plus every visible entity with its on-screen box [x, y, w, h].
viewport_debug_view	View	Show a debug visualization in the live editor viewport (the human sees it too), or list every view with its color legend (list=true).
viewport_multi	View	One image with four views of the scene (or an entity): perspective (top-left), top (top-right), front (bottom-left) and side (bottom-right).
viewport_pick	View	Which entity is at pixel (x, y) of a capture with the given size (editor camera).
viewport_quality	View	How the live editor viewport renders while editing: fast (default; lower internal resolution, no screen-space GI/reflections or light shafts, near foliage shadows, coarser LODs) keeps heavy worlds responsive; balanced; full (what the game and captures show).
environment_get	Render	Current sun, sky, ambient, fog, exposure and grid settings.
environment_update	Render	Edit scene lighting/atmosphere: sun (azimuth, elevation, color, intensity), sky colors, ambient, fog, exposure, grid.
fx_benchmark	Render	Render frames real-time frames back to back (no readback, effects time advancing 1/60 s per frame, so GPU particles and hair simulate) and report the GPU time per frame and per effects pass, plus the wall-clock time.
fx_burst	Render	Emit particles from an emitter right now (explosions, muzzle flashes, impacts).
fx_create	Render	Create an effect or a body of water from a preset, ready to tweak.
fx_stats	Render	Measured GPU cost of the last rendered frames: whole-frame GPU time, the GPU simulation pass (particles + hair), per-emitter live particle counts (read back asynchronously, a few frames old) and per-groom sizes.
groom_create	Render	Grow strand hair or fur on an entity's mesh (a head, a bust, an animal body) from a preset, ready to tweak.
groom_info	Render	Strand, guide and point counts, memory (CPU and GPU), generation time and the measured GPU cost (simulation and drawing) of a groom, or of every groom in the scene when entity is omitted.
groom_update	Render	Change a groom's fields (or switch to another preset and then apply fields).
impostor_bake	Render	Bake the octahedral impostors of foliage layers now: each heavy model (an imported tree, bush, rock or grass clump; one mesh or every part of a prefab) is captured from up to 32x32 directions into an atlas of albedo, normal and depth, and instances beyond the layer's transition distance render as impostors (lit, shadowed and depth-correct like real geometry).
light_shadows	Render	Turn shadows of point/spot lights on or off and tune them, for one light, a list, or every light ("all", optionally only one kind).
locale_check	Render	Audits localization and returns findings an agent can fix one by one: per locale the keys with no translation (and coverage); keys the project uses ("@key" fields, tr("key") in scripts, #line dialogue ids) that no table defines; unused keys; placeholder mismatches between a translation and the source ({name} missing or extra); invalid messages; plurals missing forms the language needs (ru: one/few/many, ar: zero..many); strings longer than their budget (the table's max column, or source length x budget, default game.json maxLengthRatio); characters no font covers (CJK, Arabic...: add a font); keys requested at run time but missing.
locale_extract	Render	Scans the open scene, scenes, prefabs, dialogue scripts and Wander code for hard-coded player-facing texts (ui.text, ui.placeholder, text.text, dialogue lines and choices without a #line id, .text = "..." in scripts) and proposes a key for each ("main_menu.play", "dlg.intro.start.003"); a text whose source string already exists reuses its key.
locale_list	Render	Lists the game's locales: the current one and its fallback chain (pt-BR -> pt -> source), the source language, every locale with strings (count, coverage, files under locale/), game.json localization settings, strings requested at run time that no table has, and table file problems.
locale_pseudo	Render	Writes a pseudo-locale for layout testing: every string accented and about 30% longer inside brackets ("Play" -> "[Ƥļáý~~]"), placeholders, plurals and rich-text tags intact, so truncation, overflow and hard-coded texts (they stay plain) jump out.
locale_set	Render	Switches the language the game shows: texts written as "@key" (ui.text, ui.placeholder, text.text), tr() calls and #line dialogue lines follow at once.
movie_render	Render	Render a cinematic to video or a PNG sequence, offline and deterministically (the movie renderer).
particles2d_create	Render	Create pixel-art particles for a 2D game from a preset, ready to tweak: rain (streaks over the whole view), drizzle, snow (drifting flakes), leaves and petals (falling, swaying), fireflies (glowing, twinkling, wandering), smoke (chimney puffs), ripples (puddle rings while it rains), dust (motes in sunlight), sparkle (water glints).
particles2d_info	Render	Live state of particles2d emitters: particles alive, cap, rate, box, wrap, and the bounds the live particles cover (world units).
perf_stats	Render	Frame cost and scene complexity: GPU and CPU frame time, draw calls, lights, terrain nodes, foliage instances, entities, behaviors and assets.
probe_add	Render	Add a reflection probe: a captured cubemap that glossy floors, metal and glass inside its volume reflect instead of the sky (box-projected, so reflections line up with the walls), and that gives them their ambient light.
probe_bake	Render	Re-capture reflection probes now (after moving furniture, changing lights or the sky): renders one still frame of view, which captures every invalidated probe in full regardless of the per-frame face budget, and returns their state (slot, captures, GPU time) plus warnings.
probe_info	Render	Reflection probes and their atlas: the budget (Environment.probeBudget probes, probeUpdates faces per frame), atlas resolution / slots / memory, and per probe: slot and debug color (the reflection_probes debug view draws it), whether it is captured, lighting this view, waiting for the face budget, over budget or out of view, captures so far, last capture GPU time, stale (something in range changed since a once probe was captured: run probe_bake), size, update mode.
render_layers	Render	Render layers (20): MeshRenderer.layers says which layers a mesh is on; Camera.cullMask and Light.cullMask say which layers a camera draws and a light illuminates (a mesh is drawn / lit when they share a layer).
shader_get	Render	The renderer's current shader source (Metal Shading Language).
shader_set	Render	Replace the renderer's shader source at runtime.
shadow_atlas_info	Render	Which point and spot lights cast shadows this frame and how: projection (spot view, cube = 6 views, dual_paraboloid = 2 views), atlas slot and resolution, whether it was re-rendered this frame or reused from the static cache, and why a light has no shadow (disabled, out_of_view, beyond_max_distance, over_light_budget, atlas_full, pending).
foliage_add	World	Grow GPU-instanced foliage and ground detail over a terrain (or over scene meshes in an area): grass, tall grass, dune grass, flowers, ferns, beach pebbles, shells, small rocks, boulders — or any mesh/asset as a custom layer (trees, bushes from downloads).
place_on_surface	World	Move entities straight down (or up) so the bottom of their bounds rests on the geometry below them.
raycast	World	Cast a ray into the scene and get the first mesh hit (triangle-accurate): entity, point, surface normal and distance.
scatter	World	Procedurally place many copies of an entity or prefab in an area — forests, rocks, coins, crowds.
terrain_create	World	Create a large heightfield terrain: an island with beaches, a tropical coast, alpine peaks, a canyon, desert dunes, rolling hills or a mountain valley.
terrain_generate	World	Regenerate a terrain's heights from new generator parameters (shape, seed, heights, featureSize, ridges, warp, erosion, thermal, terraces, beachWidth, seaLevel), then re-paint its layers.
terrain_layers	World	Replace a terrain's material layers and re-paint them from their rules (height/slope/noise).
terrain_paint	World	Paint a material layer (by index or name) onto a terrain with brush strokes at world (x, z): sand paths, dirt patches, grass clearings.
terrain_query	World	Terrain height, normal, slope (degrees) and dominant layer at world (x, z) points, plus terrain stats.
terrain_sculpt	World	Sculpt a terrain with brush strokes at world (x, z) positions: raise / lower (strength in meters), flatten (toward target world height; plateaus, roads, building pads), smooth, noise (rougher ground), set.
terrain_undo	World	Step back the last terrain_sculpt / terrain_paint / terrain_generate / terrain_layers on a terrain (heights and weights; component fields use the regular undo).
tilemap_from_ascii	World	Build or update a tilemap from an ASCII map — the fastest way to lay out a level.
tilemap_inspect	World	Read a tilemap as ASCII per layer (with a legend of tile ids and counts), its size, tileset, terrains and the merged collision rectangles (world units, relative to the map's top-left; x right, y up) — what a physics body or a pathfinder needs.
tilemap_paint	World	Edit a tilemap layer: set individual cells, fill a rectangle, flood-fill a region, or clear.
water_query	World	Height and normal of the animated water surface (FFT ocean) at points — for floating boats, buoys and debris, or placing a pier above the waves.
asset_complete	Asset	Mark a request done with the generated file (project-relative).
asset_import	Asset	Register a file placed in the project (e.g.
asset_import_mesh	Asset	Import a mesh (.obj, .glb, .gltf — e.g.
asset_info	Asset	Everything about one asset: GUID, type, tags, description, provenance, import settings, which entities use it, and type-specific data (material fields, prefab contents).
asset_list	Asset	Search the project's assets (meshes, textures, materials, prefabs, scenes, audio...) by type, tag or text (matches path, description and tags; supports * globs).
asset_move	Asset	Rename or move an asset file (its .meta and GUID move with it) and update every reference in the open scene.
asset_preview	Asset	Render an isolated preview image of a mesh, material (on a sphere), texture or prefab — look before you place it.
asset_refresh	Asset	Rescan the project folder for new or changed files (the editor also does this automatically).
asset_request	Asset	Queue a request for generated content — kind: mesh (3D model), texture, sprite (2D), audio (sfx), music, video — with a prompt.
asset_requests	Asset	List generated-asset requests and their status.
asset_tag	Asset	Set an asset's tags and/or description (and provenance).
audio_generate	Asset	Create a sound effect, ambience loop or piece of music as a WAV file in the project, procedurally and deterministically (the same seed and parameters always give the same audio) - no external generator needed.
audio_info	Asset	Measure an audio file (wav, mp3, flac): duration, sample rate, channels, peak and RMS in dBFS, integrated loudness (LUFS), clipping, DC offset, silence ratio, whether it starts or ends abruptly (clicks), and for loops how big the jump is at the loop point.
groom_export	Asset	Write a groom's rest-pose strands to a file for DCC round trips: .hair (Cem Yuksel's format, read by many hair tools), .groom.json (readable) or .skygroom (compact binary).
material_assign	Asset	Use a material asset on one or more entities (sets mesh.material; empty string clears it).
material_create	Asset	Create a reusable material asset (*.mat.json): color, metallic, roughness, emissive (glows with bloom), albedo texture with tiling, unlit.
material_update	Asset	Change fields of an existing material; every entity using it updates instantly.
prefab_apply	Asset	Push an instance's overrides into its prefab file so every instance (in all scenes) gets them.
prefab_create	Asset	Save an entity and all its children (components, behaviors, vars, tags) as a reusable prefab asset.
prefab_instantiate	Asset	Create a linked instance of a prefab: the scene stores only what you change on it (prefab_overrides), and editing the prefab updates every instance.
prefab_overrides	Asset	How a linked prefab instance differs from its prefab: per-field overrides (with the prefab's value), removed nodes, added entities and its placement (root name/transform, never applied).
prefab_relink	Asset	Link existing copies of a prefab (made before prefabs were linked, or by copying entities) back to it.
prefab_revert	Asset	Undo overrides so an instance matches its prefab again.
prefab_unpack	Asset	Make an instance local: its entities stay exactly as they are but are no longer linked to the prefab (edits to the prefab stop reaching it, and the scene saves it in full); also known as "make local".
sprite_atlas_pack	Asset	Pack many images (a folder, a list, or globs like "sprites/hero/.png") into one atlas texture plus a .atlas.json describing every frame (trimmed of transparent borders, padded and edge-extruded so nothing bleeds).
sprite_sheet_import	Asset	Turn rendered animation frames (a Blender/DCC render: one subfolder of numbered PNGs per clip, e.g.
sprite_sheet_slice	Asset	Describe a grid sprite sheet as an atlas (*.atlas.json) so frames get names: give the cell size (or columns/rows), optional margin/spacing, and either names or a prefix.
texture_generate	Asset	Procedurally generate a seamless PBR texture set — albedo, normal map and ORM (occlusion/roughness/metallic) — for realistic or stylized surfaces: bricks, planks, cobblestone, rock, rust, marble, fabric, scales, ...
behavior_from_graph	Wander	Turn a node graph (from behavior_graph, possibly edited) back into Wander source.
behavior_graph	Wander	Visual node graph of a behavior (or raw source): bodies (handlers, fns, tests, state handlers) with an entry node, exec-flow statement nodes wired by exec pins (if: then/elif/else; loops: body), expression nodes wired into data pins, and literals/names inline on pins (value).
behavior_remove	Wander	Remove a named behavior from an entity.
behavior_set	Wander	Create or replace a named behavior on an entity: its natural-language intent (the human source of truth), an optional structured spec derived from the intent ({summary, rules: [{text, tests: [test names]}]}), and the Wander source.
behavior_spec	Wander	The intent -> spec -> code view of a behavior: its intent, the stored spec (rules an agent derived from the intent, each naming the tests that verify it), what the code declares (triggers, states, tunable params with ranges and current per-entity values, vars, functions, tests), and coverage (rules without tests, tests without rules).
wander_break_clear	Wander	Removes breakpoints: one by id, every breakpoint of a script, or all (no arguments).
wander_break_list	Wander	Breakpoints and logpoints with their script, line (and the line asked for when it moved), condition, hit condition, hits so far, whether a compiled script has code there, plus break-on-error.
wander_break_set	Wander	Stops the running game at a line of a behavior script so you can inspect it (wander_stack, wander_eval).
wander_check	Wander	Compile Wander source without attaching it, exactly as the engine would run it (components, builtins, used modules from the project).
wander_continue	Wander	Resumes a game paused in the Wander debugger.
wander_debug_state	Wander	Whether the game is paused in the Wander debugger, why (breakpoint, step, pause, error with its message) and where (script, line, function, entity, state), plus the breakpoints.
wander_eval	Wander	Evaluates a Wander expression in a paused frame (0 = innermost): its locals, arguments, the behavior's vars, self and every read-only builtin are available ("distance(self, target)", "items.length").
wander_inspect	Wander	While playing: the runtime state of an entity's behaviors — current state of each state machine and how long it has been active, handlers waiting in wait (and for how long), plus the entity's vars.
wander_pause	Wander	Stops at the next statement any behavior runs (the game is frozen mid-tick there; resume with wander_continue).
wander_reference	Wander	The Wander 2 guide for writing behaviors: syntax, triggers, statements, idioms, and every builtin function with its signature (generated from the builtin registry, including subsystem and native-module builtins).
wander_set_var	Wander	Changes a local, an argument or one of the entity's vars in a paused frame, then the behavior continues with it (test a fix without restarting).
wander_stack	Wander	The paused behavior's call stack, innermost first: function, script, line and column, entity, behavior and state, each frame's arguments and locals (value and display text), the entity's vars, and globals (time, frame, dt).
wander_step	Wander	Steps a paused behavior: over (the next statement of this function; calls run through), into (the next statement anywhere, entering called functions), out (back in the caller).
wander_test	Wander	Run the test "..." blocks of a behavior in a sandbox simulation (the real scene is never touched): each test gets a fresh world, ticks once (on start ran), then runs with self = the entity under test; wait advances the simulation at 1/60 s, emit/press/hold/release/click inject input, and expect reports failures with the compared values.
native_build	Code	Compile the project's native C++ module (native/*.cpp against skywalker/native/sdk.h, plus flags, include dirs, libraries, frameworks and pkg-config packages from native/module.json) into a library with the system clang++, then load it: its builtins become callable from every behavior (they appear in wander_reference) and its systems run every tick while playing.
native_list	Code	Status of the project's native code: whether native sources exist, the C++ compiler, the last build and its diagnostics, the loaded module with its builtins (signatures) and systems, and behaviors running as AOT-compiled native code.
native_template	Code	Write a starter native module: native/<name>.cpp (a builtin wave(t, freq) and a per-tick system that spins entities tagged "spinner") and native/module.json (flags, include_dirs, lib_dirs, libs, frameworks, pkg_config).
wander_compile_native	Code	AOT-compile Wander behaviors to C++ and load them as native code (system clang++, cached by program hash, so unchanged behaviors load instantly).
audio_mix	Simulation	Read or set the project's mixer (audio.json): per-bus volume and mute for master, music, sfx, ambience, voice and ui, and the default music crossfade.
audio_play	Simulation	Listen to a clip or an entity's audio component.
game_feel	Simulation	Try impact feedback on the running game exactly as Wander does: hit_stop freezes the game clock for seconds (or slows it to scale), shake adds trauma (0..1) to the 2D camera (camera, default the active one), flash flashes an entity's sprite color fading over seconds; info reads the hit-stop left, each camera2d's trauma and offset, and active flashes.
input_map	Simulation	Read or edit the project's input action map (input.json): named, device-independent actions bound to keyboard, mouse and gamepad.
load_game	Simulation	Restores a slot into the running game: persisted entities return to their saved state (spawned ones are recreated with their ids, ones destroyed before the save are removed again), game vars, the scene (a save from another scene is an immediate scene flow change: carry entities come along) and the exact behavior state (state machines, timers, waiting handlers, random generator), then on loaded runs.
logs	Simulation	Recent Wander log output and runtime/compile errors.
process_info	Simulation	What runs while the game is paused or slowed, and how smooth real-time frames are.
save_delete	Simulation	Deletes a save slot's file.
save_game	Simulation	Saves the running game into a slot, exactly as Wander's save_game() would at a tick boundary: every entity with a persist component (whole state or chosen fields, Wander vars, spawned subtrees), tombstones for persisted scene entities that were destroyed, game_var values, the scene, the play time and the exact behavior state.
save_inspect	Simulation	Diffs a save slot against the running game to debug "what didn't restore": per persisted entity, the fields whose current value differs from the saved one (path, saved, current), entities missing from the scene, entities the save destroyed or never had, game var differences, the scene and the tick.
save_list	Simulation	Lists the save slots of this project: slot, metadata (title, chapter...), file size, format and game version, play time, scene, tick and when it was saved.
sim_control	Simulation	play / pause / stop the game, or step N fixed ticks (1/60 s each) deterministically and get the resulting logs and errors.
sim_input	Simulation	Inject player input for the next ticks, like a player (or a playtest bot) would: press keys (fires on key), hold/release keys (for key()), press or hold input ACTIONS (jump, fire, ...
sim_teleport	Simulation	Move an entity instantly — a respawn, a portal, a checkpoint — without render interpolation smearing it across the screen for a frame (Wander: teleport(entity, position)).
sim_trace	Simulation	Run the game for N ticks and sample properties over time — e.g.
nav_build	Physics	Bake (or rebuild) the navigation mesh from static colliders and static meshes, save it to the project and record the settings in the scene's navmesh component (one undoable edit; creates an entity named "Navigation" if needed).
nav_debug	Physics	Top-down map of the level with the navmesh drawn over it (teal = walkable), nav agents (yellow dots) with their current paths, and optionally a test path between two points (orange).
nav_path	Physics	Walking path on the navmesh between two points or entities (bakes the navmesh first if needed).
physics2d_add	Physics	Make 2D entities physical with a preset (one undoable edit); colliders are fitted to the sprite.
physics2d_info	Physics	The 2D physics world (Box2D) at a glance: settings (gravity, sub-steps, debug draw), counts (bodies by motion, awake/sleeping, shapes, sensors, chains, characters, joints, contacts), each body and character2d with its velocity, sleeping/grounded state, tilemap collision pieces (merged loops/boxes/polygons), and warnings (bad polygons, unknown layers, missing joint bodies).
physics2d_query	Physics	Ask the 2D collision world (collider2d shapes, character2d capsules) on the XY plane — works while editing and playing.
physics2d_settle	Physics	Drop 2D objects with a real simulation and keep where they come to rest: only the listed entities move (as dynamic bodies, even without body2d), everything else is frozen; the result is ONE undoable edit.
physics_add	Physics	Make entities physical with a preset (one undoable edit).
physics_debug	Physics	Capture the viewport with every collider drawn as a wireframe (color = state) plus physics stats (bodies, awake/asleep, contacts, triggers, characters, joints) and warnings (bad layers, unsupported shapes, missing joint targets).
physics_query	Physics	Ask the collision world (colliders, not render meshes) — works while editing and playing.
physics_settings	Physics	Read or change scene-wide physics: gravity (m/s^2), substeps (stability for stacks/fast objects), which collision layers ignore each other (ignorePairs, e.g.
physics_settle	Physics	Drop objects with a real simulation and keep where they come to rest (simulate, then keep the poses).
vehicle_create	Physics	Make a drivable car, truck or kart from a chassis entity whose wheel meshes are child entities named wheel* (wheel_fl, wheel_fr, wheel_rl, wheel_rr; or pass wheels).
vehicle_info	Physics	Live state of vehicles: speed (km/h), rpm, gear, inputs as asked and as applied after assists (steering smoothing, auto reverse, traction control, ABS, drift assist), drift angle, lateral/longitudinal g, and per wheel: suspension length/compression, contact point and surface, load (N), drive and cornering forces, slip ratio and slip angle, skid 0..1.
vehicle_test_drive	Physics	An autopilot drives a copy of the vehicle through standard maneuvers in a private physics world (the scene is not changed; works while editing) and returns handling metrics to tune by numbers: accel (0-60, 0-100 km/h, quarter mile, wheelspin, upshifts), braking (distance and g from speed, default 100 km/h; ABS activity, stability), slalom (8 cones every cone_spacing m at speed, default 60: completed, cones hit, average speed, line error), skidpad (circle of radius m, speed ramps until the car leaves the line: max lateral g, and whether it understeers, oversteers or runs out of power), top_speed (duration s), custom (inputs keyframes [{t, throttle, brake, steer, handbrake}]), all (accel, braking, slalom, skidpad).
vehicle_tune	Physics	Change a vehicle's handling parameters with validation (one undoable edit; works while playing: the vehicle is rebuilt keeping its speed).
animation_list	Animation	Skeleton and clips of a rigged model or animated character.
animation_preview	Animation	Render a character posed at a clip or state at given times (editor preview; the scene is not changed).
animation_retarget	Animation	Retarget clips from one humanoid rig to another in pose space and save them as a new library (.anim) on the target's skeleton: different bone names (mixamo / suffixed like thigh_l / generic, detected by name and topology), rest poses (T-pose vs A-pose), bone axes and proportions (the hips move by the source motion scaled by the leg-length ratio; bones keep their own lengths, so nothing stretches).
animator_set	Animation	Set an animator's parameters and triggers, or play a state/clip with a crossfade — live while the simulation runs (same as Wander set_param / trigger / play_animation), or as the editor preview while editing.
animator_setup	Animation	Create a state machine controller (*.animctl.json) for a character and assign it.
bone_attach	Animation	Make an entity follow a bone of an animated character: a sword in the right hand, a hat on the head, a lantern on the hip.
bone_ik	Animation	Make a character's hand or foot reach a point with two-bone IK (the elbow/knee and shoulder/hip bend; bone lengths are kept): a hand on a door handle, rail or lever, a foot planted on a step.
character_ik	Animation	Set up automatic foot IK, hand targets and turning for a humanoid character (adds or updates its characterIk component; undoable).
character_inspect	Animation	Everything about a character's animation and look in one call: the humanoid bone map of its skeleton (slots like hips, leftHand, rightFoot with the bone names found, convention mixamo / suffixed / generic, missing slots), key bone positions in the world, clips with their root speed (m/s) and root turn (degrees per cycle), root motion / in-place / root yaw settings, retargeting (retargetFrom and how its clips map), foot and hand IK status of the last solve (contact, locked, ground offset, slope, pelvis drop, hand reach error), hair and fur attachment (follows the skin?, bound roots, colliders), and the material model of every mesh part (skin, eye, cloth, hair_card, pbr).
sequence_camera_shot	Animation	Add a procedural camera move to a sequence — the quickest way to direct cinematics.
sequence_create	Animation	Create a cinematic sequence asset (*.sequence.json) and an entity whose sequencer plays it when the simulation starts.
sequence_get	Animation	A sequence's tracks (type, entity, property, key count and time span) and length; with time, the evaluated property values and live camera at that moment.
sequence_key	Animation	Add or replace keys in a sequence, many at once.
sequence_play	Animation	Play or stop a sequence.
sequence_scrub	Animation	Look at a sequence at any time without playing: renders through the sequence's live camera (cuts and shots) with every keyed property and animation applied, then restores the scene.
ui_create	UI	Build a whole user interface (HUD, menu, dialog, inventory, document) from one declarative JSON tree in a single undoable step.
ui_inspect	UI	Read the computed UI layout: every element's rect [x, y, w, h] in pixels for a viewport (default: the canvas's reference resolution), visibility, text, values and style classes, as a tree.
ui_interact	UI	Use a widget the way a player would: click a button (sends Wander on ui "&lt;name&gt;" and on click on the next tick while playing), toggle, set a slider/progress value, type into an input, scroll a scroll view, or click at a pixel (hit-tested like a mouse).
ui_style	UI	Restyle a UI.
dialogue_check	Dialogue	Lint a .dialogue script (Yarn-style): syntax errors with line numbers, jumps to missing nodes (with did-you-mean), a missing start node, unreachable nodes, variables read but never set, empty nodes.
dialogue_control	Dialogue	Drive a live conversation in play mode (enters play-paused when editing, like sim_control step): start a node, advance (finishes the typewriter first), choose an option (0-based), stop, or read the state (speaker, line, choices, typing).
dialogue_preview	Dialogue	Simulate a conversation without UI or play mode and get the transcript: every line (speaker, text, tags), each choice offered and taken, commands sent, node jumps, final variables and visit counts.
playtest_compare	Studio	Before/after comparison of two playtests (ids like P-3): every metric with its delta and whether it got better or worse (direction-aware: fewer deaths is better, higher completion is better).
playtest_run	Studio	Play the game with a bot in a sandbox copy of the scene (the scene you edit is untouched) and get a report: completion rate, time-to-goal, deaths and their causes, fails, damage, stuck periods, objectives, coverage, frame cost, screenshots at notable moments and a top-down heatmap (returned as an image).
studio_agent_brief	Studio	Everything needed to be a roster member: its system prompt (role mission, focus, persona, standing instructions, memory, the team, studio etiquette) and the engine tools it may use with their access (allow | ask).
studio_agent_define	Studio	Create a studio agent or update one (by id or name; only the fields you pass change).
studio_agent_list	Studio	The studio roster: each agent's id (use it for assignees and @mentions), name, role, discipline, focus, live status, open tasks and usage.
studio_agent_remove	Studio	Remove an agent from the studio (deletes agents/<id>.agent.json; its open tasks become unassigned).
studio_decide	Studio	The director's (or producer's) verdict on a feedback item, visible to everyone with its rationale: act (creates tasks — give each a title, acceptance criteria and an assignee — or links existing task_ids), drop (won't do, say why), defer (later), or merge_into a duplicate.
studio_feedback_list	Studio	Feedback with each item's director verdict (act / drop / defer / merge_into), rationale and measured effect (metrics before/after).
studio_feedback_submit	Studio	File feedback about the game as a playtester, critic, agent or human: category (fun, difficulty, clarity, visuals, audio, performance, bug, narrative, accessibility), severity, a one-line summary, details, what it's about (target), and evidence {playtest: "P-3", captures: [...], metrics: {...}, positions: [[x,y,z]], repro: [steps]}.
studio_feedback_update	Studio	Change a feedback item: status (e.g.
studio_inbox	Studio	Messages for you (addressed to you, mentioning you, or broadcast in #general), oldest first; unread only by default, and reading marks them read.
studio_loop_advance	Studio	Report the results of a loop stage's assignments and move the loop on: reports [{agent, report, signoff?, usage?}].
studio_loop_define	Studio	Define a studio loop: a repeatable cycle of stages with stop conditions, stored in studio/loops/<name>.loop.json.
studio_loop_start	Studio	Start a run of a loop.
studio_loop_status	Studio	A loop's state: status, iteration, current stage, pending assignments (with prompts), per-iteration history (stage reports, playtests, filed feedback, verified effects) and metric trends.
studio_loop_stop	Studio	Stop a running loop (pending assignments are dropped).
studio_memory	Studio	Your long-term memory as a studio agent (kept in your profile and shown at the start of every task): note a fact worth remembering (conventions, decisions, the human's preferences, unfinished work), forget an outdated note by number, or list notes.
studio_message_send	Studio	Talk to the team so the back-and-forth is visible: post in a channel (#general by default; any name creates a channel), address agents with to or @mentions in the text (@id, @role, @discipline, @all), reply in a thread with reply_to, and reference a task/feedback.
studio_overview	Studio	Start here when working with the studio (a team of AI agents making this game).
studio_presence	Studio	Show what a roster member is doing right now in the editor's Studio panel (live status and activity next to its avatar): working with a one-line activity when you start something, idle when you finish.
studio_task_claim	Studio	Claim a task and start it (assignee = you, status = doing).
studio_task_create	Studio	Put a task on the studio board.
studio_task_list	Studio	The studio board.
studio_task_update	Studio	Move a task across the board (backlog → todo → doing → review → done, or dropped), reassign it, edit it, or add a comment.
studio_team_template	Studio	Spawn a whole team of specialists from a template (agents that already exist by id are updated): starter_crew (5 generalists), indie_trio (3), aaa_strike_team (22: director, producer, five designers, four programmers, five artists, audio, writing, QA, two playtester personas, critic), narrative_team, qa_squad (QA lead, three playtester personas, critic, fixer), art_team, audio_team.
studio_usage_report	Studio	Record tokens an agent spent with its own model, for studio budgets and cost tracking (runners that call models outside the engine — the editor crew, custom scripts — report each request here).
dcc_cancel	DCC	Stop a running design-app job (its id is in dcc_list's jobs).
dcc_convert	DCC	Convert FBX, OBJ, Collada (.dae), USD/USDZ, 3DS, PLY, STL, Alembic or .blend files to glTF binary (.glb) with Blender — materials and textures are kept and embedded — then import them as assets.
dcc_edit_asset	DCC	Round-trip a mesh asset of the project through Blender: it is loaded, edited by preset ops and/or your Python script, exported and re-imported as a NEW VERSION (<name>_v2.glb, provenance recorded in its .meta: source asset, ops, version), so the original stays untouched and the change can be compared or reverted.
dcc_export	DCC	Export objects or collections of a Blender file to glTF (.glb) and import them: the way to use a hand-made or downloaded .blend asset library.
dcc_generate	DCC	Create a 3D model by running a procedural modeling recipe or your own Blender script, then import it as an asset (and optionally place it).
dcc_install_addon	DCC	Install (and enable) the Skywalker Bridge add-on in the user's Blender, so a Blender window the human works in can be driven live: it adds a 'Skywalker' tab to the 3D viewport sidebar (N) with Start Bridge and Send Selection buttons.
dcc_list	DCC	Which professional design apps are installed on this computer and what the bridge can do with them: Blender (fully supported and tested), plus Maya (mayapy), Houdini (hython) and 3ds Max (3dsmaxbatch) adapters that follow the vendors' documented headless interfaces but are untested.
dcc_receive	DCC	Copy a model file a design app just exported (an absolute path, e.g.
dcc_run_script	DCC	Run a Python script headless inside a design app on this computer (Blender bpy by default; Maya via mayapy, Houdini via hython, 3ds Max via 3dsmaxbatch — those untested) and get back its log, structured result and the files it produced.
dcc_session_exec	DCC	Execute Python inside the running Blender session (bpy, bmesh, B = skywalker_dcc.blender and sky are in scope; variables persist between calls, like a REPL).
dcc_session_pull_selection	DCC	Export the objects currently selected in the live Blender session (or the named objects) to glTF under dcc/live/<name>.glb, import them as an asset and place them (a new asset is placed at the origin unless you pass place; place:false imports only).
dcc_session_send	DCC	Import a project mesh asset into the live Blender session (it appears selected, and the view frames it) so you or the human can edit it there; bring it back with dcc_session_pull_selection.
dcc_session_start	DCC	Launch Blender with the Skywalker bridge running, so you can work interactively across many calls (state persists: build a scene step by step with dcc_session_exec, inspect it, then pull the result back with dcc_session_pull_selection).
dcc_session_status	DCC	Is a live Blender session available, and what is in it?
dcc_session_stop	DCC	Stop the bridge.
game_build	Files	Package the project as a standalone macOS app (Name.app): the player runtime, the scenes, the assets they reference (computed from scenes, prefabs, materials and Wander scripts; all_assets ships everything), scripts, the project's native module (compiled now), Info.plist, an icon made from the game.json icon, and an ad-hoc code signature.
game_run	Files	Start the standalone player on the current project as a separate process to try the game like a player would (real window, real input, audio).
game_settings	Files	Read or change the project's shipping settings in game.json: startScene, window {width,height,fullscreen,resizable,vsync}, quality (low|medium|high|ultra), renderScale, quitOnEscape, pauseOnFocusLoss, icon (a PNG, 1024x1024 recommended), bundleId (reverse-DNS), version, copyright, plus include/exclude globs for packaging, and the description fields (id, title, genre, mood, pitch), and mounts: shared folders outside the project addressed by a top-level name, e.g.
legal_info	Files	Skywalker's Terms of Use, Privacy Notice and license: their versions and effective dates, MCP resource URIs (skywalker://docs/legal/TERMS, skywalker://docs/legal/PRIVACY, skywalker://docs/LICENSING), whether a person has accepted the current versions on this computer (status current, outdated, not_recorded), and a verified summary of data practices (no telemetry; data leaves the computer only to the AI provider or download URL the human chose).
asset_download	Network	Download an openly licensed asset (3D model .glb/.gltf/.obj/.ply/.stl, texture, .hdr sky panorama, audio, or a .zip pack of them) from a URL into the project, record its license and author, add it to CREDITS.md, and (for models) import it — optionally placing it in the scene.
tool_approve	Custom tools	A HUMAN approves (or rejects with approve:false) the current definition of a custom tool that needs approval (it mutates, writes files or reaches the network, or the policy is "ask").
tool_define	Custom tools	Create or update your OWN tool when no engine tool does what you need.
tool_enable	Custom tools	Turn a custom tool off (it disappears from tools/list but keeps its files and approval) or back on.
tool_inspect	Custom tools	Full definition of a custom tool: code or steps, schemas, capabilities, limits, tests, status and why, approval (by whom, for which hash), stats (calls, failures, timing) and its recent calls and errors.
tool_list_custom	Custom tools	Every custom tool of the project (and external tools hosted by connected clients) with its status — active, pending_approval, rejected, disabled, offline, invalid — kind, version, author and call counts, plus the project's policy.
tool_policy	Custom tools	Read or set who approves custom tools in this project (game.json customTools.policy): off (disabled), ask (every tool needs a human's approval), auto (default: read-only tools run at once, tools that mutate or write files need approval), trust (no approvals).
tool_promote	Custom tools	Copy a project's custom tool into your user library (~/.skywalker/tools) so other projects can install it with tool_define {"from_library": "user_x"} (their approval rules apply).
tool_remove	Custom tools	Unregister a custom tool and delete its files (tools/<name>.tool.json and .wander) unless delete_files is false.
tool_test	Custom tools	Run a custom tool's tests, or one call with "args", as a DRY RUN: scene edits are rolled back and file writes skipped, so it is safe on tools that are not approved yet.
events_poll	Agent layer	Read the engine's live event stream (the same events the editor's Activity feed shows: tool calls with their actor, studio changes such as messages, tasks, feedback, decisions and loops, play state, selection, scene loads/saves, asset changes) after a cursor, without consuming them.
tool_host_list	Agent layer	Which external processes serve py_* tools: each host's label, owner (actor), tools, queued and in-flight calls, calls served and seconds since its last poll; plus the event stream's cursor range (events_poll).
tool_host_poll	Agent layer	Fetch the calls other agents made to your py_* tools (see tool_host_register): [{call, tool, args, actor}].
tool_host_register	Agent layer	Offer tools implemented in your own process (a Python agent harness, a script) to every agent connected to this engine: each becomes an engine tool named py_<name> that appears in tools/list.
tool_host_reply	Agent layer	Answer one call fetched with tool_host_poll.
tool_host_unregister	Agent layer	Stop serving the py_* tools of a host (they disappear from tools/list; calls still waiting fail).