Every tool. Every system.

Search MetaSound node classes, ranked

Full pin schema of a MetaSound node

List MetaSound data types

List MetaSound interfaces

Create a MetaSound Source or Patch

Summarize a MetaSound asset

Read a MetaSound graph

Add a node to a MetaSound graph

Remove a MetaSound node

Wire two MetaSound nodes together

Clear a MetaSound node input

Set a literal on a MetaSound node input

Add an input to a MetaSound's interface

Add an output to a MetaSound's interface

Remove a graph input, output or variable

Set a graph input's default value

Declare a MetaSound graph variable

Add a get or set node for a variable

Add or remove a MetaSound interface

Build a whole MetaSound graph in one call

Re-position a MetaSound graph

Check a MetaSound for faults

List Sound Cue node classes

Create a Sound Cue

Read a Sound Cue's node tree

Add a node to a Sound Cue

Remove a Sound Cue node

Attach a Sound Cue child to a parent

Build a whole Sound Cue tree in one call

Every editable property of one Sound Cue node

Set any properties on a Sound Cue node

Re-position a Sound Cue node tree

Check a Sound Cue for faults

Export an audio asset's full state to JSON

List creatable audio asset classes

Create any audio asset by class name

Identity and hierarchy of an audio asset

Re-parent a Sound Submix

Re-parent a Sound Class

Set an audio effect chain

Rank Mutable node types against keywords (5.8+ only)

Describe Mutable node types, pins and properties (5.8+ only)

List the Mutable node palette categories (5.8+ only)

Create a new Customizable Object asset (5.8+ only)

Create a Customizable Object Instance (5.8+ only)

Read a Customizable Object's source graph (5.8+ only)

Read Mutable nodes by GUID (5.8+ only)

Add a node to a Customizable Object graph (5.8+ only)

Link two pins in a Customizable Object graph (5.8+ only)

Break links on a Customizable Object pin (5.8+ only)

Delete a node from a Customizable Object graph (5.8+ only)

Write node properties in a Customizable Object graph (5.8+ only)

Attach child Customizable Objects to a parent's Object Group (5.8+ only)

List the child Customizable Objects attached to a parent (5.8+ only)

Add a pin to a Mutable node that has an add-pin button (5.8+ only)

Build a whole Customizable Object graph in one call (5.8+ only)

Auto-arrange a Customizable Object graph (5.8+ only)

Compile a Customizable Object (5.8+ only)

Validate a Customizable Object and return a verdict (5.8+ only)

List a Customizable Object's parameters (5.8+ only)

Read parameter values off an instance (5.8+ only)

Write parameter values on an instance (5.8+ only)

Regenerate a Customizable Object Instance (5.8+ only)

Full JSON export of a Customizable Object (5.8+ only)

List a Customizable Object's states (5.8+ only)

Set the current state of an instance (5.8+ only)

Reset an instance's parameters to their defaults (5.8+ only)

Copy an instance's whole parameter state (5.8+ only)

Apply a copied parameter state to instances (5.8+ only)

Write Parameter UI Metadata on parameter nodes (5.8+ only)

Create a Customizable Object Macro Library (5.8+ only)

List a Macro Library's macros (5.8+ only)

Add macros to a Macro Library (5.8+ only)

Remove macros from a Macro Library (5.8+ only)

Declare a macro's inputs and outputs (5.8+ only)

Place a Macro Instance node in a graph (5.8+ only)

Create a new empty Control Rig Blueprint

Create a Control Rig and import a skeleton (any skeleton)

Import a skeleton's bones into an existing rig

Add a bone to the rig hierarchy

Add a null (space) to the rig hierarchy

Add an animation control of any type

Add a named curve element

Add a socket under a parent bone/null

Declare a connector on a Control Rig MODULE asset

Change an existing connector's type, flags or description

Add a connection rule restricting what a connector may bind to

List the connection rule types this engine ships

Create a Control Rig MODULE asset

Read a Control Rig's module identity and metadata

Write a module's identity and library metadata

Add an asset-level member variable to a Control Rig

Add MANY member variables to a Control Rig with a single compile

List a Control Rig's member variables and their config flags

Remove an asset-level member variable from a Control Rig

Add an animation channel under a control

Reparent an element

Update a control's settings (reflection)

Set a control's initial or current value

Move a control like dragging its gizmo (select + SetControlGlobalTransform + evaluate), report bones moved

Select/deselect rig elements through the engine controller

Set a control's offset transform

Set an element's transform

Remove an element from the rig hierarchy

Rename an element

Atomically build a whole hierarchy

Read the rig hierarchy as a tree

Read one element

List valid control + element types

Search RigVM graph node types

List registered RigVM template notations

Describe one or many RigVM node types' pins

Read a RigVM graph's nodes

Describe one RigVM node in a graph

