ue5-mcp — Field manual for driving Unreal Engine 5 via MCP

Engine-level wisdom an LLM needs to drive UE5 through an MCP server without faceplanting on UE's silent-fail edges. This skill is server-agnostic: the gotchas, patterns, and identifiers documented here apply whether you're connected to Epic's official ModelContextProtocol plugin (UE 5.8+) or any other MCP server that exposes UE5 functionality.

What this skill isn't: a list of commands for any particular MCP server. Each server publishes its own tool catalogue — ask the server with tools/list for what it actually exposes. This skill covers what bites you after you know the tool names.

1. Session checklist — read before you write

UE5 is a structured-asset editor. The agent that wins is the one that reads state before mutating it.

1. Always dump the asset before editing it. Blueprint, material, Niagara

system, widget, level — every MCP server worth its salt exposes a dump_* / inspect_* / read_* family. Use it. Editing a graph without first knowing what's there creates broken connections, duplicate nodes, and unrecoverable corruption faster than anything else.

1. Discover before assuming. Call tools/list once on connect, cache it,

and use it to figure out which tools your server actually exposes. Different servers wrap UE5 differently; recipes from this manual that reference a generic capability (e.g., "dump the Blueprint graph") will map to different concrete tool names on different servers.

1. Verify after mutating. UE5 has too many silent-fail edges to trust a

successful response. Read the property back. Compare to what you asked for. If they differ, re-examine.

1. Save explicitly. Most introspection tools serialize from disk. If

your last mutation is in-memory only, the dump returns the pre-mutation state. Save the asset (or SaveDirtyAssets) before re-reading.

2. UE5 reflection gotchas

These bite agents regardless of which MCP server sits in front of them. Every one has cost real debugging time.

2.1 PascalCase, not snake_case, for UPROPERTY writes

Setting a UPROPERTY via the Python binding's set_editor_property("auto_possess_ai", ...) silently no-ops on many builds. UPROPERTY names are PascalCase at the reflection layer: AutoPossessAI. Python's unreal module accepts snake_case at the call site, but the underlying lookup is case-sensitive against the PascalCase name. There is no error returned — the property simply doesn't change.

Detection pattern: round-trip verify. After any UPROPERTY write, read the property back and compare. Naive string compare misses normalization (EFoo::Bar vs Foo::Bar, (X=1,Y=2) vs (X=1.000000,Y=2.000000)). The robust pattern in native C++:

1. Allocate a scratch buffer aligned to Property->GetMinAlignment() and

call Property->InitializeValue(Scratch).

1. Property->ImportText_Direct(RequestedValue, Scratch, Owner, PPF_None)

to canonicalize what was requested.

1. Property->ExportTextItem_Direct(ExpectedText, Scratch, ...) for the

canonical form of "what we asked for."

1. Apply the write, then Property->ExportTextItem_Direct(ActualText, ...)

for "what we got."

1. Compare ExpectedText to ActualText.

If they differ, the write didn't take — usually due to snake_case mismatch, an enum-class qualifier issue, or a struct-text format the property doesn't recognize.

2.2 Blueprint class path needs the _C suffix

LoadObject<UClass>(nullptr, "/Game/Path/BP_Foo") returns nullptr. The Blueprint's generated class lives under a different name: /Game/Path/BP_Foo.BP_Foo_C. StaticLoadClass expands this internally; LoadObject<UClass> does not.

If an MCP tool returns "Class not found: /Game/Path/BP_Foo," that's almost always the missing suffix. Retry with <path>.<asset>_C.

2.3 Async asset operations don't block

MetaHuman texture downloads, asset compilation, shader compilation, derived-data builds, Niagara compile, package save — all async. An agent that requests "download MetaHuman textures" and immediately reads the character sees the previous texture state, not the new one.

Patterns:

• Poll the relevant Is*Complete predicate before continuing.
• Subscribe to the completion delegate if the subsystem exposes one

(FAssetCompilingManager::Get().GetPostCompilationDelegate(), etc.).

• For MetaHuman: poll IsTextureSourceRequestComplete(Character) after

RequestTextureSources.

• For asset save: don't immediately re-read the package file; let

UPackage::SavePackage complete first.

2.4 Save before reading from disk

Many "dump" / "serialize" operations read the asset from its .uasset package on disk. If the most recent edits are in-memory only, the dump returns the pre-edit state. Save explicitly between mutate and read, or use an in-memory-aware introspection path if the server provides one.

