Skip to main content
Glama

ue4ss-bridge

PyPI version PyPI Downloads Python 3.10+ License: MIT

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 ue4ss\bridge\request.json, runs the request on the game thread, writes response.json. Game-agnostic.

The game: ue4ss\Mods\UEBridge\ (GitHub release, Dawnwalker Nexus, Laughless Saint Nexus)

ue4ss-bridge (Python)

An MCP server and CLI that write those files and read the answers. Finds the running game by itself.

Your machine: uvx ue4ss-bridge or pip install ue4ss-bridge

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 the UFunctions 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:

  1. Every 50 ms the in-game Lua loop checks for request.json in ue4ss\bridge\.

  2. When one appears, the request runs on the game thread via ExecuteInGameThread.

  3. 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; uvx handles 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 ready

3. 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

enabled

true

false disables the bridge without uninstalling; nothing is polled

allow_writes

true

false is strict read-only: set_property, call_function, console_command, hook_function and eval_lua are refused

allow_eval

true

false refuses raw Lua (eval_lua); the structured inspection tools keep working

poll_ms

50

request file check interval in milliseconds (50 is the floor; lower values are clamped)

bridge_dir

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-bridge

or with pip:

pip install ue4ss-bridge

Quick check. With the game up and the mod loaded:

uvx ue4ss-bridge status
game: The_Holy_Fool | process: The_Holy_Fool-Win64-Shipping.exe | running: True | bridge dir: C:\...\Binaries\Win64\ue4ss\bridge

uvx ue4ss-bridge hello returns the mod's version, protocol and permissions.

Claude Code

claude mcp add ue4ss-bridge -- uvx ue4ss-bridge

Claude 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/mcp

Shell, 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

bridge_status

Game found, running, mod answering, mod version and permissions, round-trip time. Call first.

eval_lua(code, timeout)

Any Lua chunk on the game thread. Whole UE4SS API plus the UEB helpers in scope; print output captured.

world_info

World, player controller, pawn, game instance, game mode.

find_object(path) / find_objects(class, limit)

Resolve one reference / list live instances of a class.

list_types(pattern, limit)

Loaded reflected types matching a Lua pattern.

inspect_object(ref, include_super, pattern)

Every reflected property with its value.

list_functions(ref)

Every UFunction on the class chain.

get_property / set_property

One property. set returns {previous, current}.

call_function(ref, fn, args)

Call a UFunction with positional args.

console_command(cmd)

Run a console command.

snapshot_object(ref, label, include_super, pattern)

Keep an inspect_object walk in the game under a label. Read-only.

diff_object(label, ref, update)

Re-walk and report {changed, added, removed, same} against that snapshot, by dotted property path. ref defaults to the snapshot's own reference. At most 500 rows per list; truncated counts the rows dropped per list. Read-only.

list_snapshots()

Labels held, with object path, wall-clock taken timestamp (whole seconds since the epoch) and property count. Read-only.

forget_snapshot(label)

Drop one snapshot, or all with "*". Read-only.

list_subclasses(ref, limit, pattern)

Every loaded class derived from a base class, Blueprint classes included: {base, count, types} with {name, kind, path, parent} rows sorted by path. Read-only; about 1.5 s.

targeted_actor(distance, channel, ref)

Line trace from the camera (or from ref's own location and forward vector): the actor, component, impact point and normal, bone, physical material and materials hit. Read-only.

watch_property(ref, names, label, interval_ms, every)

Sample properties on a timer and record every change under a label. interval_ms defaults to 250 with a 100 ms floor. Read-only.

hook_function(function, label, max_args)

Record every call of a UFunction with its parameters. Counts as a write.

poll_events(since, label, limit, clear)

Drain what the watches and hooks recorded: {events, next, dropped, buffered}. Read-only.

list_streams() / stop_stream(label)

Watches and hooks running / stop one, or all with "*".

reload_mod()

Re-read settings.lua and re-run the mod in place, no game restart. Read-only, so it is the way back after allow_eval was turned off.

batch(calls)

Several of the above in one round trip.

dump(kind)

UE4SS dumpers: usmap, jmap, uht, cxx, actors, objects, static_meshes.

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] ... ready in UE4SS.log.

  • Picked up, no response: the game thread is blocked (loading screen) or the request is long. dump uses a 600 s timeout for that reason. If the process is gone, the error names the in-flight operation from bridge\lastop.log and the newest crash report.

  • One request at a time. A request.json younger 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>.zip

The 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 tools
batchA

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

    B3.4/5.0

    Scored across 26 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count4/5

    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.

    Completeness5/5

    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

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Drives 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