Add a node to a RigVM graph

Connect an output pin to an input pin

Break a link, or all links on a pin

Set a node pin's default value

Set a RigVM node's position

Remove a node from a RigVM graph

Atomically build a RigVM graph

Auto-arrange a RigVM graph

Batch-set many node pin defaults in one call

List available gizmo shape names

Set a control's shape / color / visibility / gizmo transform

Gizmo gate, fails the rig when controls are unfitted, buried, or wrongly shaped

Size/orient control gizmos from the mesh's real skinned cross-section (no guessed scales)

Set a RigVM node's tint color

Set a RigVM node's size (comment/collapse boxes)

Set a comment node's text/font/bubble

Rename a RigVM node

Expand/collapse a struct/array pin

Toggle a pin's debug watch

Lock a wildcard/template pin to a concrete type

Set an array pin's element count

Add exec output pin(s) to a Sequence node so the graph can fan out

Bind a pin directly to a variable

Remove a pin's variable binding

Define a new function in the function library

Remove a library function

Rename a library function

Set a function public/private and/or pure/mutable

List library functions with their I/O

Place a call to a library function

Add an input/output pin to a function/collapse graph

Remove an input/output pin from a function/collapse graph

Rename an input/output pin on a function/collapse graph

Collapse nodes into a sub-graph

Expand a collapse/function node back inline

Promote collapse<->function

Add a graph-scoped local variable

Remove a graph-scoped local variable

List a graph's local variables

Reset a template node's pins to wildcard

Add a solve event node by friendly name

List every graph in the rig

Sample the live preview rig per frame

Per-bone jitter/motion statistics

THE physics alive-gate: shake a control, freeze it, measure residual jiggle

Per-bone residual jiggle after the driver stopped

Set an existing rig's preview skeletal mesh

Add a Rig Module to a Modular Rig

Bind a module connector to an element

Auto-resolve module connectors

List engine-valid targets for a module connector

List a Modular Rig's modules

Delete a module from a Modular Rig

Query the Rig Module asset library

Read a module instance's config

Set or reset a module config value

Bind a module variable to another module's variable

Rename a module instance

Reparent a module instance

Reorder a module among its siblings (5.7+)

Mirror a module (e.g. left arm to right arm)

Swap a module's source asset

List rig sockets with placement hints and claimed state

List hierarchy components (physics solvers/bodies/joints)

Numeric live pose: current vs rest per bone, worst deviation first

Detect melted / twisted / inside-out skinning on the preview mesh

Physics invariant checks: unjointed bodies, free joints, conflicts, drift

Inspect a module asset's internal graphs (any module, incl. custom)

Toggle per-command disk saves for rig commands (default off)

Size a ChainPhysics module's collision from the real skinned mesh

Generate a kinematic body-collider rig module asset

Mesh-vs-mesh clip depth: cloth/hair vertices inside body volume

Real per-bone geometry from skinned vertices + physics asset

Place a pole control out in the bend plane, and verify it moved

Purge persisted components from the blueprint hierarchy

Full field dump of live hierarchy components via reflection

List animation channels with hosts and live values

Write animation channel values on the running instance

Play an animation on the rig's asset-editor preview

Stop the preview animation and restore forwards-only solve

One-shot soft-tissue jiggle setup (tip bone + rebind + tune)

Flag dead controls and undriven bones from live VM truth

Graph red-squiggle report: bad refs, missing channels, dead exec, runtime log

Ground-truth rig I/O: events, AnimBP pins, control reads, measured bone writes, safety verdict

Headless rig performance report: solve ms, hot nodes, physics census, red flags

Which controls actually MOVE bones, empirical connectivity map

Headless N-frame simulation: anim input, limb crossing, ground clipping, deviation, NaN checks

Clear a module connector's binding

Export a complete Control Rig to JSON

Scan a Niagara system's full stack for issues (the per-module warnings/errors the editor shows)

Apply a stack issue's fix (the editor's "Fix issue" button), one issue or all auto-fixes

List standalone Niagara data/utility asset types creatable via create_niagara_asset

Create a standalone Niagara data/utility asset

Add a named parameter (with optional default value) to a parameter collection

Create a new Niagara particle system

Get full info about a Niagara system

List Niagara system assets

Delete a Niagara system asset

Compile a Niagara system

Compile a standalone Niagara script (module / dynamic input / function)

Apply a standalone Niagara script's edits to the asset (editor Apply button)

List emitters in a Niagara system

Create a standalone Niagara emitter asset

Add an emitter to a Niagara system

Remove an emitter from a Niagara system

Set a property on an emitter

Duplicate an emitter within a system

Move an emitter to a new position

List modules in an emitter's stack

Add a module to an emitter's stack

Remove a module from an emitter's stack

Enable or disable a module

