Tool reference

get_tool_signature

Registered at startup.

Return the JSON schema (params, return shape, cost) for a specific HaybaOS command. Call list_tool_categories first to find command names.

hayba_check_ue_status

Registered at startup.

Check whether the Unreal editor bridge is reachable and report its current identity and status.

No parameters.

hayba_introspect

Introspect UE reflection: editor-property names+types of a class/struct, member values of an enum, or input/output pin labels of a PCG node (by graph+node) or settings class. Kills trial-and-error API discovery.

hayba_invoke

Registered at startup.

CALL ANY TOOL BY NAME, whether or not its pack is loaded — the whole catalogue is reachable through here. Pair with hayba_search_tools when you do not know the name. USE_WHEN: any call into an unloaded domain, which is most of them. NOT_WHEN: you are making many calls into one domain — hayba_pack_load gives you native schemas.

hayba_pack_list

Registered at startup.

List the tool packs — domain packs group one subsystem, workflow packs bundle a task across subsystems. Shows tool counts and which are loaded. USE_WHEN: you want the map of what exists. NOT_WHEN: you want a specific capability — hayba_search_tools is faster than reading the map.

No parameters.

hayba_pack_load

Registered at startup.

Register a pack natively so its tools appear in your tool list with full schemas. This is an OPTIMISATION for repeated use, not a prerequisite: hayba_invoke already calls any tool without it. USE_WHEN: you are about to make several calls into one domain. NOT_WHEN: one-off call — just invoke it.

hayba_search_tools

Registered at startup.

FIND A TOOL BY DESCRIBING WHAT YOU WANT, in plain language ("make a menu widget", "why is my landscape flat"). Searches the FULL catalogue, including the tools that are not registered yet — most of them are not, by design. Returns tool names you can pass straight to hayba_invoke without loading anything. USE_WHEN: you do not already know the exact tool name. NOT_WHEN: you know the name — just hayba_invoke it.

list_tool_categories

Registered at startup.

List all HaybaOS command domains and their commands. Call this first to discover what is available before requesting a specific schema.

No parameters.

actor_batch_spawn

Spawn many actors in ONE call from an array of {class_path, location?, rotation?, scale?, label?}. Prefer this over repeated actor_spawn: one round trip and one transaction instead of N.

actor_batch_transform

Transform many actors in one call: each entry sets absolute location/rotation/scale (omitted fields unchanged). Returns per-actor before/after read-back. Undo granularity follows the editor default (one python exec).

actor_call_function

Call a BlueprintCallable UFunction on an actor by name, with arguments. The escape hatch for behaviour no dedicated tool exposes — powerful and unvalidated, so it is gated by Plan Mode.

actor_delete

Destroy an actor in the active level.

actor_duplicate

Copy an existing actor, optionally placing the copy at a new transform. Keeps the source's properties, so it is the cheap way to repeat a configured actor rather than spawning and re-setting everything.

actor_find

Query level actors by label substring, exact class, tag, and/or a spatial radius around a point. Paginated. Returns {actors[], total, has_more}.

actor_focus

Frame the editor viewport camera on an actor (selects it and aligns the active viewport). For the vision loop before a screenshot.

actor_get_components

List an actor's components with their class and name. Use this before object_set_property or actor_call_function, which both need the component name. include_internal also returns engine-created components you normally do not touch.

actor_get_properties

Reflect every property on an actor with its current value. The discovery step before actor_set_properties — property names must match the UPROPERTY exactly, and this is how you learn them instead of guessing.

actor_get_selection

Read the current editor actor selection.

No parameters.

actor_inspect

Full read-back of a level actor: class, transform, bounds, components, material slots, tags, outliner folder, attach parent. The inspection half of the inspect-then-edit loop.

actor_list

List what is in the scene: every actor in the active level with its label, class and transform. Start here when you need to know what already exists before changing anything.

actor_set_folder

Move actors into a world-outliner folder (organisation). Empty folder string moves to the root. Returns per-actor read-back of the applied folder.

actor_set_properties

Set actor properties from a name to value map. Names must match the UPROPERTY exactly; a name the actor does not have is reported back rather than silently dropped, so read the response instead of assuming it applied.

actor_set_selection

Replace the editor actor selection with the given actors (by label or path). Returns the resolved selection + any unresolved ids.

actor_set_visibility

Show or hide an actor in the level. This is editor/runtime visibility only — the actor still exists, still ticks and still collides.

actor_snap_to_socket

Attach an actor to a named socket on another actor, so it follows that socket's transform. The usual way to put a prop in a hand, a light on a fixture, or a decal on a mount point.

actor_spawn

Place a new actor in the active level by class — a light, a volume, a blueprint actor, or any registered UClass. To place a StaticMesh or other content asset by its path instead, use actor_spawn_from_asset.

actor_spawn_from_asset

Spawn an actor from a content asset path (StaticMesh or Blueprint) without knowing the actor class. Optional snap_to_floor line-traces down onto geometry. Returns actor_id + final transform read-back. NON-IDEMPOTENT.

actor_tag

Add or remove gameplay tags on an actor in one call. Tagging marks an actor's role so PCG filters and gameplay code can select it by tag rather than by name.

actor_transform

Reposition, rotate, or scale an existing actor.

placement_validate

Asks whether an actor of this class would collide with anything if spawned at this transform, WITHOUT spawning it. Use it before actor_spawn when placing into a populated scene — cheaper than spawning, checking, and deleting. It answers about overlap only: it does not tell you whether the spot makes sense, is on navmesh, or is inside geometry.

memory_delete

Delete memory blocks: a single block by id, every block from one agentRole, or (with confirm_all) the entire store. Exactly one of id / agentRole / confirm_all is required.

memory_export

Dump memory blocks (optionally filtered by scope/agentRole) to a portable JSON file for backup or transfer to another store via memory_import.

memory_import

Load a memory_export JSON file back into the store. Reports exactly what happened per row: inserted, skipped (malformed), or conflicted (id already existed — left alone under "skip", overwritten under "replace").

memory_list

List recent memory blocks for a role/scope, most-recent-first, with no keyword filter. Use to browse what has been written, not to search for something specific.

memory_prune

Force retention to run now with an explicit (or default-configured) age/count bound. memory_write already does this automatically after every insert — use this only to prune on demand with a tighter one-off bound.

memory_recall

Search memory blocks by keyword against their intent and content, most recent match first. Use when you remember roughly what a past block was about but not its id.

memory_write

Write a memory block: an intent, its content, which agent role wrote it, and whether it is private or shared with other agents. Runs bounded retention (age + count) after every write and reports what (if anything) it pruned.

anim_blueprint_add_state

Adds a state to an existing state machine in an animation blueprint. It cannot create the state machine itself — that still needs the AnimGraph editor — so on a blueprint with none it answers 'state machine not found', which is a missing prerequisite rather than a bad request. Compile with anim_blueprint_compile afterwards.

anim_blueprint_add_transition

Wires one state to another. The transition is created with no rule, which means it is always taken — pair it with anim_blueprint_set_condition unless you actually want an unconditional transition. Pass state_machine_name when two state machines might share a state name.

anim_blueprint_compile

Compiles an ANIMATION blueprint (ABP) — the animation state-machine asset, not an ordinary class. Reports the compiler errors and warnings. Every anim_blueprint_* write leaves the asset needing this, and an uncompiled ABP keeps running its previously generated class, so state-machine edits look like they did nothing.

anim_blueprint_get_info

