Skip to main content
Glama
unreal-ai-connection

unreal-ai-connection

by NAJEMWEHBE

Unreal AI Connection

Drive Unreal Engine 5.7 from any MCP-compliant client over a local TCP socket.

150+ tools. Zero pixel-clicking. ~50ms round-trip.

CI License Unreal Engine Python MCP Tools Changelog PRs Welcome

Unreal AI Connection — abstract geometric AI core on the left, orange data streams flowing right into a wireframe low-poly 3D landscape with mountains and a glowing river

Live demo: an MCP client procedurally builds a city in Unreal Engine 5.7, places Niagara FX, and orbits a camera

Live capture — an MCP client builds the scene, places Niagara FX (spawn_niagara_at_location), and orbits a camera, entirely over the local TCP socket. Reproduce with scripts/capture_demo_gif.py.

Native C++ handlers — not Python Remote Execution. ~50 ms round-trips across 150+ tools · MIT · works with any MCP-compliant client (Claude Code, Cursor, Cline, Codex, Gemini, Continue, Windsurf, Zed, …).

The suite now spans inspection and authoring — read existing assets and create them: actors, levels, data tables/assets, Blueprints (incl. K2 graph nodes), material graphs, Niagara FX, Level Sequence cinematics (camera cuts, audio, visibility), and Movie Render Queue renders — all over the same socket.

⭐ If this saves you time, a star helps other devs find it.

Authoring high-quality assets: see docs/ASSET-PIPELINE-BLENDER.md.


Install (one paste, any client)

Every route below only wires the stdio bridge. You must separately install the UE 5.7 plugin into your project's Plugins/ folder and launch the editor (it binds 127.0.0.1:18888). See docs/setup/README.md for the prerequisite, and docs/DISTRIBUTION.md for how this is published.

Claude Code — paste the owner/repo, no clone needed:

/plugin marketplace add NAJEMWEHBE/unreal-ai-connection
/plugin install unreal-ai-connection@unreal-ai-connection

The plugin starts the bridge with python3. On Windows that name can resolve to the Microsoft Store stub instead of Python (when where python3 lists a WindowsApps path first): if the server fails to start, install Python from python.org with "Add to PATH", or turn off the python3 alias in Settings > Apps > Advanced app settings > App execution aliases. A project .mcp.json can use py instead (docs/setup/claude-code.md).

Cursor — one-click deeplink. Base64-encode your machine's bridge path into this template:

cursor://anysphere.cursor-deeplink/mcp/install?name=unreal-ai-connection&config=<BASE64>

where <BASE64> is base64 of {"command":"python3","args":["/ABSOLUTE/PATH/TO/bridge/unreal_ai_connection_bridge.py"]} (on Windows use "command":"py" if python3 is not on PATH). Manual fallback — .cursor/mcp.json:

{ "mcpServers": { "unreal-ai-connection": { "command": "python3", "args": ["/ABSOLUTE/PATH/TO/bridge/unreal_ai_connection_bridge.py"] } } }

VS Code — install deeplink (URL-encode the JSON for your path):

vscode:mcp/install?<URL-ENCODED {"name":"unreal-ai-connection","command":"python3","args":["/ABSOLUTE/PATH/.../bridge/unreal_ai_connection_bridge.py"]}>

Windows: all snippets use python3; if that's not on PATH use the py launcher instead ("command": "py"). The .claude-plugin/mcp-config.json marketplace path uses python3 for cross-platform consistency — Windows users without python3 should use the manual per-client recipe in docs/setup/ with py.

Every other client — copy-paste recipe per client:

Client

Route

Recipe

Claude Code

/plugin marketplace add NAJEMWEHBE/unreal-ai-connection

docs/setup/claude-code.md

Claude Desktop

edit claude_desktop_config.json

docs/setup/claude-desktop.md

Cursor

deeplink / .cursor/mcp.json

docs/setup/cursor.md

Codex CLI

codex mcp add unreal-ai-connection -- …

docs/setup/codex-cli.md

Windsurf

mcp_config.json

docs/setup/windsurf.md

Continue

~/.continue/config.yaml

docs/setup/continue.md

Cline

MCP Marketplace tab / settings

docs/setup/cline.md

Zed

~/.config/zed/settings.json

docs/setup/zed.md

Gemini CLI

~/.gemini/settings.json

docs/setup/gemini-cli.md

VS Code Copilot

.vscode/mcp.json

docs/setup/vscode-copilot.md

Also discoverable in the official MCP Registry as io.github.najemwehbe/unreal-ai-connection (feeds the VS Code MCP gallery, mcp.so, PulseMCP) and submittable to the Cline marketplace via llms-install.md.


Related MCP server: unreal-engine-mcp

Jump to


How it fits together

graph LR
    A[Any MCP client] -->|stdio MCP| B[Python Bridge]
    B -->|TCP 127.0.0.1:18888| C[UnrealAIConnection plugin<br/>UE editor module]
    C -->|native C++ API| D[Unreal Editor 5.7]
sequenceDiagram
    participant User
    participant Client as MCP client<br/>(e.g. Claude Code)
    participant Bridge as Python bridge
    participant Plugin as UE plugin module
    participant Editor as Unreal Editor 5.7

    User->>Client: "Spawn a Cube at origin"
    Client->>Bridge: stdio MCP — tools/call spawn_actor
    Bridge->>Plugin: TCP 127.0.0.1:18888<br/>JSON-RPC framed
    Plugin->>Editor: GEditor->SpawnActor()
    Editor-->>Plugin: success + actor ref
    Plugin-->>Bridge: JSON-RPC result
    Bridge-->>Client: MCP envelope
    Client-->>User: rendered confirmation<br/>(~50ms total)

You ask Claude Code: "Take a screenshot of my level and tell me what's there." — Claude resolves the request to a tool call, the bridge forwards it as JSON-RPC to the running editor, the plugin captures the viewport, and Claude renders the image inline. Same flow works for spawning actors, inspecting Blueprints, mutating Widget Trees, executing arbitrary unreal.* Python, listing actors, focusing the viewport, loading levels, taking high-res screenshots.

The plugin binds to 127.0.0.1 only — your running editor is never reachable across the network.


Why it exists

UE 5.7's Python reflection has known dead-ends. Most painfully: EditorUtilityWidgetBlueprint.WidgetTree is a UPROPERTY() without EditAnywhere, so neither get_editor_property nor direct attribute access can reach it. This blocks "let an LLM build me an editor utility panel" workflows entirely.

The plugin sidesteps these limits by calling UE's native C++ APIs directly inside the editor process. It's also dramatically faster than driving UE's GUI with screenshot pixel-clicks — ~50ms round-trip vs. minutes of GUI fiddling.


Why MCP specifically

MCP (Model Context Protocol) is a vendor-neutral I/O protocol designed for LLM tool-use. Because this plugin speaks MCP rather than baking in any one client, every conforming client gets every tool for free: Claude Code, Codex CLI, Cursor, Gemini CLI, Continue, Zed, Cline, and any future entrant. Switch clients without changing the plugin or the bridge.

The wire format is stdio MCP between client and bridge, then a tight length-prefixed JSON-RPC over TCP 127.0.0.1:18888 between bridge and the running UE editor. Either side can be reimplemented in another language; the contract is the JSON.


Tools

150+ tools. Most are native C++ handlers registered by the plugin at editor startup; the rest are bridge-side synthetic tools (wait_for_events, get_camera_transform, set_camera_transform, screenshot_actor, compile_mod_pak, compile_mod_pak_direct, bulk_delete_assets, bulk_move_assets, bulk_rename_assets, bulk_duplicate_assets, bulk_inspect_assets, inspect_data_asset, inspect_sound_class, inspect_sound_submix, inspect_audio_bus, inspect_material_function, inspect_metasound, find_unused_assets, get_reference_chain, bulk_compile_blueprints, audit_blueprint_compile_status, find_actors_by_class, bulk_focus_actors, bulk_screenshot_actors, bulk_set_actor_property, compare_assets, bulk_set_console_variables, inspect_dependency_graph, bulk_fix_redirectors, marketplace_search, marketplace_import, convert_hdri_to_cubemap, sequencer_add_transform_keyframe, import_mesh, material_auto_remap, batch_capture_cameras, batch_spawn_from_csv) that compose existing handlers without a dedicated UE round-trip (or, for compile_mod_pak and compile_mod_pak_direct, shell out to RunUAT or UnrealPak entirely outside the UE process) — see bridge/unreal_ai_connection_bridge.py's SYNTHETIC_TOOLS. Per-tool JSON schemas and examples live in docs/TOOLS.md. Grouped overview:

Progressive tool disclosure (opt-in). Advertising 150+ schemas up front is a lot of context — past ~30–50 tools, model tool-selection accuracy and token cost both degrade (Anthropic Tool Search Tool, MCP discussion #532). Set the environment variable UCMCP_TOOL_MODE=progressive on the bridge and tools/list returns only a small core set (get_project_summary, list_tools, get_actors_in_level, execute_unreal_python, take_high_res_screenshot, get_viewport_screenshot, poll_events) plus a single search_tools discovery tool. The model calls search_tools(query="add a camera keyframe", category="sequencer") to pull the schemas of just the tools it needs, on demand. Every one of the 147 tools stays directly callable via tools/call in both modes — progressive mode changes only what is advertised, never what is dispatchable, so existing clients keep working. Default (unset / all) is the legacy expose-everything behaviour. search_tools runs entirely bridge-side (no UE round-trip), validates its input, and fails closed.

Python execution (5 tools)

Tool

Purpose

execute_unreal_python

Universal escape hatch — run arbitrary unreal.* Python in the editor's interpreter. Multi-line scripts work.

run_python_file

Execute a .py file from disk in the editor's Python interpreter.

apply_python_to_selection

Run a Python snippet with the editor's current selection bound as actors / assets.

exec_python_persistent

Persistent Python session — variables defined in one call survive into the next.

reset_python_state

Wipe the persistent session's globals.

Project / asset registry (10 tools)

Tool

Purpose

get_project_summary

Project name, engine version, enabled plugins, asset count.

find_assets

Query the asset registry by class + path + name.

inspect_asset

Class, tags, dependencies, referencers, on-disk size.

move_asset

Move an asset to a different folder; UE creates a redirector at the source path.

rename_asset

Change an asset's leaf name in place; UE creates a redirector at the old name.

duplicate_asset

Copy an asset to a new path.

delete_asset

Delete an asset; refuses if referenced by other packages unless force=true.

fix_up_redirectors

Resolve all object redirectors under a folder.

create_data_table

Create a new UDataTable asset whose rows conform to a given row UScriptStruct.

create_data_asset

Create a new UDataAsset (or subclass) asset from a UDataAsset subclass path.

Blueprint / widget / animation — introspection + authoring (20 tools)

Tool

Purpose

inspect_blueprint

Variables, function/event graphs, parent class of any Blueprint asset.

compile_blueprint

Recompile a Blueprint asset and report errors.

inspect_widget_tree

Read the widget hierarchy of a UWidgetBlueprint or EUW (the thing UE Python can't do).

inspect_widget_blueprint

Widget-BP-specific surface: animations, delegate bindings, palette category, inherited named slots, property-binding count, blueprint compile status. Pairs with inspect_blueprint + inspect_widget_tree.

edit_widget_tree

Mutate the tree: set_root / add_child / set_property. Solves the EUW WidgetTree blocker.

inspect_anim_blueprint

Read variables and state machines of an Animation Blueprint.

inspect_anim_montage

Read sections, slots, and notify tracks of an UAnimMontage.

inspect_static_mesh

LODs, materials, collision, bounds for a UStaticMesh.

inspect_skeletal_mesh

LODs, materials, sockets, skeleton info for a USkeletalMesh.

inspect_physics_asset

Body setups (one per simulated bone), constraint setups (joints between bodies), bounds-bodies subset, named physical-animation + constraint profiles. Cross-links to inspect_skeletal_mesh via preview_skeletal_mesh.

inspect_niagara_system

Emitters and exposed user parameters of a Niagara system.

inspect_landscape

Components, layers, and material info for a landscape actor.

inspect_data_table

RowStruct identity, sorted row names, per-property name+type for every FProperty on the row struct, plus client-strip / ignore-extra/missing-fields flags.

inspect_curve

UCurveBase channel layout (1ch UCurveFloat / 4ch UCurveLinearColor / 3ch UCurveVector), per-channel name + key count + per-channel + global time/value range.

create_blueprint

Create a new UBlueprint asset under /Game/ from a parent class (default /Script/Engine.Actor).

add_blueprint_variable

Add a typed member variable (bool/int/float/string/name/vector/rotator/transform/object) to an existing UBlueprint.

add_blueprint_function

Add a new empty function graph to an existing UBlueprint.

add_blueprint_node

Add a K2 node (call_function / variable_get / variable_set / branch) to a Blueprint event or function graph; returns the new node's GUID + pins.

connect_blueprint_pins

Wire two pins (exec or data) between nodes by GUID + pin name, via the schema-validated UEdGraphSchema_K2::TryCreateConnection.

set_blueprint_node_pin_default

Set a literal or object default on an input pin (verified by read-back).

Materials (6 tools)

Tool

Purpose

create_material_instance

Create a UMaterialInstanceConstant asset with a parent material set.

set_mi_parameter

Override a scalar/vector/texture parameter on a material instance. Type discriminator picks value shape.

inspect_material

List parameter names declared by a UMaterial or UMaterialInstance (scalar/vector/texture/static-switch).

inspect_material_instance

Read a material instance's parent + currently-overridden parameter values.

add_material_expression

Create a UMaterialExpression node inside an existing UMaterial's graph, then recompile the material.

connect_material_expression

Wire an expression's output to a material property input (property:BaseColor) or another expression's input (node:<ExprName>:<InputName>), then recompile.

Textures (3 tools)

Tool

Purpose

import_texture

Bring an image file (PNG / JPG / EXR / TGA / BMP / HDR) from disk into the project as a UTexture2D asset via UE's canonical import path.

configure_texture

Adjust SRGB / compression / LOD group / filter on an existing texture asset.

inspect_texture

Texture class, surface dimensions, sRGB, compression, filter, LOD group, mip-gen, virtual-texture / never-stream flags, composite-texture cross-link. UTexture2D-specific size / mips / pixel format / imported source dimensions emitted conditionally.

Level Sequences (9 tools)

Tool

Purpose

inspect_sequence

Read structure of a Level Sequence: tracks, sections, bindings, frame rate, playback range.

create_sequence

Create a new empty Level Sequence asset with a configured display rate and playback range.

bind_actor_to_sequence

Add a level actor as a possessable binding to a Level Sequence.

set_sequence_playback_range

Set a Level Sequence's playback start/end (display-rate frames).

add_cine_camera_to_sequence

Spawn an ACineCameraActor and add it as a possessable binding; returns the binding GUID (feed it to add_camera_cut_track).

add_camera_cut_track

Add (or reuse) the camera-cut track and bind a camera over a [start, end] frame range.

add_audio_track

Add a master audio track + sound section to a Level Sequence.

add_visibility_track

Add an actor-visibility track that keys an actor shown/hidden over time (inverted bHidden).

render_sequence_mrq

Async-render a Level Sequence (optional map override) to PNG / JPG / BMP / EXR via Movie Render Queue; returns a task_id (completion via poll_task).

Level / actor authoring (24 tools)

Tool

Purpose

get_actors_in_level

Name / class / transform of every actor; optional case-insensitive substring filter.

spawn_actor

Create an actor at a location with optional rotation, label, and initial properties. Class path supports built-ins and Blueprints.

set_actor_transform

Move / rotate / scale an existing actor by name. Absolute or relative mode.

delete_actor

Remove an actor by name. Force flag overrides children-attached safety check.

set_actor_property

Mutate any UPROPERTY on an actor. Supports primitives, FName/FText, vectors, rotators, colors, enums, and TSoftObjectPtr.

add_component

Attach a component (UActorComponent / USceneComponent subclass) to an existing actor at runtime, optionally socketed.

duplicate_actor

Clone an existing level actor (label or FName), optionally offset and relabel. Undoable (single Ctrl+Z).

set_actor_folder

Set an actor's World Outliner folder path (e.g. Lighting/Key); empty string moves it to the outliner root. Undoable.

rename_actor

Change an actor's World Outliner display label (SetActorLabel); the stable FName is unchanged. Undoable.

focus_actor

Select an actor by label and frame the viewport on it.

load_level_by_path

Open a level by package path.

create_level

Create a new empty level (UWorld) asset under /Game/ and open it as the active level.

build_lighting

Invoke a static-lighting build on the active editor world. Non-interactive; may take time on large levels.

spawn_niagara_at_location

Place a Niagara system in the level (ANiagaraActor + SetAsset) at a world transform; optional auto-activate. Undoable.

spawn_niagara_attached

Attach a Niagara system component to an existing actor, optionally socketed. Undoable.

set_niagara_user_param

Set a user-exposed Niagara parameter (float / vec3 / linear-color / bool) on a placed Niagara component, with type-match validation. Undoable.

find_actors_by_class

Filter the active level's actors by class. Composes get_actors_in_level and matches against the short class name. Bridge-side synthetic.

bulk_focus_actors

Frame the viewport on each actor in a sequence, optionally screenshotting each one. Composes focus_actor (+ get_viewport_screenshot) per name. Bridge-side synthetic.

bulk_screenshot_actors

Focus + screenshot each actor in a sequence. Composes screenshot_actor per name. Bridge-side synthetic.

bulk_set_actor_property

Apply many {actor, property, value} mutations in one call. Composes set_actor_property per assignment. Bridge-side synthetic.

compare_assets

Symmetric diff between two assets' inspect_asset outputs. Bridge-side synthetic.

bulk_set_console_variables

Set many CVars in one call with optional atomic rollback. Composes get_console_variable + set_console_variable. Bridge-side synthetic.

inspect_dependency_graph

BFS the asset dependency graph (down by default, optional bidirectional sweep). Composes inspect_asset recursively. Bridge-side synthetic.

bulk_fix_redirectors

Resolve redirectors across many content folders in one call. Composes fix_up_redirectors per folder. Bridge-side synthetic.

Viewport / screenshots (3 tools)

Tool

Purpose

get_viewport_screenshot

Active viewport as a PNG written to a project-confined disk path (throttle-proof fresh frame; optional small inline thumbnail).

take_high_res_screenshot

Trigger UE's HighResShot console command.

render_camera_to_png

Force a synchronous render of the level-editor viewport (or an off-screen SceneCapture2D at arbitrary resolution) and write a PNG — works headless where deferred screenshots fail.

Console / logs (5 tools)

Tool

Purpose

get_log_lines

Read recent UE Output Log entries from the in-process ring buffer. Filter by category and minimum verbosity.

execute_console_command

Run a UE console command (e.g. stat fps, r.ScreenPercentage 50) and capture its output.

get_console_variable

Read a single console variable's current value.

set_console_variable

Write a value to a console variable.

find_console_variables

Enumerate console variables matching a name pattern.

Long-running tasks (4 tools)

Tool

Purpose

start_sleep_task

Reference long-running task — sleeps for N seconds. Used to exercise the task pattern from clients.

poll_task

Read a task's current state / result.

cancel_task

Cancel an in-flight task by id.

list_tasks

Enumerate all tracked tasks and their states.

Event push / subscriptions (5 tools)

Tool

Purpose

poll_events

Drain queued editor events (actor spawn/delete, asset add/remove/rename/import, level save, map change) from the in-process EventBus.

wait_for_events

Bridge-side synthetic tool — block until matching events arrive or timeout_ms elapses, by polling poll_events at poll_interval_ms cadence.

register_subscription

Open a per-client subscription channel for a filtered event stream.

poll_subscription

Drain queued events from a specific subscription.

unsubscribe

Close a subscription.

Audio (3 tools — introspection trio)

Tool

Purpose

inspect_sound_cue

USoundCue duration, multipliers, attenuation cross-link, root sound-node class, full graph node list (sorted, with class taxonomy).

inspect_sound_wave

USoundWave sample rate, channels, frame count, duration, compression type + runtime format + compressed-data size, sound group, looping/streaming flags, loading behavior, subtitle + cue-point + loop-region counts. Editor-only LUFS / sample-peak / comment fields conditional.

inspect_sound_attenuation

USoundAttenuation 3D-playback rules: distance algorithm + shape, spatialization, air-absorption LPF/HPF, listener focus, occlusion tracing, reverb send, priority attenuation, plus assorted feature flags. Each major feature is gated by its master bitfield; sub-objects collapse to {enabled: false} when disabled.

Camera (3 tools — bridge-side synthetic)

Tool

Purpose

get_camera_transform

Read the level-editor viewport camera's location + rotation. Composes execute_unreal_python + get_log_lines via the marker pattern.

set_camera_transform

Set the level-editor viewport camera's location and/or rotation. Single execute_unreal_python round-trip.

screenshot_actor

Frame the viewport on a specific actor and capture a focused PNG. Composes focus_actor + get_viewport_screenshot.

Editor state / undo (2 tools)

Tool

Purpose

undo_transaction

Step the editor undo stack backward — the programmatic Ctrl+Z. Each mutating MCP edit (spawn/delete/transform/property/component) is one transaction, so this reverts the last such edit (or the last N via count).

redo_transaction

Step the editor undo stack forward — the programmatic Ctrl+Y. Re-applies transactions previously reverted by undo_transaction (or Ctrl+Z), up to count steps.

Self-introspection (1 tool)

Tool

Purpose

list_tools

Names of every registered method (for autodiscovery).

Adding the next C++ handler is one .cpp file plus one line of registration — see docs/ARCHITECTURE.md. New synthetic tools are an entry in SYNTHETIC_TOOLS plus a function in bridge/unreal_ai_connection_bridge.py.


Quick start

Engineers (you already build UE projects from source)

  1. Drop the plugin in. Copy UnrealAIConnection/ into <YourProject>/Plugins/.

  2. Regenerate project files. Right-click <YourProject>.uproject → Generate Visual Studio project files.

  3. Build the editor. Open the .sln, build Development Editor | Win64. First build takes ~5–15 min.

  4. Launch. Open the .uproject. The MCP server auto-starts on 127.0.0.1:18888. Look for these lines in the Output Log:

    [LogUnrealAIConnection] Module started
    LogUCMCPHandler: Registered handler 'execute_unreal_python'
      ... (85 more handler lines)
    [LogUCMCP] Listening on 127.0.0.1:18888
  5. Wire your MCP client. Copy examples/.mcp.json.example to your project root as .mcp.json, edit the path to point at bridge/unreal_ai_connection_bridge.py, restart your client, and approve the new MCP server. Same bridge works with Claude Code, Claude Desktop, Cursor, Codex CLI, Windsurf, Continue, Cline, Zed, Gemini CLI, and VS Code Copilot — see docs/setup/ for per-client copy-paste recipes.

Non-engineers / GUI-only users

See docs/INSTALLATION.md — step-by-step, screenshot-first.

Verify it works

The smoke test fires every default-on tool from a plain Python TCP client (not through Claude Code) — a fast way to confirm the plugin loaded and the server is alive:

python examples/smoke_test.py

You'll see structured JSON output for every default-on step (eleven banner-headed sections, plus a few unbannered checks for the asset registry, sequencer and materials handlers — the last two skip with a print if your project has no Level Sequences or Materials in /Game/). Last line: "Smoke test complete."


What's in the box

UnrealAIConnection/                The Unreal Engine plugin (drop into <Project>/Plugins/)
  Source/UnrealAIConnection/         C++ editor module
  Resources/                      MCP manifest JSON
  UnrealAIConnection.uplugin         Plugin manifest

bridge/
  unreal_ai_connection_bridge.py     Python stdio ↔ TCP bridge for any MCP client

examples/
  smoke_test.py                   Connects to the live server, fires the safe tools
  .mcp.json.example               Template Claude Code MCP config

docs/
  INSTALLATION.md                 Step-by-step install for a UE 5.7 project
  TOOLS.md                        What each tool does + JSON examples
  ARCHITECTURE.md                 How the pieces fit + UE 5.7 API gotchas

skills/
  driving-unreal/                 Bundled know-how skill — which tools to chain for common UE workflows (auto-discovered by MCP clients)

tests/                            Pytest suite for the bridge (no UE required)
.github/workflows/                CI runs the bridge tests on every push & PR

Status

Latest release

v0.9.1 — 2026-05-23

Tools

155 live — 118 native C++ handlers (one MCP method per Handler_*.cpp) plus 37 bridge-side synthetic tools (Python-only composition over existing handlers; never crosses the TCP wire as a dedicated round-trip). See docs/TOOLS.md for the per-tool reference.

Tested on

UE 5.7.4 / Windows 11 / Visual Studio Build Tools 2022 / MSVC 14.44 / NETFXSDK 4.8.1

Build status

Plugin compiles + loads against UE 5.7.4 host on Windows 11; every handler registers, TCP server binds 127.0.0.1:18888, bridge round-trip via tools/call list_tools returns full registry.

Bridge tests

pytest suite, ~99% coverage, no UE needed; the CI badge above shows the current run

CI

GitHub Actions on every push and PR

Maintenance

Active. Development paused 2026-07-03 and the repo was marked deprecated 2026-07-17; maintenance and new work resumed 2026-11-05. Issues and PRs are read again.

Development workflow

Multi-agent ensemble — Opus orchestrates, Codex authors C++, Sonnet handles Python + recon, NVIDIA cloud + local OSS LLMs run pre-PR diff review, Copilot CLI gives a second opinion, Gemini auto-review fires on every PR open. No single model gates a merge.

Roadmap / status honesty

One in-flight item is stated plainly here so nothing is oversold:

  • Officially built & tested on UE 5.7. Other UE versions are community / best-effort: the cross-engine compatibility scaffold lets you build from source for your engine version (uncertified, not actively maintained, contributions welcome). See ADR-0001 / docs/PHASE-H-COMPAT.md.

  • Engine 5.3 and older, from source: re-pin an engine-appropriate MSVC toolchain in your BuildConfiguration.xml (<CompilerVersion>); the maintainer's own pin is cleared (36th closing note in docs/HANDOFF.md).

  • Engine 5.6, host-certified from source: Built with MSVC 14.38 and smoke-tested live (all suites green) on a real 5.6 editor. No prebuilt 5.6 binaries are published: build from source as for 5.7. DMX note: the DMX tools need the optional UnrealAIConnectionDMX companion plugin, which pulls in the engine's DMXEngine + DMXProtocol; the core plugin loads without them.


What this is NOT

  • A general MCP server framework — this is bonded to UE's editor process.

  • A live-broadcast tool — for that, look at vMix, OBS, NDI Studio Monitor.

  • An Aximmetry / Pixotope / Disguise replacement — those have multi-engineer multi-year codebases.


Contributing

Issues and PRs welcome. Two house rules:

  1. Verify UE API claims against UE 5.7 source. Past reviewer subagents have made specific UE API claims that turned out wrong; ground-truth the engine source before committing.

  2. Each new MCP handler is one Handler_*.cpp file in Source/UnrealAIConnection/Private/MCP/Handlers/, plus one extern declaration and one Reg.Register(Make_Handler_*()) line in UnrealAIConnectionModule.cpp. Don't grow the foundation — add handlers.

Running tests

Bridge unit tests run without UE in under a second:

pip install pytest pytest-cov
pytest tests/

CI runs the same suite on every push and PR (see .github/workflows/tests.yml). The live integration smoke test in examples/smoke_test.py requires a running UE editor — see tests/README.md.


License

MIT — see LICENSE. © 2026 HD Media (Kuwait).

Available Tools

105 tools
add_componentA

Attach a component (UActorComponent or USceneComponent subclass) to an existing actor at runtime, optionally socketed and transformed relative to a parent component.

Inputs: actor_name (required), class_path (required), component_name, attach_to, +2 more.

apply_python_to_selectionA

Run user Python with the editor's current selection pre-bound: selection (selected level actors) and selected_assets (selected content-browser assets). Convenience wrapper around execute_unreal_python that injects the lookup boilerplate. Same output-capture caveat: ExecuteFile mode does not return stdout; use unreal.log marker + get_log_lines.

Inputs: code (required).

audit_blueprint_compile_statusA

Enumerate every Blueprint under a content path and report its compile-status bucket (UpToDate/Dirty/Error/Unknown/BeingCreated). Composes find_assets + inspect_blueprint bridge-side. This is a READ-ONLY audit (no recompile triggered); pair with bulk_compile_blueprints to actually fix anything found.

Inputs: path_under, compile_failures_only.

bind_actor_to_sequenceB

Add a level actor as a possessable binding to a Level Sequence. Creates the binding GUID and wires it to the live actor.

Inputs: sequence_path (required), actor_name (required).

bulk_compile_blueprintsA

Recompile multiple Blueprints in one MCP call by composing the compile_blueprint C++ handler bridge-side. Returns per-path success/failure plus aggregate counts. Mirrors the bulk_*_assets family shape (paths list + continue_on_error). Useful after batch-mutating BPs via execute_unreal_python or other tooling.

Inputs: paths (required), continue_on_error.

bulk_delete_assetsA

Delete multiple assets by composing the delete_asset C++ handler bridge-side. Returns per-path results plus aggregate counts. By default continues after individual failures (partial success is normal); set continue_on_error=false to stop on first failure. SYNTHETIC bridge-side handler.

Inputs: paths (required), continue_on_error.

bulk_duplicate_assetsA

Duplicate multiple assets in one call by composing the duplicate_asset C++ handler bridge-side. Schema mirrors bulk_rename_assets's per-entry mapping but uses dest_path (full destination path) instead of new_name (leaf name) since duplicate_asset takes a full destination, not a folder + name split. Unlike rename/move, duplicate does NOT leave a redirector at the source -- the source is preserved at its current path and a new copy is created at dest_path. Returns per-entry results plus aggregate counts. SYNTHETIC bridge-side handler.

Inputs: duplicates (required), continue_on_error.

bulk_fix_redirectorsA

Resolve UObjectRedirector stubs across multiple content folders in one MCP call. Composes fix_up_redirectors per folder. Useful as a follow-up to a sweep of bulk_move_assets / bulk_rename_assets calls (each of which leaves redirectors at the source paths) so the LLM does not have to issue one fix_up_redirectors per touched folder.

Inputs: folders (required), recursive, continue_on_error.

bulk_focus_actorsA

Frame the viewport on each actor in a sequence, optionally capturing a screenshot after each focus settles. Composes focus_actor (plus, when screenshot_each=true, get_viewport_screenshot) per name. Useful for 'show me each enemy / spawn / light in turn' walkthroughs where one screenshot_actor at a time would force the LLM into a polling loop.

Inputs: names (required), delay_ms, screenshot_each.

bulk_inspect_assetsA

Inspect multiple assets in one MCP call by composing the inspect_asset C++ handler bridge-side. Returns per-path inspection data plus aggregate counts; partial failures isolated per result. Mirrors the bulk_*_assets family shape. Use for pipeline audits (e.g. enumerate 500 textures and report which lack a power-of-two source).

Inputs: paths (required), continue_on_error.

bulk_move_assetsA

Move multiple assets into a single destination folder by composing the move_asset C++ handler bridge-side. Each move leaves a redirector at the source per UE's standard move semantics. Returns per-path results plus aggregate counts. By default continues after individual failures (partial success is normal); set continue_on_error=false to stop on first failure. SYNTHETIC bridge-side handler — mirrors bulk_delete_assets's shape so client code can switch between the two with a one-tool-name change.

Inputs: paths (required), dest_folder (required), continue_on_error.

bulk_rename_assetsA

Rename multiple assets in one call by composing the rename_asset C++ handler bridge-side. Each rename leaves a redirector at the source per UE's standard semantics. Schema differs from bulk_delete_assets / bulk_move_assets: takes a renames list of {path, new_name} objects so each asset gets a per-entry leaf name. Returns per-entry results plus aggregate counts. Mirrors the bulk_*_assets result-shape convention. SYNTHETIC bridge-side handler.

Inputs: renames (required), continue_on_error.

bulk_screenshot_actorsA

Frame and screenshot each actor in a sequence. Composes screenshot_actor (which itself composes focus_actor + get_viewport_screenshot) per name. Same shape as bulk_focus_actors but always captures a PNG — convenient for thumbnail-pipeline runs where every actor in a list needs a deterministic centered shot.

Inputs: names (required), delay_ms.

bulk_set_actor_propertyA

Apply many UPROPERTY mutations across many actors in one MCP call. Composes set_actor_property bridge-side; mirrors the bulk_*_assets family shape (assignments list + continue_on_error). Each assignment specifies its own {actor, property, value} so this is NOT 'set the same property on N actors' — it's 'run N individual sets'. Useful after batch-spawning to push initial-state mutations without N round-trips.

Inputs: assignments (required), continue_on_error.

bulk_set_console_variablesA

Set multiple Console Variables in one MCP call with optional atomic rollback. Composes get_console_variable (to capture each pre-value) plus set_console_variable (to apply each new value); on any per-cvar failure when rollback_on_error=true, the synthetic walks back every applied change to its captured pre-value. Mirrors the editor's 'apply scalability set then revert if any fail' pattern, with an explicit rollback failure list so callers know which restores themselves failed.

Inputs: assignments (required), rollback_on_error.

cancel_taskA

Request COOPERATIVE cancellation of a running task. Sets the task's atomic flag; the worker observes it on its next polling iteration (~50ms) and exits cleanly to status='cancelled'. UE has no safe forced-thread-termination, so workers that don't poll the flag run to completion regardless. Idempotent: returns ok=true with accepted=false for unknown ids and already-terminal tasks.

Inputs: task_id (required).

compare_assetsA

Symmetric diff between two assets' inspect_asset outputs. Composes inspect_asset bridge-side on both paths and returns the fields that differ. Useful for 'what changed between these two versions of the same blueprint?' walkthroughs and for cross-checking duplicated assets that should be identical. The path field is excluded from comparison (trivially different between the two inputs).

Inputs: path_a (required), path_b (required), fields.

compile_blueprintA

Explicit Blueprint recompile via FKismetEditorUtilities::CompileBlueprint. Use when a BP has been mutated externally (e.g. via execute_unreal_python) and needs to be recompiled without further mutation. Pairs with edit_widget_tree's compile=true flag.

Inputs: path (required), skip_save.

compile_mod_pakA

Compile a UE mod plugin to a .pak file via RunUAT BuildMod (game Dev Kits like Conan Exiles) or BuildPlugin (vanilla UE5), headless. No UE Editor session required. Especially useful for game Dev Kits in 'installed-build mode' where BuildPlugin is blocked (e.g. Conan Exiles Enhanced UE5) — falling back to BuildMod cleanly. BuildMod path produces a .pak in output_dir; BuildPlugin path produces a redistributable plugin package (no .pak generated by default — ok=true based on exit_code alone).

Inputs: project_path (required), output_dir (required), mod_name, plugin_path, +4 more.

compile_mod_pak_directA

Compile a UE5 mod into a .pak by invoking UnrealPak.exe directly with a response file, bypassing RunUAT entirely. Use when the Dev Kit's RunUAT BuildMod is broken (Funcom Conan Exiles Enhanced UE5 ships a ScriptModules manifest invalid-record bug — UAT deletes its own deps.json before BuildMod can run). Pre-condition: caller has already cooked the .uasset files (e.g. via execute_unreal_python on a running Editor, or a separate UnrealEditor-Cmd.exe -run=Cook pass). UnrealPak is a standalone UE binary and works regardless of UAT state — runs in seconds and produces a .pak that deploys directly to the server's Mods// folder. Complements compile_mod_pak (which uses RunUAT); use compile_mod_pak_direct when UAT is broken on your Dev Kit. SYNTHETIC bridge-side handler.

Inputs: unreal_pak_path (required), response_file (required), output_pak (required), compression, +2 more.

configure_textureA

Adjust SRGB/CompressionSettings/LODGroup/Filter on an existing UTexture asset and persist the change. Triggers UE's standard PreEditChange/PostEditChange flow and rebuilds the GPU resource.

Inputs: path (required), srgb, compression, lod_group, +2 more.

convert_hdri_to_cubemapA

Convert a longlat-projection HDRI (UTexture2D) into a UTextureCube so it can drive a SkyLight's SpecifiedCubemap slot. SYNTHETIC bridge-side handler. Pipeline: spawn an inside-out sphere with the HDRI as an unlit emissive material, capture it with a SceneCaptureCube into a TextureRenderTargetCube, then materialize the static UTextureCube via RenderingLibrary.render_target_create_static_texture_cube_editor_only. Temp render-target + temp material + temp actors are cleaned up before return. Closes the 23rd HANDOFF note's HDRI cubemap parked item.

Inputs: hdri_path (required), dest_path, dest_name, cube_size, +1 more.

create_material_instanceB

Create a UMaterialInstanceConstant asset and set its parent to an existing UMaterial or UMaterialInstance.

Inputs: parent_path (required), path (required), name (required).

create_sequenceA

Create a new Level Sequence asset. Initializes an empty MovieScene with the given display frame rate and playback end-frame.

Inputs: path (required), name (required), display_rate_fps, playback_end_frames.

delete_actorA

Remove an actor from the editor world by name (label or FName). Children are detached, not destroyed (UE's default behavior). Force flag overrides the children-attached safety check.

Inputs: name (required), force.

delete_assetA

Delete an asset. Refuses if referenced by other packages unless force=true. WARNING: deletion is permanent within the project; force-delete cannot recover via Undo.

Inputs: path (required), force.

duplicate_assetA

Copy an asset to a new path. Source asset is preserved; destination must not already exist. No redirector is created (callers reference the duplicate by its new path).

Inputs: path (required), dest_path (required).

edit_widget_treeA

Mutate a widget tree. ops: set_root | add_child | set_property. Solves UE 5.7 EUW WidgetTree population.

Inputs: path (required), op (required), class, name, +5 more.

exec_python_persistentA

Tier 2 PR #45: like execute_unreal_python but state PERSISTS across calls. Variables, imports, and function/class definitions defined in one call are visible in the next -- letting Claude build up state across turns without re-loading every time. Implemented via UE's FPythonCommandEx with FileExecutionScope=Public (shared globals dict with the editor's Python console). Pairs with reset_python_state. Same output-capture caveat as execute_unreal_python: ExecuteFile mode does not capture stdout via CommandResult; use unreal.log marker + get_log_lines.

Inputs: code (required).

execute_console_commandA

Run a UE console command (e.g. 'stat fps', 'r.ScreenPercentage 50') and optionally capture its output. Executes on the game thread in the editor world context.

Inputs: command (required), capture_output.

execute_unreal_pythonA

Run arbitrary unreal.* Python in the editor's embedded interpreter (universal escape hatch). Multi-line scripts allowed.

Inputs: code (required).

find_actors_by_classA

Filter the current level's actors by class. Composes get_actors_in_level bridge-side and matches each actor's short class name against the supplied class_name (accepts either a short name like 'StaticMeshActor' or a class path like '/Script/Engine.StaticMeshActor' — the synthetic strips the path prefix and matches case-insensitively). Useful for 'find every light' / 'find every spawn point' walkthroughs without forcing the LLM to grep through a thousand-actor get_actors_in_level dump.

Inputs: class_name (required), level.

find_assetsA

Query the asset registry by class + optional path + optional name substring + optional tag filters. Returns matching assets with structured records (name, package_path, class[, tags]).

Inputs: class_path (required), path_under, name_contains, limit, +2 more.

find_console_variablesA

Prefix-search the IConsoleManager registry; returns matching CVar names + types + read-only flags. Pairs with get_console_variable / set_console_variable for discovery workflows. C++ handler -- direct iteration of UE's internal console registry. Part of the language-shim experiment (PR #46): see docs/LANGUAGE-CHOICE-RETROSPECTIVE.md.

Inputs: prefix, limit.

find_unused_assetsA

Enumerate assets under a content path and report which have zero referencers (i.e. nothing in the project references them). Composes find_assets + inspect_asset bridge-side. Useful for content cleanup audits before shipping. Returns the first limit unused assets and a truncated flag when more remain.

Inputs: path_under, class_filter, limit.

fix_up_redirectorsA

Cascade-update consumers of UObjectRedirector assets under a folder, then delete the now-redundant redirector .uasset stubs. Cleans up after move_asset / rename_asset workflows. Mirrors the editor's right-click 'Fix Up Redirectors in Folder'.

Inputs: path (required).

focus_actorB

Select an actor by label or unique name and frame the editor viewport on it.

Inputs: name (required).

get_actors_in_levelA

Return name/class/transform of every actor in the active editor world. Optional name_contains filter.

Inputs: name_contains.

get_camera_transformA

Read the level-editor viewport camera transform. SYNTHETIC bridge-side handler (PR #46 language-shim experiment): composes execute_unreal_python + get_log_lines via the marker pattern. Returns { location: {x,y,z}, rotation: {pitch,yaw,roll} }.

Inputs: no named parameters.

get_console_variableA

Read a UE Console Variable by name. Returns the current value in all four representations (string/int/float/bool), the detected type (int|float|bool|string), the read-only flag, and the human-readable last-setter (e.g. 'Console', 'DeviceProfile'). Distinct from execute_console_command: this reads CVar state directly, never invokes the console exec engine.

Inputs: name (required).

get_engine_versionA

Structured engine-version snapshot — major / minor / patch / changelist / branch as separate fields, plus a 'minor_dotted' convenience like '5.7'. Use this when the LLM needs to branch on engine version without parsing get_project_summary's single 'engine_version' string.

Inputs: no named parameters.

get_log_linesA

Read recent UE Output Log entries from the in-process ring buffer. Supports category substring filter and minimum verbosity filter. Returns up to count lines (default 100, max 1000) at or above the requested severity.

Inputs: count, category_filter, min_verbosity.

get_project_summaryA

Project name, engine version, enabled plugins, asset counts.

Inputs: no named parameters.

get_reference_chainA

Walk the asset reference graph BFS from a root, returning every node and edge up to a depth bound. Composes inspect_asset recursively. direction=up follows referencers (who references me) — useful for impact-of-change analysis before deleting/renaming. direction=down follows dependencies (what I reference) — useful for dependency audits before packaging.

Inputs: path (required), depth, direction.

get_selected_actorsA

Return name/label/class/transform of every actor currently selected in the editor's World Outliner / viewport. Companion to apply_python_to_selection — lets the LLM observe what is selected before running code against it.

Inputs: no named parameters.

get_viewport_screenshotA

Capture the active editor viewport as a PNG, return base64-encoded inline.

Inputs: no named parameters.

import_textureA

Import an image file (PNG/JPG/EXR/TGA/BMP/HDR) from disk into the project as a UTexture2D asset, using the canonical UE asset import pipeline.

Inputs: source_path (required), dest_path (required), dest_name, replace_existing, +2 more.

inspect_anim_blueprintA

Read structural properties of a UAnimBlueprint asset: parent class, target skeleton, template flag, baked state machines, anim functions (with implemented flag), sync groups, parent anim blueprint chain. C++ handler -- guards UAnimBlueprintGeneratedClass for null (compiled data is empty / is_compiled=false when the blueprint has never been compiled). No new Build.cs deps (Engine module already present).

Inputs: path (required).

inspect_anim_montageA

Read structural properties of a UAnimMontage asset: target skeleton, play length, frame rate (rational), blend envelope (in/out times + auto-blend trigger), composite sections (with start/end times and next-section linkage), slot animation tracks, notify events. C++ handler; no new Build.cs deps (Engine module covers it). Completes the animation introspection trio with inspect_anim_blueprint and inspect_skeletal_mesh.

Inputs: path (required).

inspect_assetA

Read everything the asset registry knows about a single asset: class, all registry tags, dependency packages, referencer packages, on-disk file size.

Inputs: path (required).

inspect_audio_busA

Inspect a UAudioBus by package path: returns leaf class name, package path, audio_bus_channels enum stringified (Mono/Stereo/Quad/FivePointOne/SevenPointOne), and additional editor-accessible UPROPERTYs discovered via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.

Inputs: path (required).

inspect_blueprintA

Read parent class, declared variables, function/event graph names, and compile status (UpToDate/Dirty/Error/Unknown/BeingCreated) of a Blueprint asset.

Inputs: path (required).

inspect_curveA

Read structural properties of a UCurveBase asset (UCurveFloat / UCurveLinearColor / UCurveVector / any subclass): curve class, channel count, global time + value range, and per-channel name + key count + per-channel time/value range. Channel layout: UCurveFloat = 1 channel, UCurveLinearColor = 4 (RGBA), UCurveVector = 3 (XYZ). C++ handler; no new Build.cs deps (Engine covers UCurveBase / FRichCurve).

Inputs: path (required).

inspect_data_assetA

Shallow-reflect a UDataAsset by package path and return class, parent class, package path, and editable property list (name, Python type, stringified value). SYNTHETIC bridge-side handler (PR #92 language-shim experiment): composes execute_unreal_python + get_log_lines via the marker pattern. Property values for nested structs / arrays / dicts are stringified as 'container:type' or '' — no recursion. Logical errors (asset not found, marker buffer overflow, payload unparseable) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.

Inputs: path (required).

inspect_data_tableA

Read structural properties of a UDataTable: RowStruct asset path + name, row count, sorted row names (FName.ToString), per-property name+type for each FProperty on the RowStruct (TFieldIterator with EFieldIterationFlags::None to skip super fields), client-strip flag, missing/extra-field tolerance flags, optional ImportKeyField. C++ handler; no new Build.cs deps (Engine + CoreUObject cover UDataTable / UScriptStruct / FProperty). Null-guards RowStruct (freshly-created DataTables can have no struct assigned).

Inputs: path (required).

inspect_dependency_graphA

Walk the asset dependency graph BFS from a root (dependencies, downward by default). Composes inspect_asset recursively; optionally also follows referencers (upward) for a bidirectional sweep. Distinct from get_reference_chain in that it defaults to direction=down (dependencies, packaging-audit framing) and supports a single bidirectional pass instead of forcing two separate calls. De-duplicates visited nodes across both directions.

Inputs: path (required), depth, include_referencers.

inspect_input_mappingsA

Dump the project's legacy UInputSettings: action_mappings (name+key+modifier flags) and axis_mappings (name+key+scale), plus a uses_enhanced_input flag that signals whether the project has migrated to the Enhanced Input system. The #1 context an LLM needs before touching gameplay code.

Inputs: no named parameters.

inspect_landscapeA

Read structural properties of an ALandscape (a SCENE ACTOR, not an asset): component dimensions, total component count across loaded streaming proxies, landscape material, world-space bounds, both LandscapeGuid (mutates on PIE/instancing) and OriginalLandscapeGuid (stable). Lookup by actor label or GUID; if neither is given and exactly one landscape exists, that one is returned. Diverges from sibling Inspect* handlers (which take asset paths) because UE landscapes have no .uasset.

Inputs: name, guid.

inspect_materialA

List parameter names declared by a UMaterial or UMaterialInstance: scalar, vector, texture, and static-switch parameters.

Inputs: path (required).

inspect_material_functionA

Inspect a UMaterialFunction by package path: returns leaf class name, package path, description, expose_to_library flag, library_categories (stringified Text values), function inputs (name + input_type enum stringified), function outputs (name), and additional editor-accessible UPROPERTYs via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes.

Inputs: path (required).

inspect_material_instanceA

Read a UMaterialInstanceConstant's parent + currently-overridden parameter values (scalar/vector/texture).

Inputs: path (required).

inspect_metasoundA

Inspect a MetaSoundSource or MetaSoundPatch asset by package path: returns leaf class name (which of the two it is), package path, and additional editor-accessible UPROPERTYs via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Accepts either MetaSoundSource (emitter-attached) or MetaSoundPatch (reusable subgraph). Graph structure (nodes / connections) is NOT reflected here -- that requires a dedicated traversal pass. For surface-level metadata + exposed UPROPERTYs the permissive enumeration covers the common case. Logical errors (asset_not_found, wrong_asset_type, metasound_unavailable, marker_not_found, invalid_json) return as ok=False success envelopes.

Inputs: path (required).

inspect_niagara_systemA

Read structural properties of a UNiagaraSystem asset: emitter list (name + enabled + mode), user-exposed parameter list, system-level settings (looping, GPU usage, warmup + tick params when needed, fixed bounds, effect type). C++ handler -- requires Niagara runtime module + EnsureFullyLoaded() before reading lazy-loaded data.

Inputs: path (required).

inspect_physics_assetA

Read structural properties of a UPhysicsAsset: preview skeletal mesh cross-link, body setups (one per simulated bone with bConsiderForBounds + is_in_bounds_subset flags), constraint setups (joint between two bodies with child/parent bone names), bounds-bodies subset count, named physical-animation profiles, named constraint profiles. Pairs with inspect_skeletal_mesh via shared preview_skeletal_mesh path. C++ handler; no new Build.cs deps (Engine + PhysicsCore cover UPhysicsAsset / USkeletalBodySetup / UPhysicsConstraintTemplate). Null-skips TObjectPtr and TObjectPtr entries (PR #55->#57 lesson).

Inputs: path (required).

inspect_project_settingA

Reflect any UDeveloperSettings subclass (RendererSettings, PhysicsSettings, InputSettings, etc.) and dump editable UPROPERTY values as JSON. Bulk mode (omit 'property') returns every editable property; single mode (pass 'property') returns just that one. Closes the gap where the LLM had no access to per-system Project Settings.

Inputs: settings_class (required), property.

inspect_sequenceB

Read structure of a Level Sequence asset: tracks, sections, bindings, frame rate, playback range.

Inputs: path (required).

inspect_skeletal_meshA

Read structural properties of a USkeletalMesh asset: per-LOD vertex / triangle / section counts, bounding box (min/max/size/center) + sphere radius, target USkeleton, total + raw bone counts, material slots, morph targets (count + names), clothing assets, physics asset. C++ handler; no new Build.cs deps (Engine module covers it). Mirrors inspect_static_mesh's bounds shape for cross-handler consistency.

Inputs: path (required).

inspect_sound_attenuationA

Read structural properties of a USoundAttenuation asset (3D playback rules): distance algorithm + shape, spatialization, air-absorption LPF/HPF, listener focus, occlusion tracing, reverb send, priority attenuation, plus a feature_flags sub-object for assorted bool toggles. Each major feature group is collapsed to {"enabled":false} when its master gate (bAttenuate / bSpatialize / bAttenuateWithLPF / bEnableListenerFocus / bEnableOcclusion / bEnableReverbSend / bEnablePriorityAttenuation) is off, so the JSON stays compact for default-disabled assets. Completes the audio introspection trio with inspect_sound_cue + inspect_sound_wave. C++ handler; no new Build.cs deps (Engine covers USoundAttenuation / FSoundAttenuationSettings / FBaseAttenuationSettings).

Inputs: path (required).

inspect_sound_classA

Inspect a USoundClass by package path: returns leaf class name, package path, parent USoundClass asset path (for chaining), child USoundClass asset paths, and the editable FSoundClassProperties values (Volume, Pitch, low-pass filter, attenuation distance scale, voice-center-channel volume, radio-filter volume, eight boolean flags, OutputTarget enum). SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. UE Python field names are snake_case but the JSON output remaps to UE's native PascalCase FSoundClassProperties layout. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.

Inputs: path (required).

inspect_sound_cueA

Read structural properties of a USoundCue asset: total duration, max distance, volume + pitch multipliers, subtitle priority, max audible distance, attenuation-settings cross-link, root sound-node class, and the full graph of sound nodes (sorted by name with class taxonomy). C++ handler; no new Build.cs deps (Engine covers USoundCue / USoundBase / USoundNode / USoundAttenuation). Null-skips TObjectPtr entries (PR #55->#57 lesson).

Inputs: path (required).

inspect_sound_submixA

Inspect a USoundSubmix by package path: returns leaf class name, package path, parent USoundSubmix asset path (for chaining), child submix asset paths, and additional editor-accessible UPROPERTYs discovered via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.

Inputs: path (required).

inspect_sound_waveA

Read structural properties of a USoundWave asset: sample rate, channel count, frame count, duration, compression type + runtime format + (conditional) compressed data size, sound group, looping flag, streaming flag (via IsStreaming() not the deprecated bStreaming), loading behavior, subtitle count + supports flag, cue-point count + loop-region count (separated via GetCuePoints / GetLoopRegions). Editor-only fields (imported_sample_rate, lufs, sample_peak_db, comment) emit conditionally when non-default. C++ handler; no new Build.cs deps (Engine covers USoundWave / USoundBase / FSoundWaveCuePoint / FSubtitleCue). USoundWave's LoadBehavior=LazyOnDemand caveat handled by reading only declarative fields (no transient runtime state).

Inputs: path (required).

inspect_static_meshA

Read structural properties of a UStaticMesh asset: LOD count, per-LOD vertex/triangle counts, bounding box, material slots. Pairs with inspect_asset (registry metadata) and inspect_material (parameters). C++ handler -- benefits from native struct access. Part of the language-shim experiment (PR #46).

Inputs: path (required).

inspect_textureA

Read structural properties of a UTexture asset (UTexture2D / UTextureCube / UTextureRenderTarget / UTexture2DArray / ...): texture class, surface dimensions (width/height/depth via virtual accessors), sRGB, compression settings, filter, LOD group, LOD bias, mip-gen settings, virtual-texture streaming flag, never-stream flag, composite-texture cross-link. UTexture2D-specific: size_x / size_y / num_mips / pixel_format / imported_size_x|y. Pairs with the existing configure_texture handler (mutates these fields) and import_texture (creates the asset). C++ handler; no new Build.cs deps (Engine covers UTexture / UTexture2D / EPixelFormat).

Inputs: path (required).

inspect_widget_blueprintA

Read UWidgetBlueprint-specific structural properties: parent class, blueprint compile status, palette category, animations (with start/end/length and binding count), delegate property bindings, inherited named slots from parent class, and the property-bindings count. Complements inspect_blueprint (variables + graphs, inherited from UBlueprint) and inspect_widget_tree (widget hierarchy); cross-link via shared asset path. C++ handler; no new Build.cs deps (UMG + UMGEditor already present).

Inputs: path (required).

inspect_widget_treeB

Read the widget hierarchy of a UWidgetBlueprint or UEditorUtilityWidgetBlueprint.

Inputs: path (required).

list_levelsA

Enumerate every UWorld asset (level) in the project. Optional path_under defaults to '/Game/'; optional name_contains is case-insensitive substring filter. Closes the gap where load_level_by_path required the caller to already know the package path.

Inputs: path_under, name_contains.

list_tasksA

Enumerate all tasks in the FUCMCPTaskRegistry with optional status / type filters and a limit. Atomic snapshot under the registry's lock so the result is internally consistent. Returns total/matched/returned counts plus task records mirroring poll_task's shape.

Inputs: status_filter, type_filter, limit.

list_toolsA

Return the names of every registered MCP method on the UE server.

Inputs: no named parameters.

load_level_by_pathB

Load a UE level by package path, e.g. /Game/Maps/MyMap.

Inputs: path (required).

marketplace_importA

Download a CC0 asset from a marketplace (Polyhaven or AmbientCG) and import it into the project as a UTexture2D via the native import_texture handler. SYNTHETIC bridge-side handler. Polyhaven path: /files/{slug} catalog lookup -> direct download. AmbientCG path: /api/v2/full_json?id={slug}&include=downloadData -> downloads the per-resolution zip -> extracts the Color map (textures) or sole EXR/HDR (hdris) -> hands the file to import_texture. Supports texture (Color/Diffuse map) and hdri (EXR/HDR); model import is parked for a later PR (native handler has no mesh-import wrapper today). When multi_map=true is passed (texture only), the handler additionally pulls Normal/Roughness/AO/Displacement/Metalness when the source ships them — each map lands as a separate UTexture2D named <dest_name>_<map> (Color stays at <dest_name> for back-compat). Asset files: both sources are CC0 (public domain, no attribution required). API access: the Polyhaven public API is licensed for non-commercial and academic use only — commercial integrations require a custom license from Poly Haven (https://polyhaven.com/our-api). AmbientCG's public API and asset files are both CC0.

Inputs: slug (required), source, asset_type, resolution, +5 more.

move_assetA

Move an asset to a different folder; leaf name unchanged. UE auto-creates a redirector at the source path.

Inputs: path (required), dest_folder (required).

pie_controlA

Start / stop / query Play-In-Editor sessions. Closes the 'did my edit actually work?' loop — LLM can scaffold a gameplay change, trigger PIE, observe the running state, then stop. action=start with mode=play|simulate; action=stop tears down current session; action=query returns is_playing + is_simulating booleans.

Inputs: action (required), mode.

poll_eventsA

Tier 2 entrypoint: drain editor events fired since the caller's last poll. Today UE pushes events from a starter set of delegates (actor_spawned, actor_deleted, asset_added) into a 1000-entry ring buffer (FUCMCPEventBus); this handler returns the slice with seq >= since_seq (inclusive cursor), capped at max_count. First call: pass since_seq=-1 (default) to discover the current next_seq, then poll with the previous response's next_seq for steady-state delta consumption. Response includes 'dropped' flag if the caller's since_seq fell below the oldest buffered event (i.e. buffer overflowed between polls).

Inputs: since_seq, max_count, event_filter.

poll_subscriptionA

Drain events for a server-side subscription. Per-sub cursor advances atomically with the read -- a successful poll never returns the same events twice. No since_seq param (cursor is server-side); no event_filter param (filter was set at register_subscription time and is immutable for that sub -- re-register if you need a different filter).

Inputs: subscription_id (required), max_count.

poll_taskA

Read current state of a task started via any start_*_task handler. Non-blocking: returns the registry snapshot and never waits for the task to advance. Status: pending | running | completed | cancelled | failed. Result populated when status=completed; error populated when status=failed.

Inputs: task_id (required).

register_subscriptionA

Tier 2 PR #43: create a server-side cursor + filter on the FUCMCPEventBus. Returns a subscription_id (FGuid string) usable with poll_subscription (drain matched events) and unsubscribe (release). The cursor starts at the bus's current next_seq -- subscribers see events fired AFTER subscription, not historical ones. PR #43 ships subscriptions WITHOUT TTL: they live until explicit unsubscribe.

Inputs: event_filter.

rename_assetA

Rename an asset's leaf name; folder unchanged. UE auto-creates a redirector at the old name.

Inputs: path (required), new_name (required).

render_camera_to_pngA

Force a synchronous render of the level-editor viewport (or an off-screen SceneCapture2D at arbitrary resolution) and write it to an absolute path as a PNG. Works headless/backgrounded where deferred screenshots fail.

Inputs: out_path (required), width, height, camera_label, +1 more.

reset_python_stateA

Clear all user-defined names from UE Python's public (shared-with-console) globals dict. Pairs with exec_python_persistent: lets Claude wipe accumulated state and start fresh without restarting the editor. Names starting with '_' (Python dunders + conventional private) are preserved. Imports the user explicitly added (e.g. 'import unreal') ARE cleared -- re-import in the next exec_python_persistent call.

Inputs: no named parameters.

run_python_fileA

Execute a .py file from disk via the editor's embedded Python. Complement to execute_unreal_python -- avoids escaping pain for non-trivial scripts. Output capture caveat: ExecuteFile mode does not return stdout/eval-result; use unreal.log marker + get_log_lines to round-trip results.

Inputs: path (required).

save_dirty_assetsA

Persist every in-memory-modified asset + map to disk. Same as editor 'Save All'. Closes the gap where edit-side tools (set_actor_property, set_mi_parameter, edit_widget_tree, etc.) mutated UObjects but left them dirty. Optional include_levels + include_content default to true.

Inputs: include_levels, include_content.

screenshot_actorA

Frame the editor viewport on an actor (by label or unique name) and capture a focused PNG screenshot. SYNTHETIC bridge-side handler: composes focus_actor + get_viewport_screenshot. Returns base64 PNG plus the focused actor's identity and world location.

Inputs: name (required).

sequencer_add_transform_keyframeA

Add a single keyframe on a Level Sequence's 3D Transform Track for a previously-bound actor. SYNTHETIC bridge-side handler. Closes the keyframe-authoring half of the 21st HANDOFF note's Sequencer parked item: create_sequence + bind_actor_to_sequence already exist; this tool wires up MovieSceneSequenceExtensions.find_binding_by_id + MovieSceneBindingProxy.add_track + MovieSceneScriptingDoubleChannel.add_key. Caller passes location/rotation/scale as optional 3-element triples; missing triples skip those channels. Rotation order is [pitch, yaw, roll] (unreal.Rotator convention) — mapped internally to the channel layout (Roll=X, Pitch=Y, Yaw=Z). Movie Render Queue remains parked.

Inputs: sequence_path (required), binding_id (required), time_seconds (required), location, +4 more.

set_actor_propertyA

Mutate any UPROPERTY on an actor. v0.4.0 supports primitives, all common UE structs, enums, TSoftObjectPtr, plus USTRUCT (recursive)/TArray/TMap (string-keyed)/TSet/FObjectProperty (hard UObject pointers via asset path). Property names accept dotted-path syntax for nested traversal (e.g. 'RootComponent.RelativeLocation'). FInstancedStruct deferred to v0.4.x.

Inputs: name (required), property (required), value (required).

set_actor_transformA

Move / rotate / scale an existing actor by name (label or FName). Supports both absolute and relative modes.

Inputs: name (required), location, rotation, scale, +1 more.

set_camera_transformC

Set the level-editor viewport camera transform. SYNTHETIC bridge-side handler (PR #46 language-shim experiment): single execute_unreal_python round-trip. All location/rotation fields are optional and default to 0.

Inputs: location, rotation.

set_console_variableA

Mutate a UE Console Variable by name. 'value' is polymorphic: string, number, or bool. Issues the change at ECVF_SetByConsole priority (matches user-typed-in-console semantics) so it overrides ini files and code-set values. Pre-rejects ECVF_ReadOnly CVars (those silently no-op after early init) with a clear error, and post-verifies the change landed.

Inputs: name (required), value (required).

set_mi_parameterA

Override a scalar/vector/texture parameter on a UMaterialInstanceConstant. Type discriminator: 'scalar' -> number, 'vector' -> {r,g,b,a}, 'texture' -> asset path string.

Inputs: path (required), parameter (required), type (required), value (required).

spawn_actorA

Create an actor in the current editor world at a location with optional rotation, label, and initial properties. Class path can be built-in (/Script/Engine.StaticMeshActor) or Blueprint (/Game/Blueprints/BP_X.BP_X_C).

Inputs: class_path (required), location, rotation, label, +1 more.

start_sleep_taskA

Tier 2 PR #44 framework tracer: spawn a background task that sleeps for duration_ms then completes. Returns immediately with a task_id; poll via poll_task or cancel via cancel_task. Useful by itself for 'wait N ms and then do something' workflows; primary purpose is to exercise the FUCMCPTaskRegistry threading + cancellation paths. Hard cap on duration_ms is 1 hour.

Inputs: duration_ms (required).

take_high_res_screenshotA

Trigger UE's HighResShot. Output -> Saved/Screenshots/Editor/ (Windows/Mac/Linux). Optional multiplier (1..8).

Inputs: multiplier.

unsubscribeA

Remove a subscription created via register_subscription. Idempotent: calling on an unknown id returns ok=true with was_present=false rather than an error, so callers can blanket-unsubscribe on shutdown without worrying about partial state.

Inputs: subscription_id (required).

wait_for_eventsA

Bridge-side composition of poll_events: repeatedly polls UE every poll_interval_ms until matching events arrive or timeout_ms expires. Implemented in the bridge (not as a UE handler) so the wait runs in this Python process -- UE's game thread keeps running between polls and game-thread events (actor_spawned, map_changed, etc.) actually fire during the wait. Same response shape and cursor semantics as poll_events, plus a 'timed_out' field. Default timeout 500ms; hard cap 30000ms (30s).

Inputs: timeout_ms, poll_interval_ms, since_seq, max_count, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 105 tools

    Disambiguation3/5

    Most tools are clearly separated by resource type (inspect_sound_*, inspect_blueprint, etc.), but several execution families overlap: execute_unreal_python / exec_python_persistent / run_python_file / apply_python_to_selection all run Python, and get_viewport_screenshot / screenshot_actor / take_high_res_screenshot / render_camera_to_png all capture images. Detailed descriptions mitigate the ambiguity, but an agent could easily misselect without reading carefully.

    Naming Consistency4/5

    The server mostly follows a clean verb_noun snake_case pattern, with excellent family consistency in inspect_*, bulk_*, set_*, and poll_* tools. Minor deviations exist: pie_control and unsubscribe are single verbs, sequencer_add_transform_keyframe breaks the verb-first ordering, and some verbs alternate between get_ and inspect_ for similar read operations.

    Tool Count1/5

    105 tools is an extreme surface, far beyond the 16-25 'heavy' range and even the 50+ extreme-mismatch bar. While Unreal Editor is a broad domain, this many tools creates severe context-window and selection burden, and many tools could be condensed into parameterized families or folded into the Python escape hatch.

    Completeness4/5

    The toolset is exceptionally broad: asset inspection/mutation, actor control, level sequencing, audio, niagara, materials, Python execution, console variables, events, marketplace import, and even mod packaging. Missing creation/lifecycle tools for many asset types and the lack of Blueprint graph editing are genuine gaps, but they are workable around via execute_unreal_python and the extensive bulk/batch helpers.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Unreal Engine 5.7 editor plugin that gives AI assistants full read/write access to Blueprints, Materials, Animation, Niagara, Config, and more via MCP. 119 actions across 9 domains, pure C++, embedded Streamable HTTP server.
      375
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      An MCP server that gives AI agents broad control over Unreal Engine 5.7, enabling actor/asset/level management, Blueprint and material creation, screenshots, automation, and arbitrary editor Python execution.
      35
      MIT