Move a module to a new position in stack

Get input parameters for a module (keyword + top-N)

Set an input value on a module

Set a dynamic input on a module

Set a curve on a module input

Set any module input value via the stack (local/enum/linked/hlsl/dynamic_input/data_interface/reset)

Read a module input's current value and kind (round-trips to set_niagara_stack_value)

Get user-exposed parameters

Add a user parameter to a system

Set a user parameter value

Remove a user parameter from a system

Link a module input to a parameter

Add a renderer to an emitter

Remove a renderer from an emitter

Get renderer properties and bindings

Set a property on a renderer

Bind a renderer slot to a particle attribute

Auto-layout a Niagara script graph

Create a scratch pad module on a system or an emitter

Set HLSL code on a scratch pad module

Create a standalone Niagara script asset (module / dynamic input / function)

Add an event handler to an emitter

Add a simulation stage to an emitter

List event handlers on an emitter

Spawn a Niagara effect in the level

Control a spawned Niagara effect

Add a Niagara component to an actor

List Niagara effect actors in the level

List available Niagara modules

List available emitter templates

List Niagara data interface types

List Niagara parameter types by scope

Get attributes available on an emitter

List editable properties on a renderer with current values

Set a system-level property via reflection

Get actual module input values (spawn rate, colors, forces, etc.)

Set a module input value (spawn rate, color, force, size, etc.)

Get compilation errors and warnings for a Niagara system

Get live particle counts and emitter execution state

Set the timeline playback range in the Niagara editor

Get the current playback range and frame rate settings

Check for outdated modules in an emitter

Export a full Niagara System / Script / Emitter as reflection-grounded JSON

Introspect every node inside a Niagara graph

Deep inspect a single Niagara node by index, class, or GUID

BFS trace of connections upstream or downstream from a node

Classify orphaned, dead-end, and missing-input nodes in a Niagara graph

Apply scratch pad changes in an open Niagara System (Apply Scratch button)

Apply a scratch pad module's edit-copy and save the asset (Apply & Save button)

List all scratch pad modules on a Niagara System

Delete a scratch pad module from a system or emitter

Duplicate a scratch pad module with a new name

Rename a scratch pad module

Read the details-panel properties of a Niagara script

Batch-set details-panel properties on a Niagara script

List input + output parameters of a Niagara script

Add an input or output parameter to a Niagara script

Remove a named input or output parameter, cascades to Map Get/Set pins

Rename a script parameter in-place across asset and edit-copy graphs

Create a new node inside a Niagara graph

Delete a node from a Niagara graph

Build a whole Niagara graph at once, many nodes + connections in one call

Add an input pin to a Custom HLSL node

Add an output pin to a Custom HLSL node

Rename a Custom HLSL pin (also rewrites {PinName} references in the HLSL body)

Remove a pin from a Custom HLSL node

Add a typed output pin to the first ParameterMapGet node in a scratch pad graph

Add a typed input pin to the first ParameterMapSet node in a scratch pad graph

Add a pin to any UNiagaraNodeWithDynamicPins-derived node

Rename a pin on a dynamic-pin node

Remove a dynamic pin from any node in a scratch pad graph

Wire one node's output pin to another node's input pin inside a scratch pad graph

Break a pin connection in a scratch pad graph

Enumerate Niagara node classes available for spawning

Get pin schema for a node class or script asset

Find Niagara script assets by usage + name filter

Search the full Niagara node palette (the right-click menu) by keyword + category

Generic type query, handles registered Niagara types AND raw UEnums/UScriptStructs

Walk a UNiagaraDataInterface class default object and return its editable property schema

List available Niagara parameters (Engine.*, Particles.*, Emitter.*, User.*)

Resolve the actual binding of each module input, Default / Local / Linked / Dynamic / Data

Reset a module input to its default (including nested paths like 'Spawn Count.Position Array')

Reproduce the stack-UI source dropdown for a specific input

Find where a scratch pad script is referenced across all emitter/system graphs

Discover built-in dynamic-input script paths via AssetRegistry (replaces hardcoded guesses)

Enumerate member functions on a Niagara data interface class

Create a new empty PCG Graph asset

Create a PCG Graph Instance bound to a parent graph

Create a new PCG Builder Settings asset

Create a new PCG Compute Source asset

Read the HLSL source and AdditionalSources of a PCG Compute Source asset

Write the HLSL source text on a PCG Compute Source asset

Append a UComputeSource to a PCG Compute Source's AdditionalSources

Remove an entry from a PCG Compute Source's AdditionalSources

List all UPCGComputeSource assets via Asset Registry

List EPCGKernelType enum values for the Custom HLSL node

List PCG Graph assets marked as templates

Create a new PCG Graph by duplicating a template

Search PCG node types (UPCGSettings subclasses) by name or category