Reads an animation blueprint's state machines, their states and transitions, and its variables. Call it before any of the anim_blueprint_* writers: they address a state machine BY NAME, and this is the only way to learn the names — a freshly created anim blueprint has none at all.

anim_blueprint_set_condition

Sets the rule on an existing transition, identified either by its id or by the pair of states it joins. A transition with no rule fires immediately, so this is what turns a wired-up state machine into one that behaves. Compile afterwards to find out whether the expression resolved.

asset_browse

Plugin command. hayba_invoke passes it straight to the editor plugin. Also answers to describe_assets.

Alias of describe_assets — the agent-friendly name surfaced as the hayba_asset_browse routing tool.

asset_search

Plugin command. hayba_invoke passes it straight to the editor plugin.

Find assets by path, name substring or class, optionally with thumbnails. The general 'what exists in this project' query — start here when you need an asset path and only know roughly what it is.

describe_assets

Plugin command. hayba_invoke passes it straight to the editor plugin. Also answers to asset_browse.

Wrapped indirectly by the asset-retriever (src/tools/asset-retriever/asset-indexer.ts) which dispatches describe_assets and falls back to list_pcg_assets on unknown_command. Game-thread marshaled.

hayba_ambientcg_download

Download an ambientCG material zip and import into UE.

hayba_ambientcg_search

Search ambientCG for CC0 PBR materials, decals, or 3D models.

hayba_asset_browse

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Enumerate assets by filter (path/class/tag/source) without semantic ranking. Paginated.

hayba_asset_reindex

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Force a rebuild of the asset index. Use after a batch import outside the MCP-tracked download flow.

No parameters.

hayba_asset_search

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Find an asset in the user's UE Content Browser by semantic intent or keyword. Hybrid BM25 + embedding search.

hayba_polyhaven_download

Download a Poly Haven asset (HDRI / texture maps / glTF model) and import into UE.

hayba_polyhaven_search

Search Poly Haven for CC0 HDRIs, textures, or models.

hayba_sketchfab_download

Download a Sketchfab model and import into UE. Requires SKETCHFAB_API_TOKEN env var.

hayba_sketchfab_search

Search Sketchfab for downloadable 3D models. Requires SKETCHFAB_API_TOKEN env var.

asset_create_folder

Create a Content Browser folder (make_directory). Idempotent: a no-op that reports already_existed:true when the folder is already present. Use before authoring/importing assets into a new path.

asset_delete

Permanently delete content assets, verifying on the FILESYSTEM that each file is gone. Pass `paths` to delete a set in one call. READ deleted_count, not requested — it counts .uasset files actually removed. NEVER verify a delete with does_asset_exist or asset_search: the asset registry can report an asset gone while its file is still on disk, and that is exactly how a batch delete reports success for files it never removed. Assets the registry has lost but whose files remain are reported as ORPHANED and must be removed from disk directly.

asset_duplicate

Copy an asset to a new path. Use this to derive a variant rather than editing the original in place.

asset_fix_redirectors

Collapse the redirector stubs left behind by renames and moves. USE_WHEN: after a batch of asset_rename / asset_move calls — redirectors that survive into a cook are wasted work and confuse later reference lookups.

asset_get_dependencies

What this asset pulls in — everything that must exist for it to load. USE_WHEN: working out why an asset drags in a large cook, or what to migrate alongside it. NOT_WHEN: you want what depends on IT (asset_get_referencers).

asset_get_info

Read one asset's metadata (class, path, size, optional thumbnail) by exact path. Use asset_search when you do not yet know the path.

asset_get_referencers

WHAT BREAKS IF I DELETE OR RENAME THIS? Lists every asset that references the given one. USE_WHEN: before asset_delete, asset_rename or asset_move — a reference you did not know about becomes a broken link that surfaces much later. NOT_WHEN: you want what the asset itself needs (asset_get_dependencies).

asset_get_references

Both directions of an asset reference graph in one call. Note the lists may be truncated — `capped: true` says so. Prefer the single-direction tools when you need an exact count.

asset_get_source_path

Read an imported asset's reimport source-file path(s) from its AssetImportData — the "where did this come from on disk" question, ahead of a reimport or a broken-source fixup. Probes get_first_filename / extract_filenames / source_data across asset types; returns source_paths:[] when the asset carries no import data (procedural/native assets).

asset_import

Fail-closed, single-file native import. It pins the fixed connector-cache ancestor/file handles, enforces kind-specific size+magic policy and an exact factory, refuses collisions/overwrite, then discards callback-returned UObject pointers and re-resolves the exact registry path/class/package. Successful imports are normally dirty_in_memory: follow with asset_save on the returned exact path. These checks reduce exposure but do NOT prove crafted files safe for an in-process UE parser; untrusted remote files still require an isolated sanitizer. Future connector continuation additionally requires an opaque single-use grant bound to one enumerated file; directory assertions are not authority.

asset_inspect

AssetRegistry metadata for one asset: class, dirty flag, dependency/referencer counts. Read before edit/delete to avoid surprises. Differs from the legacy asset_get_info (C++-backed single-asset info, may see engine-only fields) and from asset_registry_query (bulk discovery/pagination) — use this when you already know the asset path and want its dependency graph. Optional preparation_policy adds evidence and requested/resolved preparation decisions without mutation.

asset_move

Move an asset to another folder, keeping references working. Leaves a redirector behind; asset_fix_redirectors cleans those up.

asset_open_editor

Open the asset editor tab(s) for one or more assets (AssetEditorSubsystem.open_editor_for_assets) — pure UI focus, surfaces the asset for the user. Reports which paths were missing.

asset_prepare

Inspect and apply supported StaticMesh preparation policies, retaining partial work and unsupported capability results.

asset_registry_query

Native read-only AssetRegistry query by exact class, asset-name substring, and/or content-path prefix, with deterministic pagination.

asset_rename

Rename an asset in place, fixing up references rather than breaking them. Leaves a redirector behind; asset_fix_redirectors cleans those up. USE_WHEN: the name is wrong. NOT_WHEN: it belongs in another folder (asset_move).

asset_save

Save dirty packages to disk. With asset_paths: saves each (only if dirty) and reports per-asset success — ok:false when ANY named path fails to save (surfaced in failed[] + warnings[]). Without: flushes ALL dirty map+content packages in one call. The write counterpart to editor_get_state's dirty_packages read. Idempotent (re-saving unchanged bytes is a no-op).

asset_validate

Run the editor data-validation rules over an asset or folder and return the errors and warnings. USE_WHEN: confirming an asset is sound before building on it. NOT_WHEN: checking UI layout — ui_validate is the tool for that.

content_browser_sync

Reveal + select assets in the Content Browser (UI focus). Probes sync_browser_to_objects then the AssetTools fallback; degrades to a structured error if neither exists.

content_validate

CHECK PROJECT CONTENT AGAINST MEMORY AND PERFORMANCE BUDGETS: oversized textures, compression that contradicts the asset name, non-power-of-two dimensions, UI textures outside the UI group, meshes with no LODs, excessive material slots, unreferenced meshes. Judged per strictness (relaxed/standard/strict) with every threshold justified in the hint. Reports what it did NOT examine — the audits only cover the heaviest N assets, so a clean result is scoped, never a claim about the whole project. NOT_WHEN: checking a UI screen (ui_validate).

data_create