2.5 PostEditChangeProperty is required after direct property writes

Property->CopyCompleteValue(Dest, Src) writes the value but doesn't fire PostEditChangeProperty. Any derived state set up by the object's PostEditChangeProperty handler — preview meshes, generated thumbnails, recompiles, dependent properties — won't update. Notify it manually:

FPropertyChangedEvent ChangeEvent(Property, EPropertyChangeType::ValueSet);
Object->PostEditChangeProperty(ChangeEvent);

The Details panel will show the new value either way, but the object's behaviour won't reflect it until the event fires.

2.6 Blueprint graph mutations need three steps, not one

To safely add a node to a UEdGraph:

1. Construct the node (NewObject<UEdGraphNode>(Graph)).
2. Graph->Nodes.Add(NewNode).
3. Graph->NotifyGraphChanged().

Single-call helpers in some bindings do step 1 only and leave the graph in an inconsistent state — the node exists but the editor's pin-resolution + compile pipeline doesn't see it. Symptoms: phantom "missing node" errors at compile, broken connect operations, or nodes that vanish after editor reload.

3. UE5 stability — actions that crash the editor

These are crashes that hit any agent driving the editor, regardless of MCP server. Worth knowing before you do them.

3.1 Don't delete or modify assets that other actors reference

Deleting (or transforming) a mesh asset while level actors reference it triggers a RegisteredElementType assertion crash. The editor goes down and any unsaved work in other windows is lost.

Safe pattern: before deleting, walk the asset dependency graph. Most MCP servers expose this (get_asset_references or similar). If anything depends on the asset, create a new replacement asset, swap actor references to it, then delete the original.

3.2 Don't spawn-then-immediately-delete actors in quick succession

Same RegisteredElementType assertion. Spawn → delete → focus in rapid succession (sub-frame timing) corrupts the actor registry. Add a small delay or interleave with other operations.

3.3 Niagara assertions and MetaSound crashes wipe unsaved changes

When Niagara or MetaSound asserts during PIE, the editor reverts to the last on-disk save. Custom nodes, in-memory tweaks, and uncompiled edits are gone. Save before every PIE test for these subsystems. Pattern after a crash: restart editor, dump the asset, recreate the lost nodes from the dump.

3.4 MetaSound: scalar literal on an Audio-type pin

Setting a float (or other scalar) literal directly on a pin typed as Audio crashes the editor at runtime, not at edit time. The edit succeeds silently; the crash fires when PIE starts and the graph evaluates. The stack signature is:

bExpectsNone [MetasoundDataFactory.h:395]

Rule: Audio-type pins expect audio buffer connections, not scalar values. Don't pipe a Multiply (Audio) directly from a Constant; route it through an Oscillator or noise source that produces an audio-rate buffer.

After this crash, all custom MetaSound nodes are wiped on next editor launch — only OnPlay, OnFinished, and Output survive.

3.5 Editor sprite icons are not particles

Editor viewport screenshots include sprite icons for each component (NiagaraComponent, AudioComponent, etc.). They look like particles but are the editor's UI overlay, not the actual VFX. Editor screenshots are not reliable verification for live Niagara behavior. Verify by:

1. Reading is_active: true off the Niagara actor after spawn.
2. Entering PIE and screenshotting the running game viewport.
3. Or using pixel streaming for real-time visual confirmation.

4. Identifier and path conventions

4.1 Actor labels are not stable identifiers

a.get_actor_label() returns the display string shown in the Outliner. Two actors can share a label. The label is user-editable.

Use the actor's full path as the stable identifier:

/Game/Maps/Level.Level:PersistentLevel.BP_Character_C_0

Most MCP servers accept either, but the path is the only form that survives renames and disambiguates duplicates.

4.2 Asset path forms

UE5 accepts three forms for an asset, and they mean different things:

If a tool returns a path-not-found error, check that the form matches what the tool expects.

4.3 Widget paths vs widget Blueprint paths

UMG-related tools usually take one of two parameters with similar names:

• widget_blueprint_path — path to the WidgetBlueprint asset on disk

(/Game/UI/WBP_HUD)

• widget_path — the identifier of a widget within a tree, addressing a

node inside the WidgetBlueprint's hierarchy

A "compile this widget" tool wants the Blueprint path. A "remove this widget from its parent" tool wants the tree-internal path. Servers vary on which they expose where — check input schemas before assuming.