List EPCGSettingsType category values for search_pcg_nodes

List PCG nodes with advanced or preconfigured-only behavior

List preconfigured variants for a PCG settings class

Get full schema for a PCG node type

Get valid values for a PCG settings property (enums, attribute pickers, extractors)

Read a PCG graph at a chosen verbosity

Get full info on one PCG node

Get pin-by-pin connections for one node

Trace reachable nodes from a starting node

Enumerate UserParameters on a PCG graph

List editable UPROPERTYs on the UPCGGraph asset

Set a graph-level UPROPERTY on the UPCGGraph (HiGen, landscape, cosmetic)

Add a node to a PCG graph

Delete a node from a PCG graph

Connect two PCG pins (add edge)

Atomically build a PCG graph (nodes + edges + auto-layout) in one call

Remove all edges from one pin

Remove a specific edge

Set a property on a node's UPCGSettings

Move a node

Set a node's comment string

Add a dynamic input pin

Remove a dynamic input pin

Add a graph-level user parameter

Remove a graph parameter

Rename a graph parameter

Set a graph parameter's default value

Change a graph parameter's type

Re-target a subgraph node

List subgraph parameter overrides

Override a subgraph parameter

Reset a subgraph parameter to default

Validate a PCG graph

Read cached graph validation findings

Auto-layout the graph

Attach a comment to the graph

Generate() all components bound to a graph

CancelGeneration() on all components

Toggle UPCGComponent::bActivated for a graph

Set a nested PCG node property via dotted path with [N] indexers

Read a nested PCG node property value

Discover nested property paths on a PCG node

Append or insert an element into a PCG node TArray property

Remove an element from a PCG node TArray property

Replace an instanced FObjectProperty with a NewObject of a specified class

Switch a Custom HLSL node's kernel type (mirrors the engine's SetKernelType)

Set a Static Mesh Spawner's weighted mesh list in one call

Call UPCGComponent::Generate on the named actor

Call UPCGComponent::Cleanup on the named actor

Call UPCGComponent::GenerateLocal(Trigger, bForce, Grid)

Call UPCGComponent::CleanupLocal(bRemoveComponents)

Call UPCGComponent::CleanupLocalImmediate, synchronous, no delayed tasks

Call UPCGComponent::CancelGeneration on the named actor

Call UPCGComponent::SetGraph to assign a PCG graph to a component

Read the last generated FPCGDataCollection from a component

Call UPCGComponent::ClearPCGLink, detach generated content into a standalone actor

Check whether a UPCGComponent is partitioned

List APCGPartitionActors in the world, optionally filtered by an original PCG component

Get detailed info on one APCGPartitionActor by name

Aggregate generated output across all partition actors of a partitioned PCG component

Schedule a PCG graph for async execution against a component as execution source

Schedule a PCG component's own graph for async execution

Schedule cleanup of a PCG component's graph

Refresh a PCG component on the current or next frame (editor only)

Generate every registered PCG component in the world (editor only)

Cleanup every registered PCG component in the world (editor only)

Refresh all GenerateAtRuntime PCG execution sources

Mark all runtime-gen PCG execution sources as dirty (5.8+ only)

Refresh PCG components matching a filter predicate (editor only)

Flush PCG results cache and compiled-graph cache

Clean up and re-generate all runtime-gen PCG components including partition actors

Refresh a single GenerateAtRuntime PCG component (optionally flushing cache first)

Build the PCG landscape cache for the current world

Clear the PCG landscape cache for the current world

Check whether per-node inspection is enabled on a UPCGComponent

Enable per-node inspection on a UPCGComponent

Disable per-node inspection on a UPCGComponent

Check whether a node's task executed during the last generation

Check whether a node produced data in the last execution

Get the bitmask of output pins deactivated by dynamic branching

Check whether a node triggered a GPU->CPU readback during last execution

Check whether a node triggered a CPU->GPU upload during last execution

Check whether data overrides were applied to a node during last execution

Inspect a node's output data collection (compact, AI-friendly summary)

Inspect a node's output across ALL partition cells of a partitioned PCG component

List all nodes executed during last generation (compact)

Clear cached inspection data on a UPCGComponent

Search the Procedural Vegetation add-node menu (UE 5.8 only)

List Procedural Vegetation node categories with node counts (UE 5.8 only)

Get full schema for one or more Procedural Vegetation nodes (UE 5.8 only)

Write the full Procedural Vegetation node schema to a JSON file (UE 5.8 only)

Create a Procedural Vegetation asset (UE 5.8 only)

Export a Procedural Vegetation asset to mesh assets (UE 5.8 only)

Preview a node's output in the open editor viewport (UE 5.8 only)

Dump a PCG/vegetation graph's AUTHORED configuration to a file (UE 5.8 only)

