Every tool. Every system.

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

Create a scratch pad module on a system

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 Niagara System

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

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

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

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 or editor window to PNG

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

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

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

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

List available widget types

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

Describe a widget class

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

Create a new Data Table with a chosen row struct

Search structs usable as Data Table row structures (ranked best-match first)

Get all rows from a Data Table

Get a single row by name

Get column names and types from row struct

Add a new row with optional initial data

Update specific fields on an existing row

Delete a row by name

Rename a row in-place

Copy a row under a new name

Create a Curve asset (float, vector, or linear color)

Read a curve asset's keys, settings, and ranges

Write keys on one sub-curve of a curve asset

Delete keys from one sub-curve

Replace a curve asset's data from JSON or CSV

Create a Curve Table (or Composite Curve Table)

Read a curve table's rows and keys

Add or update one curve table row

Delete a row from a curve table

Rename a row in a curve table

Replace ALL rows of a curve table from CSV or JSON

Create a Curve Atlas from linear color curves

Edit a Curve Atlas (resize, add/remove/replace curves)

List engine + custom console commands and cvars (filterable)

Full metadata for one console command or cvar by exact name

Boolean existence check (IConsoleManager registry only)

Execute any console command in the editor

Start recording a live.utrace from the running editor

Stop recording and optionally auto-load for analysis

Analyze a performance trace (diagnose, spikes, flame, hotpath, etc.)

List every trace channel the running engine has (engine + custom) plus presets

Enable or disable a trace channel at runtime (mid-trace)

Insert a named bookmark into the live trace timeline

Write a trace snapshot (tail buffer) to a.utrace file

Capture a screenshot into the live trace

Register UObject(s) for per-frame property tracing (objectproperties query)

Start sampling live per-frame timing (no trace needed)

Stop live sampling and return the multi-frame timing distribution

Report CLI, license, and editor-bridge status

Execute arbitrary Python code inside the running Unreal Editor

Dump the C++ reflection-generated schema for reflected commands

List every running Unreal editor (pid, project, engine, port)

Select which running editor later commands talk to

Clear the active editor selection

Show the active selection and which editor commands would hit

Enable or disable MCP debug mode (token tracking)

Get MCP token usage statistics