Create and persist a concrete, current UDataAsset subclass after bounded path/name/class preflight. MarkPackageDirty and SaveLoadedAsset are callback boundaries: no raw creation pointer crosses either one, and the target path/class is freshly re-resolved before save and again afterward. Inspect ok, dirty_marked, pre_save_re_resolved, save_attempted, saved (present only when attempted), target_re_resolved, and dirty_known. If any identity, dirty-mark, save, or final readback fact is not trustworthy, nested ok:false plus data_create_unknown_outcome makes the top-level response unknown_outcome; query the exact path before retrying.

data_get

Read a bounded property snapshot from a DataAsset. Always inspect reflection_complete, reflection_truncated, properties_omitted_at_least, unsupported_values, and large_integers_as_strings before treating it as complete. Set/map item counts and physical sparse-slot ranges are both capped before iteration, so a small live count cannot hide an unbounded hole scan. Integers outside the exact JSON-number range are decimal strings, never rounded. Soft, weak, lazy, and soft-class wrapper references are reported unsupported/partial instead of falsely serializing an unloaded non-null path as null. Properties with native getters or setters are also unsupported/partial: raw bytes may not be their logical value, and invoking an accessor would execute unaudited code.

data_set

Write one bounded scalar property on a DataAsset by name, then inspect copy_completed, ok, verified, target_re_resolved, dirty_marked, dirty_known, dirty (when known), and observed_value or observed_value_omitted. Only exact built-in numeric, enum, bool, string, and name property classes without native getters/setters are accepted and assigned through direct typed setters; JsonValueToUProperty and ImportText are never entered. Fixed arrays, dynamic containers, structs (including user-defined structs), wrapper/object references, interfaces, delegates, optionals, text, field paths, SkipSerialization fields, accessor-backed fields, custom property subclasses, and every other extensible type are refused before staging. Staging and all property pointers end before dirty notification; the command then re-resolves the target/class/property and repeats the accessor/schema gate before fresh bounded readback. It deliberately skips transactions, UObject editor hooks, and persistence. save_requested is always false. If any final identity/verification/dirty fact is untrustworthy, nested ok:false plus stable error makes the top-level response unknown_outcome with mandatory readback; ErrorsOnly cannot hide it.

audio_active_sounds

Inspect live active sounds and physical voice usage from the main audio device, including component ids, asset paths, effective volume/pitch, looping, pause, virtualization/audibility, owner, and managed-component count.

audio_asset_create

Create an unsaved SoundClass, SoundMix, SoundConcurrency, SoundAttenuation, or SoundSubmix asset at an explicit /Game path. Returns the canonical path and full default readback; call audio_asset_set, then audio_asset_save as the persistence boundary.

audio_asset_inspect

Inspect one SoundClass, SoundMix (including class overrides), SoundConcurrency, SoundAttenuation, SoundSubmix, or SoundWave using a stable typed settings vocabulary.

audio_asset_save

Explicitly save one supported audio settings asset and verify its .uasset exists on disk. Single-target by design so a failure cannot hide partial batch persistence.

audio_asset_set

Set typed audio asset settings in memory with changed/unchanged key diagnostics and complete typed readback. The actual target class controls which documented keys are legal; incompatible or unknown keys fail before mutation. This command never saves implicitly.

audio_component_control

Control a retained AudioComponent: play/stop/pause/resume, fade, set gain/pitch, reset parameters, or set typed MetaSound/SoundCue parameters. Returns live component readback; expired ids fail cleanly.

audio_component_play

Play a 2D USoundBase through a retained, non-auto-destroy AudioComponent and return a stable component id plus live play-state readback. Fails if the component never becomes active.

audio_list

Enumerate USoundBase assets (waves, cues, MetaSound sources) from the asset registry, including subclasses, without loading them. Duration and sample rate come from registry tags, so they are present for most assets but not guaranteed — a missing key means untagged, not zero.

audio_meter_read

Read linear magnitude, dB magnitude, and phase at explicit frequencies from a previously started master/submix analyzer. Empty or unavailable spectral data is an error, never a zero-filled success claim.

audio_meter_start

Start Audio Mixer FFT analysis on the master output or one SoundSubmix. Explicit lifecycle: start once, read one or more times, then stop.

audio_meter_stop

Stop a master/submix FFT analyzer that Hayba started. Fails if that target has no tracked analyzer.

audio_play

Play a sound 2D through a retained AudioComponent. Fails unless the component becomes active and returns component_id plus live play-state/volume/pitch readback. Prefer audio_component_play for the fully typed first-class schema.

audio_recording_start

Start in-memory Audio Mixer capture of the master output or one SoundSubmix. The matching stop command performs a synchronous, filesystem-verified WAV write.

audio_recording_stop

Stop a tracked master/submix capture and synchronously write a WAV beneath Saved/BouncedWavFiles. Returns the verified absolute path, sample count, channel count, sample rate, and duration; zero samples or an absent file is an error.

audio_set_volume

Sets the transient primary volume on the main audio device — the master bus, and only that. Use audio_asset_create/set/save with SoundClass and SoundMix assets for category routing. The change is transient and does not persist.

test_cancel

Cancels only the tagged UnrealEditor-Cmd child owned by the matching active test_run job. It never enumerates or terminates arbitrary editor processes.

test_get_log

Full entries (errors + warnings) from the last test_run, not just the pass/fail counts. Read this when a test failed and you need the actual assertion text rather than a tally.

No parameters.

test_list

Enumerate registered automation tests via FAutomationTestFramework directly (no controller/session-frontend needed). Name-substring filtering: pass filter_pattern (or its alias filter); the response echoes the applied filter so a dropped param is visible.

test_run

JOB ENVELOPE (async, non-freezing): unknown project, engine, plugin, and future Hayba tests default to a tagged owned UnrealEditor-Cmd child. Only exact lifecycle-audited pure Hayba contracts use the serving editor's core ticker. Empty or unmatched selections fail closed instead of producing a false green. Poll build_status for structured counts plus execution_mode, child PID/token, exit code, report validity, crash, timeout, cancellation, output-bound, and crash-artifact-count evidence. A crash or never-started child is failed, never skipped. Only one run may be active.

bt_add_node

Adds one node to a behavior tree. Build a tree root-first: a composite with no parent_guid becomes the root, then tasks and further composites hang off it by guid. The kind/class mismatch checks are strict on purpose, since a decorator quietly added as a task is the kind of thing you only notice when the AI misbehaves. Marks the asset dirty; asset_save to keep it.

bt_compile

Compiles the tree and reports what the compiler said. Read the warnings, not just ok: a tree with no blackboard asset compiles successfully and then does nothing useful at runtime, and that case is reported as a warning rather than an error.

bt_connect

Re-parents an existing node under a composite. It refuses to connect a node to itself and refuses an edge that would make a cycle, so a tree cannot be wired into one that never terminates. Ordering among siblings is the order children were added, and that order is execution order for a Selector or Sequence.

bt_get_info

Reads a behavior tree's whole node graph plus its blackboard keys. Call it first: bt_add_node and bt_connect address nodes by the guids this returns, and those guids come from node object paths rather than being stored, so they stay valid between calls without any bookkeeping on your side.

blueprint_add_bound_event

Plugin command. hayba_invoke passes it straight to the editor plugin.

Binds a widget or component event (Button OnClicked, a collision overlap) as an event node — the Details panel's '+' next to an event. Idempotent. Exposed to agents as ui_bind_event; kept agent_callable so hayba_invoke can reach component events too.

blueprint_add_component

Add a component of a given class to a Blueprint's component tree. Changes are staged — blueprint_compile applies them, and nothing takes effect in the level until it does.