List Procedural Vegetation assets available as creation samples (UE 5.8 only)

Create a new Material

Create a Material Instance

Build complete node graph in one atomic call

Inspect material properties, parameters, textures

Bulk-set material properties

Force recompile and save

Apply edits to the asset (clicks the editor's Apply button)

Get material compilation errors

Report the engine's own shader cost counters for a material

Add comment boxes to material graph

Read graph nodes with verbosity control

Inspect one material expression node with its available pins

Show which material outputs (BaseColor, etc.) are connected

Add a material expression node

Connect two material expression nodes

Delete a material expression by index

Set a property on a material expression

Move a material expression node

Duplicate a material expression

Auto-layout the material graph (data-flow, right-to-left)

Auto-layout all material expressions (alias of layout_material_graph)

Auto-layout a Material Function graph (data-flow, right-to-left)

Get all parameters of a material instance

Set a parameter on a material instance

Reparent a material instance

Clear a parameter override (revert to parent)

List available material expression types

Look up pins & properties for a node type

Query available material output pins

Disconnect a specific input pin

Find Material Functions by name

Diagnose orphaned, dead-end, and unconnected nodes

Trace upstream/downstream from a node

Delete orphaned/dead-end nodes

Create a new Material Function asset

Create a Material Function Instance

Override a parameter on a Material Function Instance

Read overrides on a Material Function Instance

Set the material attribute layer stack (base or instance)

Read the material attribute layer stack

Inspect a Material Function

Build complete MF node graph in one call

Add a FunctionInput pin

Add a FunctionOutput pin

Modify an existing FunctionInput

Modify an existing FunctionOutput

Validate a Material Function

Cleanup orphaned nodes in a Material Function

Create a Material Parameter Collection

Add or update an MPC scalar/vector entry

List all entries of a Material Parameter Collection

Remove an entry from a Material Parameter Collection

List gameplay tags with source, comment and children

Read one tag's comment, sources, parent and children

Add a gameplay tag to an ini source

Remove a gameplay tag from its ini source

Rename a tag, leaving a redirector behind

Create a new tag source ini

List tag sources and which are writable

Check the tag library and return a verdict

List AttributeSet classes, including unopened Blueprints

List an AttributeSet's attributes with defaults

Create a Blueprint AttributeSet, optionally with attributes

Add an attribute to a Blueprint AttributeSet

Check an AttributeSet and return a verdict

Create a GameplayEffect Blueprint

List the effect component classes this engine has

Attach a gameplay effect component

Remove a gameplay effect component by class

Add or edit a modifier on a gameplay effect

Run the engine's own validation over an effect

Create a GameplayAbility Blueprint

Create a cue notify Blueprint bound to its cue tag

List cue notify assets and the tag each answers to

Cross-check cue tags against notifies, both directions

Ranked bulk search across tags, attributes, effects and abilities

Inspect an actor's AbilitySystemComponent

Paint every landscape layer in one normalised pass

Spawn a volume with real brush geometry at a given size

Verify a volume has brush geometry and actually does something

Create a landscape at a chosen resolution

Sculpt landscape heights with a shape

Paint a landscape weight layer

Read a landscape's resolution, scale, height range and layers

Remove all landscape splines

Deform the landscape along a spline

Edit one region of an existing landscape

Carve a river into an existing landscape

Generate a complete eroded terrain into a landscape

Verify a landscape is usable

Start a Lightmass lighting build

Poll a lighting build

Recapture sky lights

Flush or fully rebake reflection captures

Verify lighting is built

Start a navigation mesh build (asynchronous)

Poll an in-flight navigation build

Verify navigation is built and actually pathable

Set or append a spline's points

Edit one spline point: location, tangents, rotation, scale, type

Read a spline's points, length and sampled transforms

Verify a spline is usable

Add a component to a placed actor in the level

Create a foliage type asset from a static mesh

Place foliage in a reproducible pattern (the brush, without the brush)

Remove placed foliage instances, keeping the types

Remove a foliage type from the level entirely

List foliage types in the level with instance counts

Verify placed foliage is actually going to render

List the editor modes this build registers, and which is active

Switch the level editor to a mode by id

Run one geomorphic process over an existing landscape

Regenerate one region of a landscape and merge it seamlessly

Report a World Partition level's grids, data layers and loaded actor counts

List every actor in a partitioned level without loading it

Load a region of a partitioned level so its actors can be edited

Release a region loaded by load_world_partition_region

Keep matched actors loaded regardless of camera position

Set whether an actor streams with the grid or is always loaded

Create a data layer asset and an instance of it in this world

List data layers with type, parent, state and actor counts

Add or remove matched actors to a data layer

Set a data layer's editor visibility, editor loading and initial runtime state

Remove a data layer instance from this world

Create an HLOD layer asset

List HLOD layer assets with type, cell size, loading range and parent

Assign an HLOD layer to matched actors, or clear the override

Run a World Partition builder (hlod, minimap, navigation, foliage...)

Set any editable UWorldPartition property by reflection

Add, edit or remove a named runtime grid

Put matched actors onto a named runtime grid

Check a partitioned world is actually partitioned

Search Behavior Tree node classes, ranked

Read a node class: its properties and what each accepts

List available blackboard key types

Create a Behavior Tree with its graph and Root node

Create a Blackboard

Attach a Blackboard to a Behavior Tree, or set what it inherits from

Create a Blueprint task, service or decorator

Read a Behavior Tree as a tree

Read a Blackboard's keys

Check a Behavior Tree and return a verdict

Add composites and tasks to a Behavior Tree

Attach decorators and services to a node

Re-parent a node or change its sibling order

Remove a node, a subtree, or a sub-node

Set properties on a node, decorator or service

Rebuild the runtime node chain from the graph

Auto-arrange the graph layout

Combine decorators with AND, OR or NOT

Inspect Behavior Trees running in play

Start, stop, restart, pause or resume running logic

Swap the subtree behind a Run Behavior Dynamic task

Add keys to a Blackboard

Remove a key from a Blackboard

Rename, retype or edit a Blackboard key

Search EQS generators, tests and contexts, ranked

Read an EQS generator, test or context class

Create an Environment Query

Read a query's options and tests

Add a generator option to a query

Remove an option from a query

Add a test to an option

Remove a test from an option

Set a property on a generator or a test

Check a query and return a verdict

Run a query in the editor and return its results

Get StateTree overview (schema, counts)

Export a StateTree to a complete self-contained JSON file

Get state hierarchy tree

Get detailed info for a single state

Get global evaluators with properties

Get global tasks with properties

Get tree-level parameters

Get detailed info for a single node by GUID

Get property bindings with full path details

Get complete StateTree data in one call

Search for nodes by class name or category

Create a new StateTree asset

Add a state to the tree

Add a task to a state

Add a global evaluator

Add a global task

Add a condition to state enter or transition

Add a utility consideration to a state

Add a transition to a state

Add a tree-level parameter

Set the value of an existing tree-level parameter

Set a property on a state

Set a property on a task/evaluator/condition

Set a property on a transition

Change the schema of a StateTree

Assign a StateTree asset to a StateTree component (placed actor or Blueprint)

Add a property binding between nodes / tree parameters

Bind a delegate dispatcher to a listener

Bind a listener to a task's completion (UE 5.8+)

Add or update a theme color

Remove a state and its children

Remove a task/evaluator/condition by GUID

Remove a transition from a state

Remove a property binding

Remove a tree-level parameter

Compile a StateTree and return errors

List available task/evaluator/condition types

List valid binding sources for a node (context/params/functions)

Deep type-aware property search across a node's binding sources

List available StateTree schema classes

List valid transition targets for a StateTree

List valid enum values for StateTree properties

Create a new Level Sequence asset

Open a Level Sequence in the Sequencer editor

Read timeline settings + binding/track counts

Set the playback range (frames or seconds)

Set the display rate / FPS

Set the tick resolution (migrating)

Bind an existing level actor as a possessable

Add a spawnable binding from a class

Add a spawnable binding from a level actor template

List bindings (possessables + spawnables), filterable by type/name

Rename a binding by GUID

Remove a binding by GUID

Convert a possessable binding to spawnable

Convert a spawnable binding to possessable

List available track classes (reflection)

List tracks on a binding (or root tracks)

Add an object-bound track to a binding

Add a root/master track (camera cut, audio...)

Remove a track by index

Add a section to a track

List sections on a track

Set a section's range (frames or seconds)

Remove a section by index

Set a property on a track (universal writer)

Set a property on a section (universal writer)

List a section's animatable channels

Add a keyframe to a channel

List keys on a channel

Remove a key by index from a channel

Set a channel's default value

Key location/rotation/scale on a transform section in one call

Spawn a cine camera and bind it in the sequence

Add a camera cut to the camera (auto-creates the cut track)

Render a Level Sequence to disk via Movie Render Queue (async)

Report Movie Render Queue progress + written files

Set an existing key's value (float/double channel)

Move an existing key in time

Set a key's interpolation + tangent mode

Set a key's tangents (arrive/leave + weights)

Set channel pre/post-infinity extrapolation (looping)

Set section ease-in/out (fade) length

Set section blend type (additive layering)

Add a sound on a master audio track

Add a sub-sequence (shot) on a cinematic shot track

Add an event track section (repeater/trigger)

Add a time-warp track with a fixed play rate (5.8+)

Add a timeline marker

List timeline markers

Remove a timeline marker by index

Add a root folder (organization)

Add a binding or root track to a folder

Set evaluation type (framelocked/withsubframes)

Add a tag to a binding

Remove a tag from a binding

Deep report for one binding: tracks, sections, channels (filterable), optional keys

Evaluate channel value(s) at a frame/time (e.g. Location.X at frame 500)

Move the Sequencer timeline bar to a frame/time (sequence must be open)

Read the Sequencer playhead position (sequence must be open)

Play or pause the open Sequencer

List keyable properties of a binding's object/component (discover what you can animate)

Possess an actor's component as a child binding (needed to animate LightColor/Intensity)

Add a property track bound to a property (auto-picks track class); enables color/intensity/etc.

Batch-add keys to multiple channels of a section in ONE call

Add an animation to a skeletal-mesh binding; loops to fill the section by default

List all actors in the current level

Find actors by name pattern

Spawn an actor in the level

Search available UClasses by name, optionally filtered by a base class

Delete an actor from the level

Set actor location/rotation/scale

Spawn a Blueprint actor instance

Spawn an actor from a class name

Get currently selected viewport actors

Get current level info (world name, actor count)

Capture viewport, a named window, or an asset editor to PNG

Block until asset and shader compilation finishes

Read an editor Message Log listing

Run the project's own data validators over its assets

Compile a Blueprint and report which nodes failed

Find static meshes with missing or unusable collision

Check a class for silent multiplayer bugs

List open editor windows and asset editors

Bring an asset's editor tab to the front

Frame the level viewport on an actor or move the camera

Context-friendly clustered understanding of the level

Native shape/bounds/pivot of a static mesh asset (before placing)

Spawn many actors from one computed array in a single call

Bulk-delete actors by name/label prefix or an explicit list

Put actors into an outliner folder (organization only)

Create an empty outliner folder

Delete an outliner folder (and subfolders)

List all outliner folders in the level

Rename/move an outliner folder

Group actors into an editor Group (AGroupActor)

Dissolve the editor Group(s) containing the given actors

Attach actors as children of a parent (transform hierarchy)

Detach actors from their parent (become independent)

Off-screen orthographic top-down (floor-plan) render to PNG

Set a property at any nested path on a placed actor

Inspect property type/clamp/enum metadata on a placed actor

List material element slots (index, slot name, current material, override state) for any target's mesh components, placed actor, Blueprint component template, or a StaticMesh asset

Assign materials per element slot to any target's mesh components, placed actors, Blueprint component templates, one or many, in a single call

Spawn ANY AActor subclass, engine, plugin, or Blueprint

Flexible actor search by name, label, class, or tag

Get property values from a live placed actor instance

Close the connected Unreal Editor the safe way (no process kill)

Start Play-In-Editor (PIE), in the active viewport, or a new window

Stop the running Play/Simulate-In-Editor session

List the New-Level templates the editor offers (Basic, Open World, blanks, project templates)

Create and open a new level (blank, partitioned, or from a template)

Open an existing level in the editor

Save the current level in place

Save the current level to a new asset path

Drop a ready-to-light environment (sun, sky, fog, floor) into the current level, with optional lighting presets

Read the editor's undo stack, newest first

Roll back the last N transactions, as Ctrl+Z does

Run many commands in one round trip and one undo step

Re-apply the last N undone transactions

Search Project/Editor Settings sections by name

Read all properties of a settings section

Set one or more properties on a settings section and persist to Default*.ini

Bring a graph to the front in the Blueprint editor

Search for classes usable as Blueprint parents

Search types by keyword for variables/pins (top-N)

Create a Blueprint from any parent class

Export a Blueprint as complete reflection-grounded JSON

Read a graph as the canonical round-trip document

Rebuild a graph from an export_graph document

Bring a graph in line with a document, changing only what differs

Compare a graph document against the live graph

Export any UObject/asset/struct as reflection-grounded JSON

Export any graph-bearing asset as reflection-grounded JSON (auto-dispatch)

Export a placed level actor + its full component hierarchy as JSON

Add a component to a Blueprint or a placed actor

Set a property on a Blueprint's component template

Delete a component from a Blueprint or a placed actor

Move a component under a new parent (or to root)

Make a scene component the root

Compile a Blueprint

Read complete BP: graph, functions, variables, components

Analyze a graph (nodes, connections, execution flow)

Create a variable in a Blueprint

Create a function-local variable

Inspect variable(s) in a Blueprint

Modify variable properties (full Details panel)

Delete a variable from a Blueprint

Change a Blueprint's parent class

Create a Blueprint Function Library asset

Set Details-panel properties on any blueprint function

Create a Blueprint Interface asset

Implement an interface on a Blueprint class

Remove an implemented interface from a Blueprint

List a Blueprint's implemented interfaces

Create a new function in a Blueprint

Override a parent-class function or event (My Blueprint > Override)

Create a new event graph in a Blueprint

Rename an event graph in a Blueprint

Delete an event graph from a Blueprint

Inspect function(s) with graph

Add input parameter to a function

Add output parameter to a function

Delete a function from a Blueprint

Rename a function

Add an event dispatcher (multicast delegate) to a Blueprint

Search ANY placeable node by keyword (top-N)

List a node's pins (name/dir/type) WITHOUT placing it

Build a whole graph fragment at once (nodes + connections)

Auto-arrange a whole graph (straight exec spines, clustered inputs, reroute knots)

Set one input pin's default literal on a placed node

Break links on a node pin (disconnect)

Splice an existing node into an exec link

Add a node to a Blueprint graph

Wire two nodes together

Delete a node by GUID

Set node property or perform semantic editing

Read a Blueprint class's default (CDO) property values

Set default property values on a Blueprint's class (CDO)

Create a Blueprint struct (UserDefinedStruct), optionally with members

Add a member variable to a Blueprint struct

Rename, retype, re-default, or re-tooltip a struct member

Remove a member from a Blueprint struct

List a Blueprint struct's members (name, type, default, tooltip)

Search Blueprint structs in the project (ranked best-match first)

Create a new UInputAction asset

Read all properties, triggers, and modifiers of an Input Action

Set properties on an Input Action

Add a trigger to an Input Action

Add a modifier to an Input Action

Remove a trigger by index

Remove a modifier by index

List all UInputAction assets

Create a new UInputMappingContext asset

Read all key mappings with triggers/modifiers

Add a key-to-action mapping

Remove a mapping by index or action+key

Change key or action on existing mapping

Add a trigger to a specific mapping

Add a modifier to a specific mapping

Remove a trigger from a mapping

Remove a modifier from a mapping

List all UInputMappingContext assets

List all UInputTrigger subclasses with properties

List all UInputModifier subclasses with properties

List available FKey values (keyboard, mouse, gamepad)

Search the Asset Registry by class, path, and/or name pattern

List assets in a Content Browser directory

Get asset metadata (class, package, properties)

Get all editable properties of any asset

Set a single property on any asset

Find dependents/dependencies of an asset

Open asset in the editor

Save a specific asset to disk

Save all unsaved (dirty) assets

Delete an asset or directory (checks references)

Copy an asset to a new location

Rename/move an asset (auto-fixes references)

Import external file into Content Browser

Batch import files into Content Browser

Get currently selected Content Browser assets

Navigate Content Browser to show an asset

Batch move/rename assets (auto-fixes references and redirectors)

Batch delete assets (reference-checked unless forced)

Fix up and delete redirectors under a content path

Find same-class assets that can replace a given asset (ranked, top-N)

Replace all references to source assets with a target asset (consolidate)

List all loaded UDataAsset subclasses

Create a new UDataAsset subclass instance

Query valid dropdown values for a property slot

Search for class paths by filter

List data assets by path/class

Introspect any object's properties (filtered, top-N, with types and enum values)

Read one property value at a dotted/indexed path

Set, append, or remove properties and array elements at dotted/indexed paths

Get the widget hierarchy of a Widget Blueprint

Add a widget to a Widget Blueprint

Remove a widget from a Widget Blueprint

Move a widget to a new parent

Rename a widget

Duplicate a widget

Create a new Widget Blueprint asset

Search the widget palette

Author a whole widget hierarchy in one command

Wrap a widget in a new panel

Replace a widget with another class

Set the tree root widget

Read a widget's properties

Set a widget's properties (faithful)

Read a widget's slot (layout) properties

Set a widget's slot (layout) properties (faithful)

Toggle a widget's Is Variable flag

Switch a Widget Blueprint between its Designer and Graph tabs

Explain one or many widget classes

Reparent a Widget Blueprint

List the Widget Blueprint's named slots

Get a named slot's content

Place a widget in a named slot

Clear a named slot

Set a widget's navigation rule for a direction

Get a widget's navigation

Reset a widget's navigation

Bind a widget property to a function (legacy)

Remove a legacy property binding

List legacy property bindings

List a widget's event delegates

Add a UI component to a widget (UE 5.8+)

Remove a UI component from a widget (UE 5.8+)

List a widget's UI components (UE 5.8+)

Create a UMG animation

List a Widget Blueprint's animations

Remove a UMG animation

Bind a widget to an animation

Remove a widget binding from an animation

Add a track to an animation

Add a keyframe to an animation track

List an animation's tracks

Add an MVVM viewmodel

Remove an MVVM viewmodel

Rename an MVVM viewmodel

List MVVM viewmodels

Add an MVVM binding

Modify an MVVM binding

List MVVM conversion functions

Set viewmodel settings

Set variable Field Notify

Remove an MVVM binding

List MVVM bindings