5. UE5 subsystem gotchas

Engine-level facts about specific subsystems. These apply regardless of MCP server — the underlying UE5 behavior is the same.

5.1 Lumen lighting — Movable mobility is mandatory

Lumen Global Illumination only considers lights with Movable mobility. Static and Stationary lights contribute nothing to Lumen GI. Agents that spawn a DirectionalLight default to Stationary and then complain that GI isn't working — the fix is to set Mobility to Movable explicitly.

5.2 Blueprint instance override staleness

Level-placed Blueprint instances retain editor-modified component property overrides even after the parent Blueprint changes. If you edit BP_Character to change Speed from 600 to 800, instances of BP_Character placed in the level keep their old override (whatever the designer or a prior agent set on that specific instance).

Pattern after any parent BP property change: walk affected level instances and either revert overrides to defaults or re-apply the new value explicitly per instance. The "Reset to Defaults" right-click in the Details panel does this for humans; for agents, set the property directly on each instance.

5.3 Niagara: created-from-empty systems don't emit

Programmatically constructing a UNiagaraSystem from scratch produces a system that compiles clean but never emits. The empty-system default state isn't valid for emission (missing system spawn script wiring, missing emitter mode, etc.).

Working pattern: start from a working template. UE ships /Niagara/DefaultAssets/DefaultSystem which has a valid sprite emitter. Most MCP servers expose an "asset duplicate" tool; use it to duplicate a working system and then mutate the copy. Don't try to build emitters from nothing.

5.4 Niagara: script_usage is part of the module identity

The same module name can appear in multiple script-usage stages:

• system_spawn, system_update — once per system frame
• emitter_spawn, emitter_update — once per emitter per frame
• particle_spawn, particle_update — once per particle

A module named SpawnRate typically lives in emitter_update. A module named Initialize Particle lives in particle_spawn. When setting module inputs, always specify `script_usage` — the same module name in different stages is a different module instance, and the wrong stage silently no-ops.

5.5 Niagara: user-facing inputs vs script pins

The Niagara stack panel shows "user-facing inputs" — the named tweakable parameters per module. These are NOT the same as the underlying script's function-call pins. An agent that reads script pins and assumes they're the inputs will fail to set values.

Discovery pattern: ask for the module's input list before setting anything. Servers usually expose this as list_module_inputs or equivalent. The returned names are what set_*_module_input expects.

5.6 Niagara: dynamic input setting is broken in many versions

set_niagara_dynamic_input (or equivalent) typically fails with:

Failed to load random range script

This is a UE5 Niagara API gap, not an MCP-server bug. Workarounds: bake the dynamic value to a constant before assignment, or compute the value in Python and set the static input.

5.7 MetaSound: exact pin names matter

MetaSound pin names are case-sensitive and exact. SuperOscillator uses Frequency, Voices, Detune — not Base Frequency or Freq. Always dump the MetaSound's nodes (dump_metasound_graph or equivalent) before setting pins to learn the exact names.

5.8 Materials: emissive bloom threshold

Emissive intensity must exceed 1.0 to trigger bloom in the Post Process pipeline. Values of 3–10 produce visibly bloomed emissive surfaces. An emissive material with intensity 0.8 looks dim and self-lit but won't bloom.

Additional requirement: Post Process Volume must have Bloom enabled in its Effects settings. Default volumes have it on, but an agent that explicitly disabled bloom for performance won't get emissive bloom either.

5.9 Materials: translucent particle materials need Unlit shading

Lit translucent materials require normal vectors. Niagara sprite particles don't reliably provide normals (the orientation comes from the renderer, not the geometry). Pattern for particle materials:

• blend_mode = Translucent
• shading_model = Unlit
• Emissive output, no base color routing

A lit translucent particle material renders as a black/featureless sprite because the lighting calc has nothing to work with.

5.10 Materials: compilation lag

Creating or modifying a material kicks off shader compilation. Depending on how many permutations the material has (number of materials in the project using it, light counts, etc.), compilation takes seconds to minutes. Visual output doesn't update until compilation completes.

Pattern: after a material edit, poll for compile completion before judging visuals. Most servers expose a "get material errors" or "is asset compiled" predicate; if not, screenshot after a fixed delay (10–30s for moderately complex materials).

5.11 UMG widgets: CreateWidget needs an owning player context

A widget created without specifying an owning player context renders blank at runtime. The widget Blueprint compiles, the instance spawns, and AddToViewport accepts it — but nothing draws because the widget has no World context to anchor in.