blueprint_add_custom_event

Adds a custom event to a blueprint's event graph: a named entry point that timers, other blueprints and the blueprint itself can call. Wire its OutputDelegate pin into a Set Timer by Event node to run it on a timer. Staged until blueprint_compile.

blueprint_add_event

Adds (or returns the existing) override event node such as BeginPlay, Tick, EndPlay, or a widget's Construct/PreConstruct — the entry points a Blueprint starts from. Idempotent: a second call returns the node already there.

blueprint_add_function

Adds a function graph to a blueprint, with an optional signature (inputs, outputs, pure), and recompiles. Every parameter type is checked before the graph is created, so a bad type refuses the whole function rather than leaving a half-built one. Build the body with blueprint_add_node using graph_name = the function name.

blueprint_add_node

Stages a standard event-graph node and returns its GUID plus exact pins. timer_by_function creates K2_SetTimer; set its Object, FunctionName, Time and Looping pins before compile. For entry points use blueprint_add_event (BeginPlay, Construct), blueprint_add_custom_event, or ui_bind_event (widget events).

blueprint_add_variable

Add a member variable to a Blueprint and recompile. Object, class and struct references are resolved when added, so a mistyped path is refused with the path in the message instead of compiling into a broken pin. Refuses a name the blueprint already has.

blueprint_compile

Compile a Blueprint and report errors. Every blueprint_* edit is staged until this runs, so call it before expecting a change to exist — and read `errors`, because a failed compile leaves the old class in place. With save true, a read-only package is refused before compiling with code package_read_only and data.make_writable_hint; nothing changes. Take the file's lock and retry, or pass save:false.

blueprint_connect_nodes

Wires exec or data pins using GUIDs and exact pin names from blueprint_inspect_graph/add_node. The K2 schema rejects invalid type or direction connections.

blueprint_create

package_path is the full intended asset path (trailing component = asset name), matching material_create. The handler derives the directory via FPackageName::GetLongPackagePath and re-composes <dir>/<name> so the asset lands at the standard /Game/Dir/Name.Name. A parent of /Script/Engine.BlueprintFunctionLibrary creates a real function library (static functions callable from any blueprint); check blueprint_type in the reply.

blueprint_document

Renders a blueprint's EVENT GRAPH as pseudo-English — a fast way to see what a blueprint reacts to without opening it. It covers events only: user-defined function graphs do not appear, so a blueprint documented as three bare events may still have functions. Use blueprint_get_info for structure.

blueprint_get_info

List a Blueprint's components. The read step before blueprint_add_component (to avoid a duplicate name) or object_set_property (which needs the component name).

blueprint_inspect_graph

Read-only exact graph export. Returns stable node GUIDs, pin names/directions/types, every edge, counts, and dirty state. Use this before adding or wiring nodes.

blueprint_remove_node

Deletes one node (and its links) from a blueprint graph, for taking back a node placed wrong. Refuses a function's entry or result node, which the function cannot exist without. Staged until blueprint_compile.

blueprint_set_defaults

Set default property values on a Blueprint's class defaults, so every future instance starts with them. Does NOT change actors already placed in the level.

blueprint_set_pin_default

Sets a literal or object/class reference on an unconnected input pin. Refuses connected pins so values are never silently ignored.

build_cook

JOB ENVELOPE (async, non-freezing): runs UnrealEditor-Cmd -run=cook on a background thread and returns { job_id, status:'running' } IMMEDIATELY. Poll build_status { job_id } for { status:'done', exit_code, output }, or watch hayba_journal_tail.

build_generate_project_files

JOB ENVELOPE (async, non-freezing): runs RunUAT GenerateProjectFiles on a background thread and returns { job_id, status:'running' } IMMEDIATELY. Poll build_status { job_id } for { status:'done', exit_code, output }.

No parameters.

build_project

JOB ENVELOPE (async, non-freezing): invokes UnrealBuildTool.exe on a background thread and returns { job_id, status:'running' } IMMEDIATELY — never blocks the editor (the old version blocked the game thread up to 5min). Poll build_status { job_id } for { status:'done', exit_code, output (log tail) }, or watch hayba_journal_tail for live build_job:<id> progress.

build_status

Reader for the async job registry shared by build_project / build_cook / build_generate_project_files / test_run. Reads the job entry under its lock by job_id and returns its current status/result. Test jobs expose untruncated scalar pass/fail/skip totals plus a structured test_results object; malformed test results fail closed. Poll this after a build_* / test_run call returns { job_id, status:'running' }.

editor_batch

Run several editor commands in order under one lease, one step per editor tick, with a fence after each (wait for shaders/asset loads/GC/async loading to settle; gc also collects garbage under an exclusive region/world lease). Returns {job_id} at once; follow it with batch_status. Steps may be wp_region_load {bounds:[minX,minY,maxX,maxY], name?} / wp_region_unload {name?}: the batch owns those World Partition regions and always releases them by the end. Other agents' queued interactive lease requests are served at fences. The batch keeps its own lease alive and runs to the end of its steps even if this server disconnects.

editor_capture_viewport

Capture the active editor viewport and return it as an inline image block (plus a small text block with camera/width/height). Set HAYBA_CAPTURE_TO_FILE to also spill the image to a temp file path.

editor_cvar_get

Typed read of a console variable (int/float/bool) via KismetSystemLibrary getters. CAVEAT: UE's typed getters return type-defaults (0/0.0/False) for an unknown or mistyped cvar name, indistinguishable from a real zero value — this tool probes existence via the string getter when available and reports verified:false (plus a note) whenever the value cannot be confirmed real; treat verified:false as "do not trust this value". type defaults to float when omitted, with type_assumed:true in the response. NOT a freeform console runner — use editor_run_console_command for that.

editor_cvar_set

Typed set of a console variable, with a float read-back of the applied value. CAVEAT: the float readback returns 0.0 for a nonexistent cvar, indistinguishable from a real set-to-0 — this tool also probes the string getter (when available on this engine build) and returns ok:false + verified:false + a note when the readback proves the cvar does not exist (mistyped name). When no existence probe is available it stays ok:true with verified:false. Idempotent (retry-safe). NOT a freeform console runner — use editor_run_console_command for arbitrary commands.

editor_focus_actor

Frame an actor in the editor viewport by label — computes camera position from the actor's bounds and aims at its centre, entirely in C++. Roll is always 0 so the view never tilts. This is the correct 'framing tool'; do NOT hand-compute camera angles in python_run.

editor_get_camera

Read the active editor viewport camera location + rotation. Net-new read counterpart to the legacy editor_set_camera. Rotation is [roll,pitch,yaw] degrees.

No parameters.

editor_get_output_log

Read the editor's output log, filtered by severity or regex and paged with since_line. The first thing to check when a command reported success but nothing happened — UE logs the real reason here.

editor_get_performance_stats

Editor frame timing: average fps, frame time, and the two thread times. These are whole-editor averages, not a profile of one operation — an idle editor with a compile running reads badly and that is not a scene problem. The thread times are cycle counters converted through FPlatformTime::ToMilliseconds; they were previously emitted RAW under _ms names, so every reading of those two fields used to be wrong by the platform cycle factor.

No parameters.

editor_get_state

One-shot consolidated native editor status: current map, who owns PIE (pie: none | user | agent:<owner>) and its phase, selected-actor count, Live Coding / shader / save activity, asset builds in progress, editor health, and the dirty (unsaved) package list (include_dirty:false skips that walk). The master gating probe before any action loop; after a pie_active refusal, poll it until pie is "none".

