ue-bridge
This server is an MCP bridge that lets AI agents and scripts inspect and control a live Unreal Engine game running UE4SS.
Status & discovery:
bridge_statuschecks whether a game is running and the mod is answering;world_inforeports the current world, player controller, pawn, game instance, and game mode.Object inspection:
find_object,find_objects,list_types,inspect_object,list_functions,get_propertylet you resolve references and read reflected properties, functions, and loaded types.Runtime manipulation:
set_property,call_function,console_command, andeval_lua(raw Lua with full UE4SS API) can modify the live game—subject toallow_writes/allow_evalsettings.Snapshots & diffs:
snapshot_object,diff_object,list_snapshots,forget_snapshotlet you record property walks and detect what changed over time.Event streams:
watch_propertysamples properties on a timer,hook_functionrecords UFunction calls, andpoll_eventsdrains the recorded events;list_streams/stop_streammanage active streams.World interaction:
targeted_actorline-traces from the camera (or another actor) to see what is being looked at;list_subclassesenumerates derived classes.Utilities:
reload_modre-reads settings without restarting the game,batchruns multiple operations in one round trip, anddumptriggers UE4SS dumpers (usmap, jmap, uht, cxx, actors, objects, static_meshes).
Provides live inspection and manipulation of Unreal Engine games through UE4SS, including object browsing, property reading, function calls, Lua evaluation, and snapshots.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ue-bridge run Lua to get my character's current health and location"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ue4ss-bridge
Live engine inspection and an MCP bridge for UE4SS games. Inspect objects, invoke functions, run Lua, and connect AI coding agents (Claude Code, Claude Desktop, Cursor, Codex, any MCP client) to the running game, without restarting it.
Developer tool, not a gameplay mod. The mod changes nothing on its own and adds no gameplay content. It is a communication bridge for mod authors, reverse engineers and developers who want external scripts or AI coding agents to interact with the live engine while it runs.
Two parts, released separately:
Part | What | Where it goes |
UEBridge (Lua mod) | Polls | The game: |
ue4ss-bridge (Python) | An MCP server and CLI that write those files and read the answers. Finds the running game by itself. | Your machine: |
What it does
UEBridge runs queries on the game thread of the running game, with no relaunch per question:
AI coding agents (MCP). Connect Claude Code, Claude Desktop, Cursor, Codex or any Model Context Protocol client to the running game.
Live object inspection. Find live instances of a
UClass, read every reflected property and its current value, list theUFunctions on the class chain.Runtime manipulation. Set properties, call
UFunctions with arguments, evaluate raw Lua.Snapshot and diff. Keep a property walk under a label, play, then ask what changed.
Event streams. Watch properties on a timer or hook a
UFunction, then poll the recorded events.Class hierarchy and aim. List every loaded subclass of a base class; line-trace from the camera to find out what the player is looking at.
Engine commands and dumps. Run console commands or trigger the UE4SS dumpers (
usmap,jmap,uht,cxx,actors,objects,static_meshes) programmatically.
Related MCP server: Roblox Executor MCP Server
How it works and the security model
AI agent / script -> ue4ss-bridge (MCP stdio or HTTP, or CLI) -> request.json
UEBridge mod: ExecuteInGameThread
ue4ss-bridge <- response.json <-File-based IPC:
Every 50 ms the in-game Lua loop checks for
request.jsoninue4ss\bridge\.When one appears, the request runs on the game thread via
ExecuteInGameThread.The result is written to
response.json.
Security and privacy
No open network sockets or ports.
No background daemon or subprocess execution.
No downloads, no telemetry, no changes to the game binary, no admin rights.
Only software already running on your PC with write access to the game folder can talk to it.
Compatibility. Game-agnostic: any Unreal Engine title running UE4SS. UEBridge registers no
hooks of its own; its Lua runs entirely through engine-thread execution, so it is unaffected by
the hook settings of your UE4SS build. hook_function registers a UE4SS hook only for the
function you name, and only while you ask for it. Verified on:
The Lantern of the Laughless Saint (Steam build, UE 5.8, project
The_Holy_Fool)The Blood of Dawnwalker (Steam build, UE 5.5.4)
Renamed from ue-bridge
Why. The old name collided with grapeot/ue-bridge, an Unreal Editor TCP bridge.
What changed. The PyPI package is ue4ss-bridge, the Python module is ue4ss_bridge, and the
command is ue4ss-bridge. Environment variables are UE4SS_BRIDGE_GAME_DIR and
UE4SS_BRIDGE_DATA_DIR.
What did not. The mod folder is still ue4ss\Mods\UEBridge\, settings.lua keeps its keys and
its place, the UEB helper table keeps its name, the log prefix is still [UEBridge], and the
request/response file layout is unchanged.
Nothing to update. ue-bridge is still installed as a command alias, so an existing MCP
client config keeps launching. The old environment variable names are still read. pip install -U ue-bridge keeps working: that package is now a stub that depends on ue4ss-bridge.
Requirements
UE4SS installed for your game.
Python 3.10+ (only for the CLI or MCP server;
uvxhandles it for you).
Install the mod
1. Extract. Extract the release zip into the folder that holds the ue4ss folder and the
game executable:
<game>\<Project>\Binaries\Win64\The archive carries the folder path, so the files land in ue4ss\Mods\UEBridge\ on their own.
No mods.txt edit: the included enabled.txt turns the mod on.
2. Verify. Launch the game and check ue4ss\UE4SS.log for:
[UEBridge] v1.2.1 ready3. Uninstall. Delete ue4ss\Mods\UEBridge\ and, if present, ue4ss\bridge\.
Configuration (scripts\settings.lua)
That copy always wins. A settings.lua at the mod root (where 1.0.0 put it) is read only when
scripts\ has none, and the mod logs one line naming it as ignored when both exist, so delete
the root file after an in-place upgrade. Edit, save, then ue4ss-bridge reload (or the reload_mod
tool), or restart the game.
Key | Default | Effect |
|
|
|
|
|
|
|
|
|
|
| request file check interval in milliseconds (50 is the floor; lower values are clamped) |
| unset | absolute path override for the request/response folder |
Connect a tool or an AI agent (the MCP server)
The program that writes and reads the IPC files is ue4ss-bridge, a Python package. It
finds any running UE4SS game on its own (an exe in a Binaries\Win64 folder with ue4ss\ beside
it), so there are no paths to configure. Pass --game-dir or set UE4SS_BRIDGE_GAME_DIR to pin
one. The pre-1.2.0 UE_BRIDGE_GAME_DIR and UE_BRIDGE_DATA_DIR are still read as a fallback.
Install
uvx ue4ss-bridgeor with pip:
pip install ue4ss-bridgeQuick check. With the game up and the mod loaded:
uvx ue4ss-bridge statusgame: The_Holy_Fool | process: The_Holy_Fool-Win64-Shipping.exe | running: True | bridge dir: C:\...\Binaries\Win64\ue4ss\bridgeuvx ue4ss-bridge hello returns the mod's version, protocol and permissions.
Claude Code
claude mcp add ue4ss-bridge -- uvx ue4ss-bridgeClaude Desktop
Add this to claude_desktop_config.json (%APPDATA%\Claude\ on Windows,
~/Library/Application Support/Claude/ on macOS):
{
"mcpServers": {
"ue4ss-bridge": {
"command": "uvx",
"args": ["ue4ss-bridge"]
}
}
}Cursor and other MCP clients
Pass uvx ue4ss-bridge (or, with pip, ue4ss-bridge / python -m ue4ss_bridge) as the MCP server
command. Cursor reads .cursor/mcp.json in the project root, or Cursor Settings > Features > MCP;
Windsurf, Continue, VS Code and Codex each take the same JSON block in their MCP settings file.
HTTP (one long-running server, several clients)
ue4ss-bridge --http serves streamable-HTTP MCP on http://127.0.0.1:8930/mcp, loopback only
(--port changes the port):
claude mcp add --transport http ue4ss-bridge http://127.0.0.1:8930/mcpShell, for scripts and for testing the channel
ue4ss-bridge status
ue4ss-bridge hello
ue4ss-bridge eval "return UEB.world()"
ue4ss-bridge props first:PlayerController
ue4ss-bridge types ^Narrative
ue4ss-bridge subclasses /Script/Engine.Pawn
ue4ss-bridge target 5000 # what the camera is pointed at
ue4ss-bridge snapshot first:PlayerController before --super # --super: include inherited properties (props too)
ue4ss-bridge diff before # or: diff <ref> <label> for another object
ue4ss-bridge watch first:PlayerController Pawn pawnwatch --interval 500
ue4ss-bridge hook /Script/Engine.PlayerController:ClientRestart restarts
ue4ss-bridge events # or: events <label>
ue4ss-bridge streams
ue4ss-bridge unwatch pawnwatch # or: unwatch "*"Example prompts
Once an agent is connected, ask it about the running game in plain language:
"Inspect the player pawn and list every health, stamina and combat property."
"Which enemy characters are spawned in the world right now?"
"What UFunctions on the player controller relate to movement, interaction or camera?"
"Snapshot the player controller, then tell me what changed after I open the map."
"Watch the player pawn's health, then tell me every time it dropped while I fought."
"What am I looking at right now, and which materials are on it?"
"List every Blueprint class derived from the enemy base class."
"Set the player's walk speed to 1200."
"Trigger a USMAP dump so I can open the cooked assets in FModel."
Tools
Tool | Does |
| Game found, running, mod answering, mod version and permissions, round-trip time. Call first. |
| Any Lua chunk on the game thread. Whole UE4SS API plus the |
| World, player controller, pawn, game instance, game mode. |
| Resolve one reference / list live instances of a class. |
| Loaded reflected types matching a Lua pattern. |
| Every reflected property with its value. |
| Every UFunction on the class chain. |
| One property. |
| Call a UFunction with positional args. |
| Run a console command. |
| Keep an |
| Re-walk and report |
| Labels held, with object path, wall-clock |
| Drop one snapshot, or all with |
| Every loaded class derived from a base class, Blueprint classes included: |
| Line trace from the camera (or from |
| Sample properties on a timer and record every change under a label. |
| Record every call of a |
| Drain what the watches and hooks recorded: |
| Watches and hooks running / stop one, or all with |
| Re-read |
| Several of the above in one round trip. |
| UE4SS dumpers: |
Every tool except eval_lua goes through the structured batch op, so they keep working when a
user turns allow_eval off.
Object references: /Script/Pkg.Object (any full path), first:ShortClassName (first live
instance), cdo:/Script/Pkg.Class (class default object). first: returns whichever instance
UE4SS finds first, which can be a template, a cutscene copy or a pooled actor rather than the live
one; for the player pawn or controller prefer the exact path reported by world_info.
Serialisation: UObjects become {"__object": fullname, "address": n}, FName/FString/FText
become strings, TArray becomes a list (first 200), structs are walked through their reflected
type including inherited fields. SoftObjectProperty and SoftClassProperty values are skipped
by default (reading one has hard-crashed a game inside UE4SS's own property reader).
Snapshots live in the game process, keyed by label rather than by object address. They
survive UEB.reload() and are lost when the game exits. A diff ignores object and struct
addresses and uses the same depth and array caps as the original walk, so an unchanged object
diffs empty.
Streams (watches and hooks) also live in the game process and survive UEB.reload(). They
share one buffer of 2000 events with a rising sequence number; poll_events reports dropped
when the cap evicted rows before you read them. Labels are unique. A watch holds its object between
passes and rechecks it with IsValid() each pass, looking it up again only when it is gone or a
read failed, so it follows first:PlayerController across respawns; its interval defaults to
250 ms and is floored at 100 ms, because a lookup costs 10 to 25 ms of game-thread time on a game
without object hash tables. It records resumed when it adopts a different object (by address and full name)
after the previous one stopped being valid or was lost, resetting the baseline so the first sample
on the new object is not a change; the same object back after a blip records nothing. When the
reference goes away it records one lost event and retries about once a second.
A hook's callback copies parameters and nothing
else: calling a hooked function from eval_lua in the same session has crashed the game, so read
hook output through poll_events.
Wire protocol (3)
request : {"id": str, "op": "hello"|"ping"|"eval"|"batch", "code": str, "calls": [ {op, ...} ]}
response: {"id", "ok": bool, "result", "output": [str], "error": str|null, "ms": int, "protocol": 3}hello returns the mod's version, protocol and permissions; the server refuses to proceed on a
protocol mismatch. Anything that can write a JSON file can be a client.
Failure modes
Request never picked up: no game running, or the mod is not installed or is disabled. Check for
[UEBridge] ... readyinUE4SS.log.Picked up, no response: the game thread is blocked (loading screen) or the request is long.
dumpuses a 600 s timeout for that reason. If the process is gone, the error names the in-flight operation frombridge\lastop.logand the newest crash report.One request at a time. A
request.jsonyounger than 10 s is another client's; older is a leftover and is reclaimed.
Developing
git clone https://github.com/littleRabbit94/ue4ss-bridge.git
cd ue4ss-bridge
uv venv --python 3.11 .venv
uv pip install --python .venv\Scripts\python.exe -e . # the package and its one dependency (mcp)
.venv\Scripts\python.exe -m ue4ss_bridge status # from the repo root
python tools/build-release.py # dist/ue4ss-bridge-<version>.zipThe mod half is ue4ss/UEBridge/; copy or link it into the game's ue4ss\Mods\ to run the
checkout rather than a release zip.
Edit ue4ss/UEBridge/scripts/main.lua, then ue4ss-bridge reload: the mod
re-runs its source in place and retires the old poll loop, no relaunch.
Credits and license
Available Tools
26 toolsbatchA
Run several bridge operations in ONE round trip and return a result per call.
A round trip costs a poll interval plus latency against single-digit ms of actual work, so a sequence of small calls is nearly all waiting. Each entry is a dict with an "op" key:
{"op": "world"} {"op": "reload"} {"op": "find", "ref": ...} {"op": "get", "ref": ..., "name": ...} {"op": "set", "ref": ..., "name": ..., "value": ...} {"op": "call", "ref": ..., "function": ..., "args": [...]} {"op": "props", "ref": ..., "include_super": bool, "read_soft": bool, "pattern": str} {"op": "funcs", "ref": ...} {"op": "snapshot", "ref": ..., "label": str, "include_super": bool, "pattern": str} {"op": "diff", "label": str, "ref": ... (optional), "update": bool} {"op": "snapshots"} {"op": "forget", "label": str} {"op": "objects", "class_name": ..., "limit": int} {"op": "types", "pattern": ..., "limit": int} {"op": "subclasses", "ref": , "limit": int, "pattern": str} {"op": "target", "distance": num, "channel": int, "ref": ... (optional)} {"op": "watch", "ref": ..., "names": [str], "label": str, "interval_ms": int, "every": bool} {"op": "hook", "function": , "label": str, "max_args": int} {"op": "events", "since": int, "label": str, "limit": int, "clear": bool} {"op": "streams"} {"op": "unwatch", "label": str} {"op": "console", "command": ...} {"op": "dump", "kind": ...}
Each result is {op, ok, result} or {op, ok: false, error}. One failing call does not abandon the rest, so a batch is safe to use for exploration.
Inputs: calls (required).
bridge_statusB
Whether a UE4SS game is running and the UEBridge mod is answering. Reports the game found, mod version, permissions, round-trip time.
Inputs: no named parameters.
call_functionA
Call a UFunction on an object with positional JSON args and return its result. Refused when allow_writes = false.
Inputs: ref (required), function (required), args.
console_commandA
Execute a console command in the running world. Output is not captured. Refused when allow_writes = false.
Inputs: command (required).
diff_objectA
Re-walk an object and report what changed since the snapshot stored under label. Read-only.
ref defaults to the reference the snapshot was taken with; pass one to compare a different object against the stored walk.
Returns {label, path, changed, added, removed, same}, where same is the number of
top-level properties with no changed, added or removed rows, and each changed row is
{path, before, after} with a dotted path into the property ("Mesh.RelativeLocation.X",
"Inventory[3].Count"). Object-valued properties compare by their path, not their address,
so an unchanged object diffs empty. If the reference now resolves to a different object the
old path comes back as stored_path and the diff still runs.
Each of the three lists holds at most 500 rows; truncated counts the rows dropped per
list when exceeded.
update=True replaces the snapshot with this walk after diffing, for a rolling diff. An unknown label raises and names the ones that exist.
Inputs: label (required), ref, update.
dumpA
Trigger a UE4SS dumper: usmap, jmap, uht, cxx, actors, objects, static_meshes. Output lands in the ue4ss directory; jmap and uht take minutes.
Inputs: kind (required).
eval_luaA
Run a Lua chunk inside the game on the game thread and return what it returns.
The full UE4SS Lua API is available (StaticFindObject, FindFirstOf, FindAllOf, RegisterHook, ForEachUObject, ...) plus the UEB helper table: UEB.resolve(ref), UEB.props(ref), UEB.funcs(ref), UEB.get(ref, name), UEB.set(ref, name, value), UEB.call(ref, fn, args), UEB.objects(class, limit), UEB.types(pattern, limit), UEB.console(cmd), UEB.world(), UEB.dump(kind), UEB.snapshot(ref, label), UEB.diff(ref, label), UEB.snapshots(), UEB.forget(label), UEB.subclasses(ref, limit, pattern), UEB.target(distance, channel, ref), UEB.watch(ref, names, label, interval_ms, every), UEB.hook(fnpath, label, max_args), UEB.events(since, label, limit, clear), UEB.streams(), UEB.unwatch(label). UEHelpers is in scope too. print() output is captured and returned alongside the result. Refused when the mod's settings.lua sets allow_eval = false; the other tools keep working.
Inputs: code (required), timeout.
find_objectB
Resolve an object reference and return its full name, class and address.
Inputs: path (required).
find_objectsD
Live (non-default) instances of a short class name, e.g. 'PlayerController'.
Inputs: class_name (required), limit.
forget_snapshotB
Drop one stored snapshot, or all of them with label="*". Read-only; frees memory in the game process.
Inputs: label (required).
get_propertyA
Read one property of an object. An unknown property name raises rather than returning junk.
Inputs: ref (required), name (required).
hook_functionA
Record every call of a UFunction, with its parameters. Counts as a write.
function is a UFunction path ('/Script/Engine.PlayerController:ClientRestart'). max_args caps how many parameters are copied per call (default 8). Read the calls with poll_events.
The callback copies parameters and the calling object's name and does nothing else. A native hook registers cleanly, but an eval that then CALLS the hooked function crashed the game with an access violation, so read hook output through poll_events and do not call a hooked function from eval_lua in the same session.
Hooking intercepts game code, so it is refused when allow_writes = false. Stop a hook with stop_stream, which unregisters it.
Inputs: label (required), function (required), max_args.
inspect_objectB
Every reflected property of an object with its current value. Use on CDOs and live actors.
pattern is an optional Lua pattern matched against the property name, e.g. "^Camera" or "Speed"; one pawn can be 300 properties, so filtering is usually what you want.
include_super defaults to False. SoftObjectProperty values are skipped (reading one has crashed a game inside UE4SS's own property reader, which no Lua pcall can catch).
Inputs: ref (required), pattern, include_super.
list_functionsC
Every reflected UFunction callable on an object, across its class chain.
Inputs: ref (required).
list_snapshotsA
Snapshots currently held in the game: label, object path, taken (a wall-clock timestamp in whole seconds), property count. Read-only.
Inputs: no named parameters.
list_streamsA
Watches and hooks currently running: {label, kind, target, interval_ms, events, started, active, lost}. Read-only.
Inputs: no named parameters.
list_subclassesA
Every loaded class derived from a base class, Blueprint classes included.
ref is a class path ('/Script/Engine.PlayerController'); passing an object that is not a Class or BlueprintGeneratedClass raises. The base itself is excluded. pattern is an optional Lua pattern matched against the short name.
Returns {base, count, types}, where count is the number of matches before limit and each
row is {name, kind, path, parent} with parent the immediate super class's short name. Rows
are sorted by path. The engine keeps no reverse index, so this walks every UObject and
tests IsChildOf: about 1.5 s on a large game.
Inputs: ref (required), limit, pattern.
list_typesA
Loaded reflected types whose name matches a Lua pattern (empty = all). Walks GUObjectArray (~400 ms).
Inputs: limit, pattern.
poll_eventsA
Drain events recorded by watches and hooks. Read-only.
since is a sequence number, exclusive: pass back the next from the previous call to get
only what is new. label filters to one stream. clear=True drops the returned rows.
Returns {events, next, dropped, buffered}. Each row is {seq, t, label, kind} plus, for a
watch, {path, before, after}, and for a hook, {fn, self, args}. The buffer holds 2000
events across all streams; dropped counts what the cap evicted before you read it.
Inputs: clear, label, limit, since.
reload_modA
Re-read settings.lua and re-run the UEBridge mod in place; no game restart.
Read-only: touches only the mod's own settings, so it works with allow_eval = false and allow_writes = false and is the recovery path after eval was turned off. Returns the settings now in effect (poll_ms, allow_eval, allow_writes) and the new generation number.
Inputs: no named parameters.
set_propertyA
Write one property of an object (number, bool or string).
Returns {previous, current}. Writes are never undone, so previous is what you restore
from if the write turns out to be wrong. An unknown property name raises instead of
silently doing nothing. Refused when the mod's settings.lua sets allow_writes = false.
Inputs: ref (required), name (required), value (required).
snapshot_objectA
Walk an object's reflected properties and keep the result in the game under label. Read-only.
The same walk as inspect_object, kept for diff_object. include_super and pattern are stored with the snapshot so the diff re-walks the same set. Reusing a label replaces the snapshot.
Returns {label, path, count, taken}, where taken is a wall-clock timestamp (os.time()
in the game, whole seconds since the epoch). Snapshots live in the game process: they
survive a UEB.reload() but not a game restart.
Inputs: ref (required), label (required), pattern, include_super.
stop_streamA
Stop one watch or hook by label, or all of them with label="*". Unregisters a hook.
Inputs: label (required).
targeted_actorA
What the player is looking at: a line trace from the camera along its forward vector.
distance is in centimetres (the engine's unit), default 5000. channel is a trace channel: 0 = Visibility, 1 = Camera. ref traces from that actor's own location and forward vector instead of the camera, which is how you ask what an NPC faces.
Returns {hit} alone on a miss, otherwise {hit, actor, actor_class, component, component_class, distance, impact_point, impact_normal, bone, phys_material, materials}. actor is the hit component's owner; materials are the component's material full names (first 32) when it exposes GetMaterials. Read-only: it works with allow_writes = false.
Inputs: ref, channel, distance.
watch_propertyA
Sample properties on a timer and record an event whenever a value changes. Read-only.
names is one property name or a list. every=True records every sample instead of only changes. Read the results with poll_events; nothing is pushed.
interval_ms is clamped to at least 100 and defaults to 250. A pass that looks the object up costs roughly 10 to 25 ms of game-thread time on a game without object hash tables, so keep watches few and slow (250 ms or more).
The object is held between passes and rechecked with IsValid() on each one; a lookup happens only when it is gone or a read failed, so the watch follows a reference such as 'first:PlayerController' across respawns without paying a scan per pass. {kind: "stream", event: "resumed"} is recorded when the watch adopts a different object (by address) after the previous one stopped being valid or was lost, with the baseline reset so the first sample on the new object is not reported as a change; the same object coming back after a blip records nothing. If the reference stops resolving (usually a map transition) it records one {kind: "stream", event: "lost"} row and keeps retrying at a slow cadence. Only stop_stream ends a watch.
Labels are unique: reusing one raises. Stop a watch with stop_stream.
Inputs: ref (required), label (required), names (required), every, +1 more.
world_infoD
Current world, player controller, pawn, game instance and game mode.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Each tool targets a distinct operation: object discovery, property inspection, function calling, stream management, snapshotting, and batch execution are clearly separated. Even similar tools like find_object/find_objects and inspect_object/snapshot_object/diff_object have well-defined boundaries.
The set predominantly follows a verb_noun underscore pattern such as list_types, get_property, watch_property, and forget_snapshot. A few outliers like bridge_status, world_info, targeted_actor, and batch break the pattern slightly but do not create real confusion.
26 tools is above the typical well-scoped range, but the server covers a broad UE4SS bridge domain including object discovery, property access, function invocation, event streams, snapshots, and batching. Each tool serves a distinct purpose, and batch is a convenience wrapper rather than redundant functionality.
The tool surface covers the full lifecycle of working with a live UE4SS game: inspecting state, reading/writing properties, calling functions, executing console/eval commands, watching changes, hooking functions, snapshotting/diffing, and recovering via reload_mod. There are no obvious dead ends for the stated purpose.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
OCR, transcription, file extraction, and image generation for AI agents via MCP.
Related MCP Servers
- AlicenseCqualityCmaintenanceEnables AI clients to control Unreal Engine 5 editor for automated Blueprint authoring, level inspection, actor spawning, and other editor workflows via a local Python MCP server and UE plugin.5004AGPL 3.0
- AlicenseAqualityBmaintenanceEnables AI agents to execute Lua code, inspect scripts, spy on remotes, and interact with a running Roblox game client through an MCP interface.42266 npm1MIT

Mengine MCPofficial
AlicenseNot gradedqualityCmaintenanceEnables AI agents to launch, inspect, control, debug, and hot-reload live Mengine game builds through Visual Studio Code or standard MCP clients.MIT- AlicenseNot gradedqualityCmaintenanceDrives Unreal Engine 5 from any AI assistant by exposing the open editor as MCP tools over Unreal's built-in Remote Control API, so users can spawn, list, move, and delete actors, search assets, and read or write properties through natural language. No custom plugin or in-engine code is required, and it includes a raw function-call tool plus batch execution for arbitrary BlueprintCallable functions.MIT