Fix: pass GetPlayerController(0) as the Owner argument to CreateWidget (the Owner pin in the Blueprint node, or the OwningPlayer parameter in the Python unreal.CreateWidget call).

5.12 In-world widget components need a WidgetClass

Adding a WidgetComponent to a Blueprint doesn't automatically associate it with a Widget Blueprint. Set the WidgetClass property explicitly — it's a TSubclassOf<UUserWidget> (an FClassProperty), so the value is the generated class path (/Game/UI/WBP_HUD.WBP_HUD_C) or the asset path (/Game/UI/WBP_HUD, which auto-expands).

Default draw mode is screen-space; for a 3D billboard, set the component's Space to World.

5.13 AudioComponent type name

When adding an audio component to a Blueprint via reflection, the type name is Audio, not AudioComponent. Some servers' helpers handle either; raw reflection lookups don't. Sound asset assignment goes through the Sound UPROPERTY (a FObjectProperty); pass the sound asset's path as the value and the property handler resolves the load.

5.14 UltraDynamicSky: override booleans first

The UltraDynamicSky / UltraDynamicWeather plugin uses a "manual override" pattern. Each weather parameter (rain, snow, wind, etc.) has a companion bool flag named <Param> - Manual Override. The manual override bool must be set to `true` before setting the parameter value — otherwise the plugin's auto-weather logic overrides whatever you set on the next tick.

Other UltraDynamicSky notes:

• Spawn Ultra_Dynamic_Sky and Ultra_Dynamic_Weather at origin together.
• First spawn triggers 150+ shader compiles; visual output isn't reliable

until they finish.

• Conflicts with existing DirectionalLights — remove or hide them.
• Rain/snow particles render most visibly in PIE; editor viewport often

shows the sky but not the particle layer.

6. MCP transport requirements

6.1 Accept header on Streamable HTTP

Servers implementing MCP 2025-03-26 Streamable HTTP generally require both content types in the Accept header:

Accept: application/json, text/event-stream

Omit it and the server returns 406 Not Acceptable. Most MCP clients (Claude Desktop, Cursor, VS Code's MCP UI, Epic's EDA panel) set this automatically. Raw curl does not — pass -H 'Accept: application/json, text/event-stream' when testing manually.

6.2 Image content blocks

MCP supports an image content block alongside text:

{
  "content": [{
    "type": "image",
    "data": "<base64-encoded PNG>",
    "mimeType": "image/png"
  }]
}

The decoded bytes start with \x89PNG\r\n\x1a\n. Most MCP clients render images inline in the chat UI. UE5 servers commonly use this for editor viewport / PIE / depth captures.

6.3 Cancellation

MCP 2025-03-26 defines notifications/cancelled with a requestId parameter. Whether it actually aborts an in-flight tool call is server-dependent — synchronous servers can't interrupt themselves mid-execution. Don't depend on cancellation working unless the server documents support.

6.4 Sessions

Servers that implement the Mcp-Session-Id header expect clients to echo it back on subsequent requests in the same session. The server mints a fresh ID if the request arrives without one. Sessions usually expire on idle timeout — re-send initialize if the server returns "unknown session."

7. Python ↔ MCP data channel

UE's Python interpreter is reachable from most MCP servers via a console command (py <code>) or a dedicated execute_script tool. Python is the right hammer for:

• Bulk asset operations where the MCP surface lacks a vectorised tool
• Niagara parameter manipulation when the dynamic-input path is broken
• Sequencer batch edits
• Anywhere the agent needs N+1 operations that depend on each other and a

round-trip per dependency would be expensive

Critical limitation: Python's print() and stdout go to the UE log, not back to the MCP client. The agent that ran the script can't see what it produced.

Workaround — Actor Tags as a data channel:

import unreal
result = "...whatever the script produced..."
note = unreal.EditorLevelLibrary.spawn_actor_from_class(
    unreal.Note, unreal.Vector(0, 0, 9999)
)
# Keep tags short — UE truncates very long tag strings on save.
note.tags = [result[:200]]

Read back via MCP: query the Note actor's properties and inspect tags. Delete the Note actor after. Spawn a fresh actor for each result — stale actors return stale tags.

For larger payloads, write to a known file under Saved/Logs/ or Saved/AgentScratch/ and read it back via the MCP server's file-read tool (if available).