editor_live_compile

Triggers a Live Coding compile of the running editor. It is asynchronous: poll the editor log for 'Live coding succeeded' or 'LogLiveCoding: Error', matching on a COUNT of terminal lines rather than presence, because earlier runs are still in the file. Compile ERRORS are not in the editor log at all — they are in UnrealBuildTool\Log.txt. A brand-new handler CLASS still needs a full editor restart; Live Coding cannot register one.

No parameters.

editor_pie_actor_inspect

INSPECT ONE LIVE PIE ACTOR without touching editor-world state: transform, bounds, tags, owner and a capped/paginated list of owned components with visibility, collision and component-space evidence. USE_WHEN: understanding a runtime road, controller, pawn or interaction target found by editor_pie_actor_list. Read-only.

editor_pie_actor_list

WHAT EXISTS IN THE RUNNING WORLD: paginated runtime actors from the selected PIE client/server, with exact path, class and transform. USE_WHEN: finding roads, controllers, interactable actors or spawned state while PIE runs. NOT_WHEN: querying the editor MainMenu world (actor_list). Use the returned actor_path for unambiguous follow-up calls.

editor_pie_assert

Assert a UPROPERTY on a PIE actor holds a value. It is ONE OBSERVATION, not a wait: a command handler runs on the game thread, so it cannot advance the world, and a property it watches can never change while it blocks — an earlier version that pumped the ticker to fake waiting is what crashed the editor. So a false `matched` with `polling:true` means 'not yet', and the caller loops. Read observed_value_last before assuming the property is wrong; it is often the expectation that is.

editor_pie_axis

Send analog input — gamepad sticks and triggers, mouse axes. Applies for the frame it is delivered, so send it again per step for sustained movement rather than expecting it to latch.

editor_pie_capture_get

Read progress or the final whole-editor timing summary for a PIE capture. Reports aborted status if PIE stops or the selected world changes. If the editor becomes unsafe, the safety gate refuses this command, so an internal abort cannot be retrieved. GPU time, real WP cells, and NPC AI cost remain explicitly unknown.

editor_pie_capture_start

Start a bounded asynchronous capture of observed editor ticker intervals, whole-editor thread timing, and process physical memory during an already-running PIE session. Returns a capture_id immediately; poll editor_pie_capture_get. Ticker intervals are a whole-editor proxy and the result gives no performance verdict.

editor_pie_click_actor

CLICK AN EXACT LIVE PIE ACTOR WITHOUT OS INPUT. Reuses the world-projection safety seam, rejects Slate/UMG and Canvas HUD blockers, and repeatedly verifies the canonical local player and first Visibility hit. It dispatches the exact native primitive stage used by APlayerController only after its complete guard state is proven, avoiding InputKey's unchecked re-entrant trace window and all synthetic mouse routes. Hover fails closed because UE exposes no public route that preserves native hover state while guaranteeing zero OS cursor movement. Fails closed for ambiguous clients, absent/hidden/minimized viewports, offscreen/hidden/occluded actors, policy changes and active gestures. USE_WHEN: selecting a road, unit or world actor in background automation with a live visible PIE viewport. NOT_WHEN: hovering, truly headless/NullRHI PIE, or clicking UI controls (editor_pie_click_widget).

editor_pie_click_widget

CLICK A CONTROL BY WHAT IT SAYS rather than by pixel. Finds the widget whose text, tag or type matches and clicks its centre, preferring an interactive one so matching a label presses the button containing it. Reports how many matched, so an ambiguous choice is visible instead of silent. USE_WHEN: pressing menu buttons. NOT_WHEN: you need an exact position.

editor_pie_mouse

Drive the mouse in the running game: move, click, double_click, press, release, drag or scroll. press/release let you hold a button across calls; drag interpolates intermediate positions because widgets that track deltas ignore a single jump. x/y are ABSOLUTE desktop pixels — pass center_x/center_y from editor_pie_widget_tree straight through. Check focused_widget_after: if it says SViewport, the click missed the UI. PREFER editor_pie_click_widget when you know the label.

editor_pie_press_key

Press a keyboard or gamepad button in the running game. pressed_and_released schedules the release on a later tick and RETURNS IMMEDIATELY — the key is still down when you read the result, which is what lets the game see the hold at all.

editor_pie_project_world

PROJECT A LIVE WORLD TARGET TO A VERIFIED CLICK CANDIDATE. Accepts an actor, owned scene component or [x,y,z]. absolute.available and x/y are present only when the point is on-screen, its PIE window is visible/not minimized, and Slate finds no UMG/modal obstruction. For actor/component clicks require target_click_ready:true too; it combines that Slate proof with the first world Visibility hit. USE_WHEN: diagnosing or clicking a road, unit or world-space target without OS input against a live visible PIE viewport.

editor_pie_screenshot

Capture the running game. Requests the shot and returns immediately; the engine writes the file a frame or two later, so poll with check_only:true and the same filename rather than assuming it is ready. NOT_WHEN: capturing the editor viewport outside PIE (editor_capture_viewport).

editor_pie_set_text

Put a value straight into a text field and tell the game about it. PREFER THIS over editor_pie_type_text when you just need to get past a field — typed characters go wherever focus happens to be, can be eaten by a modal, and are lost if focus moves before the widget commits. Find the field by the text ON it (the placeholder counts, so an empty login box matches "Username"), or omit match to use the focused field. Returns readback+verified, so you know the value is actually in the box. USE_WHEN: filling a login/search/name field. NOT_WHEN: you are testing how the game itself handles keystrokes.

editor_pie_sightlines

Observe collision sightlines in live PIE. Tests 1-32 explicit eye positions against one target point with one ECC_Visibility trace per sample (maximum 100 m each). Returns clear, blocked with first blocker, or unknown, plus clear/tested ratio. This is a collision sightline proxy, not rendered visibility, walkability, World Partition residency, or performance. Read-only; multiple live PIE worlds require pie_instance.

editor_pie_type_text

Type a string into the running game as character input, which is what text fields actually consume. Goes to whatever holds keyboard focus — click the field first. Read characters_accepted_by_ui, NOT characters_sent: the first says the text landed in a widget, the second only says it was sent. USE_WHEN: filling in a name or search box. NOT_WHEN: a single control key like Enter (editor_pie_press_key).

editor_pie_wait_for

The polling half of a PIE wait: one observation of a property, with `polling:true` when the condition is not met yet, so the caller can loop until it is or until it gives up. It does NOT block for you — the handler occupies the game thread it would need to advance, which is the reason the previous blocking version had to be removed. Same shape as editor_pie_assert; use this name when you intend to loop and that one when you intend a single check.

editor_pie_widget_tree

WHAT IS ON SCREEN RIGHT NOW in the running game: every visible Slate/UMG widget with its type, text and on-screen rectangle. USE_WHEN: before interacting — this is how you find a button instead of guessing coordinates. NOT_WHEN: inspecting a Widget Blueprint asset rather than the live screen (ui_query).

editor_run_console_command

Run an editor console command (stat unit, r.* toggles, LiveCoding.Compile, etc). Arbitrary console access, so it is gated by Plan Mode. Effects are reported by the console, not returned — check editor_get_output_log.

editor_save_all_and_quit

Save every unsaved package, then shut the editor down — in that order. Shutting down with a dirty asset parks the editor on a modal save prompt that nothing can answer, because the MCP port closes first; three editor deaths in one session each cost exactly the assets still unsaved. REFUSES to quit if anything is still dirty after the save pass, and names what is holding it up. Pass quit:false to save everything without shutting down. USE_WHEN: ending a session, or closing the editor to link C++. NOT_WHEN: you only want to save (asset_save).

