Ue5 MCP

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.
2. 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.
3. 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.
4. 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).
2. Property->ImportText_Direct(RequestedValue, Scratch, Owner, PPF_None) to canonicalize what was requested.
3. Property->ExportTextItem_Direct(ExpectedText, Scratch, ...) for the canonical form of "what we asked for."
4. Apply the write, then Property->ExportTextItem_Direct(ActualText, ...) for "what we got."
5. 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.

2.7 Enum-string resolution has three accepted forms

UENUM-defined enums store their entries as fully-qualified FName forms like EAutoExposureMethod::AEM_Manual. UEnum::GetValueByNameString matches the fully-qualified form, but bare short names (AEM_Manual) and the Python-binding casing the unreal module exposes (AEM_MANUAL from unreal.EAutoExposureMethod.AEM_MANUAL) silently miss — those are the forms agents most naturally reach for, especially when copying values out of dump_post_process_settings output or Python docs.

A 3-step resolver covers the common cases:

int64 ResolveEnumValue(UEnum* Enum, const FString& Name)
{
    if (!Enum) return INDEX_NONE;
    int64 Val = Enum->GetValueByNameString(Name);            // EEnumType::ShortName
    if (Val != INDEX_NONE) return Val;
    Val = Enum->GetValueByName(FName(*Name));                // FName lookup
    if (Val != INDEX_NONE) return Val;
    const int32 N = Enum->NumEnums();                        // case-insensitive
    for (int32 i = 0; i < N; ++i)                            // suffix-after-::
    {
        FString EntryName = Enum->GetNameStringByIndex(i);
        int32 ColonPos = INDEX_NONE;
        if (EntryName.FindLastChar(TEXT(':'), ColonPos))
            EntryName = EntryName.RightChop(ColonPos + 1);
        if (EntryName.Equals(Name, ESearchCase::IgnoreCase))
            return Enum->GetValueByIndex(i);
    }
    return INDEX_NONE;
}

Affects every reflection-driven property setter that accepts enum-typed JSON strings (FEnumProperty, FByteProperty whose Enum field is populated, properties resolved via StaticEnum<...>()). The 1-step form Enum->GetValueByNameString(Name, EGetByNameFlags::CaseSensitive) is the most fragile — it rejects everything except the fully-qualified form. The fallback chain trades a tiny scan cost (enums rarely have more than a few dozen entries) for actually accepting the strings callers pass in.

The same pattern applies on the agent side: when calling an MCP tool that takes an enum-named string, prefer the C++ short form (AEM_Manual) — it's accepted by every resolver that follows even minimal best practice; the Python-binding uppercase form may not be.

When resolution misses, list the valid values in the error. Returning "unsupported type or value coercion failed" and nothing else forces the caller to grep engine source for the enum's entries. The same NumEnums() / GetNameStringByIndex() iteration that backs the case-insensitive fallback also gives you the discovery surface — trim each entry to its short name (after the last ::), skip the auto-generated _MAX terminator, and join the rest into the error string:

TArray<FString> ValidNames;
const int32 N = Enum->NumEnums();
for (int32 i = 0; i < N; ++i)
{
    FString EntryName = Enum->GetNameStringByIndex(i);
    int32 ColonPos = INDEX_NONE;
    if (EntryName.FindLastChar(TEXT(':'), ColonPos))
        EntryName = EntryName.RightChop(ColonPos + 1);
    if (EntryName.EndsWith(TEXT("_MAX")))
        continue;
    ValidNames.Add(EntryName);
}
// "Could not apply 'X' (enum EAutoExposureMethod). Valid values:
//  AEM_Histogram, AEM_Basic, AEM_Manual. (Case-insensitive; C++ short
//  name, not Python display name.)"

The error message becomes self-documenting: any agent that calls the tool with an invalid string immediately sees the valid set in the response. No round-trip through engine source. This pairs naturally with the resolver above — same iteration, same _MAX filter, used for discovery instead of resolution.

2.8 Actor "properties" may live on the RootComponent, not the AActor

A reflection-driven property setter that only walks Actor->GetClass() silently misses the properties that look actor-level in the editor but are actually stored on the RootComponent (a SceneComponent). The member-of-component set includes Mobility, bHidden, bVisible, RelativeLocation, RelativeRotation, RelativeScale3D, AreaClass, and the other SceneComponent transform/visibility fields.

The failure mode is hostile: the setter returns success-shaped (the property name is real, and the JSON value coerced cleanly), the call log shows "property_name": "Mobility", "applied": true, but a follow-up read returns the old value. There's no error, no deprecation warning, no typo suggestion — just a write that went into the void because the writer aimed at the wrong UObject.

Fix: when the property isn't found on Actor->GetClass() and the caller didn't pin a specific component, fall back to the RootComponent's class:

UClass* TargetClass = Actor->GetClass();
void*   TargetPtr   = Actor;

FProperty* Prop = TargetClass->FindPropertyByName(*PropertyName);
if (!Prop && Actor->GetRootComponent())
{
    USceneComponent* Root = Actor->GetRootComponent();
    if (FProperty* RootProp = Root->GetClass()->FindPropertyByName(*PropertyName))
    {
        Prop        = RootProp;
        TargetClass = Root->GetClass();
        TargetPtr   = Root;
    }
}