Server-side Python execution alternative: some MCP servers expose execute_script (or similar) that captures the return value of a run() function directly into the response. If your server has this, prefer it — the data-channel workaround becomes unnecessary.

8. Patterns for MCP server authors targeting UE5

If you're building an MCP server against the UE5 editor, the following patterns have proven valuable in practice. None are required by the MCP spec — they're hard-won pragmatic recommendations.

8.1 Schema-in-error self-correction

When a tool call fails input validation, return the tool's full input JSON Schema inline in the error text. The LLM caller reads the schema, fixes the argument, and retries. Saves 3–5 round-trips per error compared to a bare "Invalid argument" message.

{
  "isError": true,
  "content": [{
    "type": "text",
    "text": "Validation failed: 'body_type' must be one of [Skinny, Athletic, Heavyset]. Full schema:\n\n{...inputSchema JSON...}"
  }]
}

8.2 Output schema as authority

Ship an outputSchema for every introspection / read-only tool. Fields in the schema are guaranteed to appear; additional metadata fields may also appear but aren't promised. Clients can parse responses against the schema instead of guessing field names.

8.3 Continuation tokens for large responses

UE5 asset dumps can run hundreds of KB. MCP clients vary on how they handle large text content. Pattern: cap response text at N bytes (64KB is a reasonable default), stash the remainder under an opaque token, return token + first chunk + _remaining_chars so the client knows there's more. Expose a continue_response(token, max_bytes) tool to fetch the next chunk.

8.4 FScopedTransaction for mutating tools

Wrap every UPROPERTY write, asset edit, level mutation, or Blueprint graph change in FScopedTransaction. Ctrl+Z in the editor then reverts the agent's change — critical for user trust. Losing the undo path is the fastest way to make agents feel scary to work with.

8.5 Lazy tool registration for large surfaces

If your server exposes 200+ tools, the default tools/list response can overwhelm small-context-window clients. Pattern: split the surface into categories, default tools/list to a small set of meta-tools (list_categories, describe_category, load_category) plus a few always-on essentials, and load full categories on demand. Use notifications/tools/list_changed to signal subscribers when the visible surface changes.

8.6 Game-thread discipline

Slate operations, viewport rendering, asset operations, and Python execution must all run on the game thread. MCP requests typically arrive on a worker thread; dispatch the actual work back to the game thread via AsyncTask(ENamedThreads::GameThread, ...) and signal completion via a TPromise or similar. check(IsInGameThread()) defensively before any Slate / viewport call.

8.7 Recursion-cap the dumpers

Asset structures can contain cycles (Blueprint references, Material Functions, Sound Cues with self-referential branches). Always cap recursion depth (1024 is a safe default for graph walks). Always cap output size before returning. Always opportunistically GC any per-tool caches.

9. Patterns for MCP clients (agents)

9.1 Cache tools/list once per session

Tool surfaces are stable within a session. Cache the response on connect. Polling mid-session wastes round-trips and can confuse cancellation logic.

9.2 Parse against outputSchema when present

If the server publishes output schemas, validate against them instead of guessing field names. Saves debugging cycles when an agent assumes a field exists that doesn't, or doesn't notice a new field appearing in a later version.

9.3 Always verify writes

UE5 has too many silent-fail edges to trust a successful response. The full pattern:

1. Issue the write.
2. Issue a read of the same state.
3. Compare to what you asked for.
4. If they differ, re-examine (snake_case? wrong enum form? async-deferred?).

Verify-after-mutate is the difference between an agent that works 80% of the time and one that works 99%.

9.4 Treat isError: true as load-bearing

The MCP spec specifies tool errors return isError: true with the error text in content[0].text. Servers may also return JSON-RPC transport-level errors with the error field at the top level. Both need handling; both contain debugging info worth reading.

9.5 Don't chain a read after a write without saving

If a tool dumps an asset from disk, the dump reflects the on-disk state. If you just mutated the asset in memory and haven't saved, the dump shows the pre-mutation state. Save explicitly between mutate and dump if you need the current state.

10. UE 5.7 vs 5.8 — engine-level differences

These affect any agent driving UE5 across engine versions, regardless of MCP layer.

10.1 MovieRenderGraph is 5.8-only

UMovieGraphConfig, UMovieGraphPipeline, and graph-based rendering composition land in 5.8. UE 5.7 has MovieRenderQueue (UMoviePipelineQueueEngineSubsystem) but no graph composition layer.

10.2 FJsonObject::Values key type change