editor_set_camera

Position the editor viewport camera for deterministic captures. To AIM it, prefer look_at:[x,y,z] (orientation computed for you, never tilts). Manual rotation is UE FRotator (pitch/yaw/roll), NOT xyz-euler. To simply frame an actor, use editor_focus_actor instead.

editor_set_viewport_mode

Switches the active editor viewport's view mode — wireframe to read geometry density, shader_complexity to find expensive materials, unlit to judge albedo without lighting. This changes what a HUMAN is looking at and does not change back on its own, so put it back to lit when you are done rather than leaving someone else's viewport in wireframe.

editor_start_pie

Start Play-In-Editor.

editor_stop_pie

Stop the running Play-In-Editor session and return whether one was running. Call it before editor-only operations: many asset and level edits are unsafe or refused while PIE is live.

No parameters.

editor_stream_log

Tail recent UE log lines (paged via since_line).

outliner_tree

Paginated world outliner: level actors with label, class, folder, and attachment parent — the agent's map of the level without dumping the whole world. Folder filters include descendants.

render_camera

Render a camera view to disk and VERIFY the file landed (magic bytes + dimensions). Accepts either an actor reference or an inline transform. Calls wait_for_idle internally before capture.

selection_get

Full editor selection probe: selected level actors, content-browser assets, and selected components. Broader than actor_get_selection (adds assets + components) — the context probe for "apply to selection" tools.

No parameters.

wait_for_idle

Wait for UE subsystems (shaders/assets/gc/pcg/world_tick) to settle before reading back or rendering. Default = shaders+assets+gc+pcg.

wait_for_shaders

Wait for UE shader compilation to settle (or timeout). Thin wrapper around wait_for_idle({subsystems:["shaders"]}).

input_add_mapping

Binds a key to an action inside a mapping context, optionally with modifiers and triggers. A modifier or trigger class name it cannot resolve is reported under unresolved_classes rather than silently skipped — so a reply listing fewer modifiers than you asked for is telling you something. Marks the context dirty; asset_save to keep it.

input_create_action

Creates an Enhanced Input UInputAction — the 'what the player did' half of the system, independent of which key does it. Pick value_type by the shape of the input: Boolean for a press, Axis1D for a trigger, Axis2D for a stick. The asset is created dirty and unsaved; call asset_save to keep it. An existing name is an explicit error, because letting the engine ask would raise a modal dialog and hang every queued command.

input_create_mapping

Creates an empty UInputMappingContext — the 'which keys, in this situation' half of Enhanced Input. A context is what gets pushed and popped as the player moves between menus, driving and walking. Fill it with input_add_mapping. Created dirty and unsaved; asset_save to keep it.

foliage_add_instance

Place one foliage instance at an exact transform. USE_WHEN: precise single placement. NOT_WHEN: covering an area — foliage_paint_at scatters at a density instead.

foliage_add_instances

Bulk-add explicit world transforms for a foliage type via EditorFoliageLibrary.add_instances, chunked to avoid a game-thread freeze — the direct authoring verb (fixes the historic silent C++ add stub). NON-IDEMPOTENT (append). UNCERTAIN-API: errors clearly when add_instances is not python-exposed.

foliage_capability_probe

Report which UE Python foliage bindings are available (EditorFoliageLibrary + add/get/remove instances, procedural-foliage, HISM, FoliageType_InstancedStaticMesh) plus the engine version and whether a Landscape/StaticMesh collision surface exists — the graceful-degradation gate to call BEFORE any scatter/author op.

No parameters.

foliage_clear_type

Remove ALL instances of a foliage type from the level (destructive, one-undo, requires confirm:true). NON-IDEMPOTENT. UNCERTAIN-API: routes through EditorFoliageLibrary.remove_instances with a null box (all-instances) and errors clearly when unavailable.

foliage_get_instance_count

Return the number of placed instances of a foliage type across the level — the cheapest read to verify a scatter/add/remove landed. UNCERTAIN-API: degrades to null + a warning when instance introspection is not python-exposed.

foliage_list_types

List the FoliageType assets in use in the current level, with instance counts. USE_WHEN: before adding or removing foliage, to learn what is already there.

No parameters.

foliage_paint_at

Scatter foliage over a circular area at a density, as the foliage paint brush does. USE_WHEN: dressing terrain. NOT_WHEN: you need one instance at an exact spot.

foliage_remove_in_bounds

Remove instances of a foliage type inside an axis-aligned box (center + half-extent) and return the delta count. NON-IDEMPOTENT (delete). UNCERTAIN-API: EditorFoliageLibrary.remove_instances signature/box arg is probed and errors clearly when unavailable.

foliage_remove_instances

Remove foliage instances of a type inside a world-space box. Returns how many were removed, so an unexpected zero is visible rather than silent.

foliage_replace_mesh

Swap the StaticMesh bound to a FoliageType (bulk re-theming — every existing instance re-renders with the new mesh) and read the binding back. Set-to-value (retry-safe).

foliage_scan_types

Enumerate the foliage types used in the level (across all InstancedFoliageActors) with mesh path, density, radius and instance count. Paginated. The read entry point so agents stop guessing foliage type asset paths. UNCERTAIN-API: type enumeration is probed and degrades to [] + a warning.

foliage_scatter_paint

Deterministic area scatter: ground-trace downward onto landscape/collision inside a circular radius at a target density, with per-instance yaw + uniform-scale jitter and optional align-to-normal, then commit via add_instances. Refuses before UE transport above 10000 candidates; reduce radius/density or split into non-overlapping regions. Same seed to same placement. NON-IDEMPOTENT (append). This is the low-level authoring verb, NOT the PLUMB-validated world_generate flagship. UNCERTAIN-API: needs a collision surface (see foliage_capability_probe.surface_actors) and add_instances exposure.

foliage_type_create

Create (or reuse if present) a FoliageType_InstancedStaticMesh asset from a StaticMesh with optional initial density — the entry point for all foliage authoring. Reuses an existing asset at the path (retry-safe read-back) but is classified NON-IDEMPOTENT as an asset-create lifecycle op. UNCERTAIN-API: FoliageType factory/class is probed and errors clearly when not python-exposed.

foliage_type_inspect

Read every authored param of a single FoliageType (density, radius, scale X/Y/Z intervals, z-offset, align-to-normal, random-yaw, collision, cast-shadow, cull distance) plus mesh path and instance count — the paired read for verify/diff before a foliage_type_set_params write.

foliage_type_set_params

Set the core authoring knobs on a FoliageType — density, radius, scale range (X/Y/Z), align-to-normal, random-yaw, world collision, cast-shadow, and cull start/end — then save + read back which keys changed. Set-to-value (retry-safe); omitted fields untouched. UNCERTAIN-API: unknown property spellings land in unchanged_keys[] rather than being silently lost. Returns ok:false (with warnings[]) when NONE of the requested params applied.

gas_apply_effect

Needs the optional HaybaMCPGAS plugin in your project.

Applies a gameplay effect to an actor's ability system component, for checking that an effect does what you think before wiring it into gameplay. Refuses an actor without an ability system component by name. An Instant effect changes attributes and leaves no active handle behind, so an empty handle is not a failure.

gas_create_ability

Needs the optional HaybaMCPGAS plugin in your project.