Surface which container actually received the write in the response (target_object: "Actor" | "<ComponentName>"). Without that hint, a caller debugging "why didn't the mobility change?" has no clue whether the fallback fired or whether the original Actor-level write succeeded on a same-named property. The silent-magic failure mode is worse than the original wart — the call now appears to work but you can't tell where the change landed.

The same pattern applies to other SceneComponent-resident sets — light intensity / color on light components, mesh on StaticMeshComponent, etc. Those usually have explicit component-targeting parameters in MCP surfaces, so the silent-miss mode there is rarer, but the fallback is the right default for any property setter accepting an actor name without an explicit component scope.

2.9 A mutation without Modify() isn't "undoable but with one field missing" — it's not in the undo history at all

FScopedTransaction wraps a block of editor code as one undo step, but the transaction only actually contains an object if that object's Modify() was called before it changed. An empty transaction — every object in scope mutated via a raw setter or direct FProperty write that skipped Modify() — is discarded as transient rather than pushed onto the undo stack (verified against UE 5.8's EditorTransaction.cpp). The failure mode isn't "Ctrl+Z reverts everything except this one field" — it's "Ctrl+Z does nothing at all for this entire edit," with no error and no indication anything was skipped. A human editing the same property through the Details panel gets a working undo step for free (the panel's property handle calls Modify() for you); a tool that reaches past the UI and writes the property directly does not, unless it calls Modify() itself.

The rule: call Modify() on the object before the mutation, not after — it snapshots pre-mutation state, so calling it post-hoc records nothing useful.

// Wrong: SetMobility doesn't call Modify() itself, so this mutation
// never enters the transaction — Ctrl+Z after this silently does nothing.
RootComponent->SetMobility(EComponentMobility::Movable);

// Right:
RootComponent->Modify();
RootComponent->SetMobility(EComponentMobility::Movable);

For a transform-style write that touches both the actor and its root component, Modify() both — matching whichever object's state the engine actually reads back on undo:

Actor->Modify();
Actor->GetRootComponent()->Modify();
Actor->SetActorTransform(NewTransform);

Not every mutator needs this. High-level engine entry points that are themselves undo-aware self-record when a transaction is active — UWorld:: SpawnActor and AActor::Destroy() both record into GUndo automatically (verified in engine source), so wrapping a spawn/destroy in an outer FScopedTransaction needs no extra Modify() call. The gap is specifically low-level setters (SetMobility, SetIntensity, a generic reflected FProperty write via ImportText_Direct / CopyCompleteValue) that mutate state directly without going through an undo-aware wrapper.

If you're auditing an existing surface for this bug, look for "it built, it ran, the response said success" as the tell — this is not a crash or an error-returning bug, so it never shows up in normal QA. The only way to catch it is to explicitly test Ctrl+Z (or the transaction system's equivalent) after every mutating call and confirm the specific property you changed actually reverts — not just that undo doesn't crash.

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.

5.15 Sequencer: extending the playback range doesn't extend track sections

UMovieScene::SetPlaybackRange(...) updates the scene's logical playback range, but per-track sections (created by AddNewCameraCut, AddSection on a TransformTrack, FloatTrack, etc.) keep their original lengths. The camera cut track section in particular bounds what Movie Render Queue actually renders — MRQ stops at the end of the active camera cut section regardless of the playback range. Symptom: a sequence whose GetPlaybackRange() reports 12 s renders only the first 5 s; the returned image count matches the section length, not the playback range.

After extending the playback range, iterate every track on every binding and call SetRange on every section:

const TRange<FFrameNumber> NewRange = MovieScene->GetPlaybackRange();
for (UMovieSceneTrack* Track : MovieScene->GetTracks())                       // master tracks
    for (UMovieSceneSection* Sec : Track->GetAllSections()) Sec->SetRange(NewRange);

if (UMovieSceneTrack* CutTrack = MovieScene->GetCameraCutTrack())             // camera cut
    for (UMovieSceneSection* Sec : CutTrack->GetAllSections()) Sec->SetRange(NewRange);

for (const FMovieSceneBinding& B : MovieScene->GetBindings())                 // per-binding tracks
    for (UMovieSceneTrack* T : B.GetTracks())
        for (UMovieSceneSection* Sec : T->GetAllSections()) Sec->SetRange(NewRange);

Symmetrically: shrinking the playback range while leaving sections long is also a no-op for MRQ (sections still play to their end). If you want "playback range and sections always match," apply the same loop on every range mutation. Real-world failure mode: a sequence's playback range and its camera cut section's range drift over a series of edits and the next render silently uses whichever happens to be shorter.

5.16 Sequencer: channel keys at the same time stack instead of replacing

FMovieSceneDoubleChannel::AddLinearKey(FrameNumber, Value) and the equivalent on FMovieSceneFloatChannel append a key to the channel's time-sorted array even if a key already exists at FrameNumber. The MovieScene tracks both keys as separate entries; on interpolation, the first-found one can shadow the just-added one — silently producing the wrong animated value. Re-keying the same time looks like a successful no-op.