FJsonObject::Values is TMap<FString, ...> on 5.7 and TMap<UE::FSharedString, ...> on 5.8. Affects native C++ iteration; doesn't affect Python or JSON-over-the-wire usage.

10.3 PathTracer setting surface

Several PathTracer settings migrated from CVar-only to UPROPERTY on UPostProcessVolume in 5.8. An agent that sets them via console commands works on both engines; one that sets them via reflection on the post-process volume needs 5.8.

10.4 Epic's official ModelContextProtocol plugin is 5.8-only

Epic's MCP plugin ships in UE 5.8 (experimental). UE 5.7 users running an agent against the editor need a third-party MCP server.

10.5 Niagara editor module split

UE 5.8 reorganised some Niagara editor APIs into a NiagaraStackEditor module. Tools that introspect Niagara stack issues need to depend on the right module on each engine version.

11. Asset structure quick reference

What gets serialized when common UE5 assets are dumped to JSON. Useful for parsing responses regardless of which server produced them. This isn't an exhaustive schema — see Epic's UE docs for the authoritative structure.

Blueprint

• UbergraphPages — event graphs plus auto-generated wrappers
• FunctionGraphs — user-defined functions
• DelegateSignatureGraphs — dispatcher signatures
• MacroGraphs — user macros (if any)
• Variables — name, type, default value, CategoryName, RepNotifyFunc
• Components — SimpleConstructionScript root + AddedComponents
• ParentClass, implemented interfaces, compile state

Niagara System

• SystemSpawnScript / SystemUpdateScript — system-level VM scripts
• EmitterHandles — per-emitter wrapper (Enabled, LocalSpace, EmitterMode)
• UserParameters — parameters exposed to the component for runtime tuning
• Per-emitter: SpawnScript / UpdateScript / RenderScript stacks,

modules per stack, renderer settings

Material

• Expressions — UMaterialExpression* nodes (one per node in the graph)
• Connections — input pin → output pin pairs
• ScalarParameterValues, VectorParameterValues, TextureParameterValues
• ShadingModel, BlendMode, MaterialDomain

Level

• Actors — array of actor entries with name, class, transform, components
• WorldSettings — game mode, level scripts, navmesh settings
• Streaming — sublevels and their state (loaded / visible / unloaded)

Sequencer (ULevelSequence)

• MovieScene — root scene
• Tracks — per binding: TransformTrack, FloatTrack, EventTrack, etc.
• Sections per track — start/end frame, evaluation type, easing

Widget Blueprint

• WidgetTree — hierarchy of widgets (root, panels, leaf widgets)
• Per-widget: Slot properties (depend on parent panel type),

variable-or-not flag, accessibility text

• BindingClass — MVVM viewmodel class (if any)

12. Anti-patterns

12.1 Don't pass actor labels as identifiers

Two actors can share a label. The label is user-editable. Use the full path.

12.2 Don't poll tools/list mid-session

Tool surfaces are stable per session. Cache once on connect.

12.3 Don't assume tool surface parity across servers

Two MCP servers against UE5 will have different tool catalogues, different parameter names for similar concepts, and different output shapes. Always read tools/list to discover what's actually exposed before assuming a tool exists.

12.4 Don't ignore isError: true

The error message is usually load-bearing. Schema-in-error servers put the input schema right in there.

12.5 Don't chain reads after writes without a save (or explicit in-memory mode)

Most introspection tools serialize from disk. Mutation without save is invisible to those tools.

12.6 Don't assume async operations completed

Texture compile, Niagara compile, shader compile, asset save, package compile — all async. Poll completion or wait on the relevant delegate before continuing.

12.7 Don't delete a referenced asset

Check get_asset_references (or equivalent) first. Deleting referenced meshes/materials crashes the editor with RegisteredElementType.

12.8 Don't connect scalar nodes to Audio-typed pins in MetaSound

Runtime crash. Use audio buffer sources (Oscillators, Noise) into Audio pins. Scalar math (Multiply, Add) on the audio path goes through Audio variants of those nodes, not the float variants.

13. Reading list

• MCP specification — protocol-level reference
• Unreal Engine Python API reference — for unreal.* module surface
• Unreal Engine 5 Editor scripting — Epic's Python guide
• Niagara documentation — for Niagara-specific module / parameter concepts
• MetaSound documentation — for audio graph semantics

For server-specific tool catalogues, query the server with tools/list.

Version history