Creates a UGameplayAbility blueprint. Lives in the optional HaybaMCPGAS satellite plugin, which auto-disables when the engine's GameplayAbilities plugin is off — so an Unknown command here means the satellite is not installed in this project, not that the command is missing. The ability is created empty; grant it to an actor with gas_grant_ability.

gas_create_effect

Needs the optional HaybaMCPGAS plugin in your project.

Creates a UGameplayEffect blueprint — the data asset that changes attributes, the unit GAS actually applies. duration_policy decides whether it fires once (Instant), ticks for a while (HasDuration) or persists until removed (Infinite). Part of the optional HaybaMCPGAS satellite.

gas_grant_ability

Needs the optional HaybaMCPGAS plugin in your project.

Grants an ability to an actor's ability system component. It refuses an actor with no UAbilitySystemComponent rather than silently doing nothing, and refuses an uncompiled ability blueprint (no class default object) — both verified live. Grants made in the editor world are editor state, not gameplay state.

hayba_dag_rebuild

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Re-run stale (dirty) artifacts. Optionally restrict to the subtree under a target URI.

hayba_dag_record

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Record a mutation Hayba did not instrument (editor-side edits, manual writes) so the DAG stays accurate.

hayba_dag_status

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Show the dependency graph of generated artifacts and which are stale (dirty).

hayba_journal_tail

Not callable through hayba_invoke. Load its pack with hayba_pack_load first.

Return the most recent mutation operations from the journal.

copilot_health

Cheap health snapshot for the copilot stack: sidecar chat routes registered, UE bridge reachable, tool registry size, and the active provider.

copilot_key_clear

Clear the stored BYOK API key for a provider. Destructive — plan-gated when Plan Mode is on.

copilot_key_set

Set the BYOK API key for a provider. The key is NEVER echoed back or logged — the response contains only a masked last-4. Stored in-memory (TODO Task 6: swaps to the C++ DPAPI vault).

copilot_key_status

Report, per provider, whether a BYOK key is configured (masked last-4 only, no network call).

copilot_model_list

Read the configured provider model catalog without model inference. Returns live-listed IDs and capability metadata when available; manual model IDs remain allowed.

copilot_provider_list

List the BYOK provider catalog, flagging which provider is active and whether a key is configured for it (masked last-4 only).

copilot_provider_set

Set the active BYOK provider (and optional model/base URL) for a copilot session.

copilot_provider_test

Preflight-check a BYOK provider: fails clean with {ok:false, reason:"no_key"} (no network call) if a key is required but absent; otherwise runs a minimal completion probe and reports latency.

ism_add_instance

Add ONE instance to an InstancedStaticMesh actor. For more than a handful use ism_add_instances instead — a per-instance round trip is the slow way to build a forest.

ism_add_instances

Plugin command. hayba_invoke passes it straight to the editor plugin.

Add up to 1000 instances to an InstancedStaticMesh actor in one call. This is how you place large repeated geometry (trees, rocks, crowd props) without one actor per item.

ism_clear_instances

Remove every instance from an InstancedStaticMesh actor, keeping the actor and its mesh. Use before re-scattering rather than deleting and respawning the actor.

ism_create_actor

Plugin command. hayba_invoke passes it straight to the editor plugin.

Spawn an actor whose root is an InstancedStaticMesh component named "ISM". This is the container ism_add_instances fills — create it once, then add instances in bulk rather than spawning an actor per item.

landscape_add_layer

Create (or reuse if present) a LandscapeLayerInfoObject asset for a named paint layer — the prerequisite for any painting. Reuses an existing asset at the path (retry-safe read-back), but is classified NON-IDEMPOTENT as an asset-create lifecycle op. UNCERTAIN-API: binding into the landscape material slot may require an editor rebuild.

landscape_get_material

Read the assigned landscape material and hole material asset paths.

landscape_import

Plugin command. hayba_invoke passes it straight to the editor plugin. Also answers to import_landscape.

Alias of import_landscape — the name discoverable in list_tool_categories under the 'pcg' domain. Wrapped by hayba_import_landscape (src/tools/index.ts uses this exact name as the dispatch target). See PR #229 for the game-thread marshal fix.

landscape_inspect

Deep brief of one landscape: component/subsection layout, XYZ scale, world bounds, material + hole material, paint layers with LayerInfo binding, streaming proxies, and a warnings[] list (missing layout/LayerInfo). The paired read for every landscape write op.

landscape_layer_list

List the paint layers on a landscape with their LayerInfo asset and whether a weightmap is bound — the read tool that exposes painting state before a paint/add-layer write. Includes a warnings[] list when both probes (get_target_layers/editor_layer_settings) return empty.

landscape_list

Enumerate all landscape actors + streaming proxies in the level with component layout, scale, material, world bounds and paint-layer count. Paginated. The read entry point so agents stop guessing landscape actor names.

landscape_list_splines

List the LandscapeSplinesComponents on a landscape with control-point and segment counts — read tool for spline-driven roads/rivers before editing.

landscape_set_lod_settings

Set landscape LOD distribution and/or scalability bias (set-to-value, retry-safe). Omitted fields are left unchanged. Returns the applied values + read-back.

landscape_set_material

Assign/swap the landscape material asset and read it back. Set-to-value (retry-safe). NOTE: after a material change with new layer slots, layer painting may need a rebuild; use landscape_inspect to check LayerInfo bindings.

landscape_set_nanite

Toggle the landscape enable_nanite property (set-to-value, retry-safe). Does NOT trigger the Nanite data rebuild (returns rebuild_needed:true). UNCERTAIN-API: the property exists in 5.x but the apply-build path is C++/pipeline.

batch_status

Progress or result of an editor_batch job: status running|succeeded|failed, phase, the step it is on, what a fence is waiting for, per-step results, loaded regions, yields to other agents. wait_s polls until done.

lease_acquire

Reserve part of the editor (world, World Partition region, asset, actor, PIE, or everything) so other agents do not change it mid-sequence. Never blocks: returns {status:"granted", lease_id} or {status:"queued", ticket, position, holder_owner, eta_s, poll_after_s}; poll by calling again with ticket. Granted leases are renewed automatically until lease_release.

lease_adopt

Make this connection act as the owner of a live lease: later commands that name no owner run as that owner, and the owner's orphaned connection-bound leases re-bind here. Needs lease_id and its owner. Connection adoption ends on close; repeat after reconnect. A confirmed adoption also switches this server's process-wide envelope owner and manual lease_id, which remain set across reconnects and unknown-id replies until explicitly changed. It does not start auto-renew or transfer existing renewal timers; renew or release the adopted lease yourself.

lease_release

Release a lease (lease_id), withdraw a queued ticket (ticket), or release everything you hold (all:true). Send exactly one. Other agents waiting on it can then be granted.

lease_renew

Extend leases you hold. With lease_id, that lease; with nothing, every lease you hold, which also revives leases the editor orphaned when this server's connection dropped. Rarely needed: leases granted by lease_acquire are renewed in the background.

lease_status

Who holds or waits for which editor resources, the enforcement mode (off / advisory / enforced_for_writes / enforced), the identified agents the editor sees as connected (active_owners), and which of your leases this server is renewing.

No parameters.

level_create

Create a new empty level asset. Does not open it — follow with level_load to switch the editor to it.

level_get_info

Name and actor count of the level currently open. The cheapest way to confirm which level you are actually editing before making changes.

No parameters.

level_goto_bookmark