Detect and update in place via the channel's TMovieSceneChannelData wrapper:

TMovieSceneChannelData<FMovieSceneDoubleValue> Data = Channel->GetData();
const int32 ExistingIdx = Data.FindKey(FrameNumber);     // exact-frame match
if (ExistingIdx != INDEX_NONE)
{
    TArrayView<FMovieSceneDoubleValue> Values = Data.GetValues();
    FMovieSceneDoubleValue Updated = Values[ExistingIdx];
    Updated.Value = NewValue;                            // preserves tangent / interp
    Values[ExistingIdx] = Updated;
}
else
{
    Channel->AddLinearKey(FrameNumber, NewValue);
}

FindKey has an optional InTolerance parameter (FFrameNumber(0) by default) for inexact matches. The same pattern applies to FMovieSceneFloatChannel / FMovieSceneFloatValue, FMovieSceneIntegerChannel, and FMovieSceneBoolChannel — each Channel->GetData() returns the matching TMovieSceneChannelData<T> wrapper.

For 3D transform sections specifically, channel-proxy index order is [0-2] Translation X,Y,Z, [3-5] Rotation X,Y,Z (where X=Roll, Y=Pitch, Z=Yaw), [6-8] Scale X,Y,Z. All nine channels need the same set-or-replace treatment when re-keying a transform — there's no top-level helper that does all nine at once.

5.17 Sequencer: save the sequence package before MRQ re-reads it

Movie Render Queue's PIE executor re-loads the level sequence package from disk when it spawns PIE. In-memory edits to the MovieScene (playback range changes, transform keys, camera bindings, sub-sequences, etc.) that haven't been flushed to disk via UPackage::SavePackage are lost — the render uses the stale on-disk version even though LoadObject<ULevelSequence>(SeqPath) returns the in-memory copy. The result is a successful-looking render that doesn't reflect the most recent edits.

This is a sequence-asset specialisation of the general "save before reading from disk" rule (see §2.4) — MRQ counts as a from-disk reader because the PIE world it spawns reloads the sequence asset fresh. Save the sequence's outermost package before kicking the render:

UPackage* SeqPkg = Seq->GetOutermost();
if (SeqPkg && SeqPkg->IsDirty())
{
    const FString Filename = FPackageName::LongPackageNameToFilename(
        SeqPkg->GetName(), FPackageName::GetAssetPackageExtension());
    FSavePackageArgs Args;
    Args.TopLevelFlags = RF_Public | RF_Standalone;
    Args.SaveFlags = SAVE_NoError;
    UPackage::SavePackage(SeqPkg, Seq, *Filename, Args);
}

Same hazard applies to any authoring → MRQ chain where the on-disk state diverges from the in-memory state — camera cuts, sub-sequence bindings, shot tracks, etc. Saving the level alone (FEditorFileUtils::SaveCurrentLevel) does not cover this; /Game/... sequence assets live in their own packages.

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.

8.8 .uplugin's "Optional": true describes a build-time relationship, not a runtime one — and doesn't survive contact with a data symbol

If your MCP-server plugin wraps a big optional engine subsystem (Niagara, GameplayAbilities, MetaHuman, Mutable/CustomizableObject, MovieRenderPipeline) so it builds clean whether or not that subsystem is enabled, the standard recipe is: reference it in .uplugin with "Optional": true, gate the Build.cs dependency behind a plugin-presence check, and #if-guard the code that uses it. That recipe closes the build-time gap. It does not by itself close the runtime gap.

The trap: if the optional plugin was present when you built, your binary now hard-links against it — "Optional": true only told UBT "don't fail the build if this is absent," it did not make the resulting .dll's imports soft. Drop that binary into a project where the optional plugin is disabled and the OS loader fails to resolve those imports at mount time (GetLastError=126 on Windows), with no useful diagnostic pointing at which optional dependency is the culprit.

The standard fix is /DELAYLOAD (MSVC) — defer resolving the DLL's imports until first actual use, so a build that never calls into the optional module never needs to load it. This works cleanly for function calls. It does not work for direct references to an exported data symbol — a global UClass*, a static const FName, an extern in the optional module's headers — because /DELAYLOAD indirects function calls through a thunk it generates, but a data-symbol reference compiles to a direct memory address that has to be resolved at link time; there's no thunk mechanism for it. If your #if-guarded code touches one of those instead of exclusively calling functions, the linker fails outright (MSVC LNK1194-class error) even with delay-loading correctly configured — and the fix isn't "configure delay-loading harder," it's "don't reference the data symbol at all outside the guard, or wrap access to it behind a function the optional module itself exports."

Practical rule: before assuming "Optional": true + delay-load has made a dependency fully soft, audit every symbol your #if-guarded code touches from the optional module and confirm none of them are exported globals/statics — function-only access is the only shape /DELAYLOAD actually covers. And test runtime disable, not just build success — "builds clean without the plugin present" and "loads clean in a project where the plugin is present-but-disabled" are two different claims, and only the second one is what an end user actually hits.

8.9 macOS: a too-minimal test project can hard-crash a `LoadingPhase:

…(truncated)