Moves the editor viewport to a stored bookmark. This changes what a human is looking at, so it is not a neutral read — prefer editor_set_camera when you just need a viewpoint for a capture. NOT VERIFIED LIVE: described from the handler source.

level_list

List every level asset in the project. Use it to find the exact path level_load wants.

No parameters.

level_load

Open a level in the editor, replacing the current one. UNSAVED CHANGES IN THE CURRENT LEVEL ARE AT RISK — call level_save first.

level_save

Save the current level. Optional path is an expected current-level package guard, not Save As; a mismatch is refused before mutation. A map or external actor package requiring a save, including clean packages requiring transient-reference repair, is refused before mutation when its file is read-only (code package_read_only, data.make_writable_hint). Saving runs unattended and cannot open a modal dialog. Returns saved, path, dirty and verified readback for that package only, not external actor packages. Plan Mode gated; disk persistence is not undoable.

level_set_bookmark

Stores a named camera position in the current level so it can be returned to later. Bookmarks live in the LEVEL, so this dirties the map and persists only if the level is saved — do not use it as scratch state on a map someone else is working in. NOT VERIFIED LIVE: described from the handler source, because verifying it means dirtying a real level.

wp_get_cells

A spatial summary of where actors are: it bins every actor in the editor world onto a fixed 512m grid and reports per-bin counts and the classes that dominate each. These are NOT the World Partition runtime cells — cell ids and bounds will not match the partition's own, which is why the reply says cell_source. Requires World Partition to be enabled on the map; use it to find the busy regions before deciding where to look.

No parameters.

wp_get_streaming_state

Answers one question honestly: does the current editor world use World Partition. It previously also reported a hard-coded source_count of 0 — a field named for a measurement that always answers zero reads as "measured, none found", so it now names itself not_enumerated instead of inventing a number.

No parameters.

color_grading_set

Set cinematic color grading on a PostProcessVolume — white-balance temp/tint and global saturation/contrast/gamma/gain (each a Vector4 with alpha=1) — with the correct bOverride_* flags and the struct written back. Set-to-value (retry-safe). UNCERTAIN-API: Vector4 absence degrades a field to a warning + unchanged_keys[].

exposure_set

Set auto-exposure on a PostProcessVolume — method (manual/histogram/basic), EV bias, min/max EV100 — each with its bOverride_* flag set and the struct written back. The single most-asked PP knob as a focused verb. Set-to-value (retry-safe). UNCERTAIN-API: AutoExposureMethod enum absence degrades to a warning.

fog_configure

Configure an ExponentialHeightFog actor — density, height falloff, start distance, inscattering color, volumetric-fog toggle — on its fog component. Set-to-value (retry-safe); omitted fields untouched. UNCERTAIN-API: component/property spellings are probed and land in unchanged_keys[].

light_get

Read all key properties of a single light (intensity, color, temperature, attenuation radius, cast-shadows, mobility) — the paired read for verify/diff before a light_set write.

light_list

Enumerate every light actor in the level with its light component class and key properties (intensity, color, temperature, attenuation radius, cast-shadows, mobility). Paginated. The read entry point so agents tune lights from real values, not guesses.

light_set

Set core properties on an existing light — intensity, RGB color, color temperature (auto-enables use_temperature), attenuation radius, cast-shadows, mobility — then read back. Set-to-value (retry-safe); omitted fields untouched. UNCERTAIN-API: property spellings are probed and land in unchanged_keys[] rather than being silently lost.

light_spawn

Spawn a directional/point/spot/rect/sky light with optional intensity, color, temperature and mobility in one call — the primary way to lay down scene lighting. NON-IDEMPOTENT (actor-create). UNCERTAIN-API: the light actor class is probed and errors clearly when not python-exposed.

lighting_capability_probe

Report which UE Python lighting/post-process bindings are available (light actor classes, SkyAtmosphere, ExponentialHeightFog, PostProcessVolume, Lumen/reflection/auto-exposure enums) plus engine version, light-actor count and PPV count — the graceful-degradation gate to call BEFORE any spawn/set op.

No parameters.

lumen_configure

Enable/disable Lumen GI and reflections (false = None) and set final-gather quality + max-trace-distance on a PostProcessVolume, each with its bOverride_* flag and the struct written back — the headline UE5 lighting verb. Set-to-value (retry-safe). UNCERTAIN-API: Lumen enums are probed and their absence degrades to a warning.

postprocess_get

Read back PostProcessSettings values AND which bOverride_* flags are active on a PostProcessVolume (a value with its override false is inert) plus the Lumen GI / reflection / auto-exposure methods — the paired read so agents see what is actually overridden before a postprocess_set / lumen_configure / exposure_set write.

postprocess_list_volumes

Enumerate every PostProcessVolume in the level with unbound/priority/blend-weight/enabled — the read entry point so agents target the right volume (or discover none exists) before a postprocess_set / exposure_set / lumen_configure write.

No parameters.

postprocess_set

Set PostProcessSettings on a PostProcessVolume — bloom, vignette, film-grain, chromatic-aberration, motion-blur, ambient-occlusion, depth-of-field f-stop — with the correct bOverride_* flag set alongside each value (a value without its override is a silent no-op) and the whole settings struct written back. Set-to-value (retry-safe); omitted fields untouched. UNCERTAIN-API: a field whose value/override set fails lands in unchanged_keys[].

postprocess_spawn_volume

Spawn a PostProcessVolume (unbound/global by default, or box-bounded) with optional priority and blend-weight — the container every postprocess_set / exposure_set / lumen_configure / color_grading_set tweak targets. NON-IDEMPOTENT (actor-create). UNCERTAIN-API: PostProcessVolume class is probed and errors clearly when not python-exposed.

sky_setup

Spawn a complete daytime sky triad — SkyAtmosphere + SkyLight + a directional-light Sun — with an optional sun angle/intensity and skylight intensity in one call. NON-IDEMPOTENT (spawns three actors; re-running adds duplicates). UNCERTAIN-API: each class is probed and a missing one degrades to a warning while the rest still spawn.

material_add_comment

Add a titled comment box around a group of nodes in a material or function graph.

material_add_node

Add a new expression node to a material graph. For a MaterialFunctionCall, pass properties.function (asset path) — the node's inputs/outputs are rebuilt immediately (UpdateFromFunctionResource), so its output pins are wirable right away and are returned in outputs[]. No recompile/refresh dance needed.

material_add_reroute_declaration

Create a named-reroute declaration (source anchor) so a value can be referenced by name instead of long wires.

material_add_reroute_usage

Create a named-reroute usage bound to a declaration by name (replaces a long wire).

material_apply

Apply a material to an actor in the level (optionally specifying a material slot).

material_compile

Finalize a material OR material FUNCTION: write it to disk, apply staged settings, surface translator errors + shader optimization stats (materials). Graph edits DEFER the disk write — call this once the graph is complete. NOTE: material functions no longer auto-save either, so after editing a function call material_compile with function_path to persist it (this avoids a half-built function crashing the editor when it is opened/compiled).

material_connect_nodes

Connect two nodes in a material graph or connect a node output to a material property. IMPORTANT for multi-output sources (esp. MaterialFunctionCall): you MUST pick the output pin with from_output (the pin NAME) or from_output_index — otherwise the call is rejected, because defaulting to the first output silently swaps function outputs (e.g. Albedo and F0). Get the real pin names/order from material_get_info.expressions[].outputs[]. May return clutter-prevention suggestions: use named reroutes when a source fans out to 2+ targets, or a reroute knee node when a wire would run backward/over another node.