Model Context Protocol · Unreal Engine 5

Unreal MCP.

Built to run the editor, not to demo it.

actions of its own across tool categories, plus all 830 of Epic's native 5.8 tools wrapped in-process and surfaced alongside them: in total. A YAML flow engine and an npm plugin ecosystem on top.

Graded against 11 other Unreal MCP servers →

Get Started →Docs
ue-mcp · Vale project
Checking editor status, then building the potion rack.
●
project (get_status)
⎿ ok · Vale
●
asset (import_static_mesh)
⎿ SM_PotionRack
●
level (place_actor)
⎿ SM_PotionRack_0
●
blueprint (compile)
⎿ ok · 0 errors
●
flow (run)
⎿ dress_shelf · 9 steps ok
Rack placed and dressed. Running PIE.
Checking editor status before we start building the potion rack.
●
ue-mcp – project (MCP) (action: "get_status")
⎿  { "editorConnected": true, "project": "Vale" }
Good. Importing mesh, recentering pivot, placing in level.
●
ue-mcp – asset (MCP) (action: "import_static_mesh", name: "SM_PotionRack")
⎿  { "success": true, "assetPath": "/Game/Meshes/Props/SM_PotionRack" }
●
ue-mcp – level (MCP) (action: "place_actor", location: {x:240,y:0,z:0})
⎿  { "label": "SM_PotionRack_0", "success": true }
Rack is in. Dressing the shelf with the saved flow.
●
ue-mcp – flow (MCP) (action: "run", flowName: "dress_shelf")
⎿  { "success": true, "stepCount": 9, "failedStep": null }
Shelf dressed and Blueprint compiled. Running PIE to verify interaction.
UE-MCP Actions
Tool Categories
830
Epic 5.8 Tools Wrapped
UE 5.4-5.8
Compatibility
<5min
Setup Time
What you can do

The whole editor,
not a slice of it.

Read and write across every major subsystem, with full undo. Filesystem reads work with the editor closed, so an agent can explore before anything runs.

⬡
blueprint
Blueprint Graph Scripting
Read and write graphs. Nodes, pins, functions, compile. Bulk-rewrite a whole graph from JSON in one call.
◫
level
Actor & Level Management
Place, move, delete. Batch spawn, line trace, snap to floor, sublevels, build lighting.
◈
material
Material Graph Authoring
Materials and instances from scratch. Expression graphs, custom HLSL, preview PNG back.
▲
gameplay
Gameplay Systems
Physics, navmesh, Enhanced Input, behavior trees, EQS, Smart Objects, multi-client PIE.
✦
gas
Gameplay Ability System
Attribute sets, abilities, effects, cues, activation tags, AbilitySystemComponent.
⊞
pcg
Procedural Content Generation
Create, wire, and execute PCG graphs. Nodes, pins, parameters, regenerate.
⌘
editor
Full Editor Control
Console, Python, PIE, viewport, sequencer, Live Coding, headless builds, screenshot and GIF capture.
∿
niagara
VFX Systems
Systems, emitters, modules, renderers, HLSL. Spawn VFX and drive live parameters.
◉
reflection
Runtime UE Reflection
Any UClass, UStruct, or UEnum, live from the editor. Gameplay tags and SaveGames too.
♪
animation
Animation & Skeletons
AnimBPs, state machines, montages, blendspaces, bone tracks, IK rigs, Pose Search.
◬
landscape
Terrain & Foliage
Sculpt heightmaps, paint weight layers, manage splines, scatter foliage by type.
more
tool categories.
StateTree, Chooser, networking, audio, UMG, sequencer, Fab imports, C++ authoring, project config.
Full tool reference →
Beyond tool calls

A tool list is
the easy part.

Making long runs repeatable. Letting other people extend the surface. Absorbing what the engine itself ships. Keeping all of it affordable in the context window.

Flow engine

Turn twenty calls
into one.

Write a sequence once as YAML in ue-mcp.yml, run it with one call. Every one of the 1930+ actions is already a flow task, so there is nothing to wire up.

  • ▸Step references, runtime parameters, conditional skips, hooks, and nested flows.
  • ▸Per-step retries, with a retryOn filter for the flaky ones.
  • ▸Rollback on failure: handlers emit their own inverse, unwound in reverse.
  • ▸Opt-in git snapshot of Content/ and Config/, restored on failure. Your real history is untouched.
  • ▸Custom tasks in your own .js/.ts, shell steps, and hot-reloaded config.
  • ▸Live SSE event stream for panels, dashboards, and CI logs.
ue-mcp.yml
flows:
dress_shelf:
description: Place the rack and light it
rollback_on_failure: true
steps:
1: { task: asset.import_static_mesh }
2: { task: level.place_actor }
3: { task: material.create_instance }
4: { task: level.place_actor, retries: 2 }
5: { task: editor.capture_scene_png }
# one call from the agent
flow(action="run", flowName="dress_shelf")
→ { success: true, stepCount: 5 }
Plugin ecosystem

Extend it without
forking it.

Extensible through npm. A plugin injects actions into existing categories, provisions a new one, or ships native C++ that registers handlers with the bridge.

  • ▸Injected actions land in categories the agent already knows. Nothing extra to discover.
  • ▸Knowledge markdown merges into the host category's AI-facing docs at boot.
  • ▸Native modules deploy into your Plugins/ directory and compile with your build.
  • ▸Guards wrap every call a plugin makes: deny policies and audit observers.
  • ▸Browse and install from the registry at plugins.ue-mcp.com.
Native 5.8 toolsets

Epic's own tools,
already wired in.

Unreal 5.8 ships an AI Toolset Registry, the plugin behind Unreal's own MCP server. UE-MCP reaches it in-process and surfaces all 830 tools as epic_* actions in the matching category: Sequencer in animation, PCG in pcg.

  • ▸One server, one config, one connection.
  • ▸Official tools sit beside the native handlers, so the agent picks in context.
  • ▸Domains with no native handler get their own category: dataflow, conversation.
  • ▸Runtime discovery through the epic category: list_toolsets, describe_toolset, call_tool.
  • ▸A bundled skill teaches the model which of the two to reach for.
ue-mcp · UE 5.8
epic(action="list_toolsets")
→ 52 toolsets · 830 official tools
# the same category you already use
animation(action="epic_add_track_to_sequence",
input={ sequence: "/Game/Cine/SEQ_Intro", ... })
→ { success: true, source: "ToolsetRegistry" }
# and the handlers ue-mcp wrote itself, unchanged
animation(action="create_montage", ...)
Context management

45k tokens of tools.
Or 1k.

Everything the server injects at session start is context the model pays for before doing anything, so the seed is a setting. Three strategies trade it against discovery round-trips, and the typed enums stay either way.

  • ▸full: every action and parameter inline. Zero discovery calls.
  • ▸lean: names and enums stay visible, prose on demand through a catalog tool with keyword search.
  • ▸micro: one gateway tool fronts every category. Smallest seed, most discovery.
  • ▸Switch with npx ue-mcp context lean, or per session with an env var.
  • ▸Measure the real cost on your own project with the bundled context-tax script.
seed cost · test project
full~45k tokens
every action + parameter inline
lean~23k tokens
names visible, prose on demand
micro~1k tokens
one gateway tool fronts it all
$ npx ue-mcp context lean
Safety

Stoppable, auditable, reversible.

An agent with write access to your project is a real risk. This is what sits between it and your files.

Write guards
Rules block or require confirmation on mutating methods before they reach the editor.
Source control aware
Writes to checked-in assets can be gated on source control state instead of silently overwriting.
Rollback on failure
Handlers emit their own inverse, unwound in reverse. An opt-in git snapshot restores Content/ and Config/.
Idempotent by convention
Handlers report created / existed / updated. Re-running an applied action is a no-op, not a duplicate.
Architecture

Two components.
One restart.

A TypeScript MCP server handles the AI protocol. A C++ plugin runs inside the editor. They talk JSON-RPC over WebSocket.

01

Run the init wizard

Run npx ue-mcp init from your project directory. It finds your .uproject, deploys the bridge plugin, and configures your MCP clients automatically.

02

One editor restart

Restart the editor once to load the plugin. Run project(action="get_status") to verify.

03

Start building

Place actors, write Blueprints, create materials, rebuild navmesh, run PIE. Anything you'd do by hand.

AI Assistant
stdio / MCP protocol
MCP Server (Node.js)
WebSocket · JSON-RPC 2.0 · per-project port
C++ Bridge Plugin
UE C++ API · game thread
Editor Subsystems
EDITOR-OFFLINE OPERATIONS
MCP Server
→filesystem
INI · C++ · Assets
Auto-reconnect
Connection drops? Retry every 15s. Config, C++ headers, and asset listing still work offline.
One server, many editors
Each editor gets its own session, port lockfile, tool graph, and guard pipeline. The client sees the union, and lifecycle calls only ever hit the editor that published the lockfile.
Tool Reference

tools.
actions.

Every tool takes an action parameter, validated against a typed enum. Discovered through embedded docs, or search when the seed is trimmed.

projectassetblueprintlevelmaterialanimationlandscapepcgfoliageniagaraaudiowidgeteditorreflectiongameplaygasnetworkingstatetreechooserfabepicpluginsdemofeedbackdataflowconversation
Agent skills

Skills, not just tools.

Knowing the actions is not the same as knowing the order to call them in. Five skills cover the non-obvious parts, and load automatically in clients that support them. When an agent still falls back to raw Python, it offers to file a gap report.

ue-mcp-workflow
Order of operations, editor lifecycle, project scoping
ue-mcp-blueprint
Graph authoring, node discovery, pin wiring, compile loops
ue-mcp-niagara
Emitter and module stack authoring, renderer setup
ue-mcp-native-cpp
Writing and building native C++ against the bridge
ue-mcp-epic-routing
When to route to the native toolsets vs native handlers
Full Tool Reference →
Comparison

Same criteria, every server.

Eleven third-party Unreal MCP servers, graded row by row against ue-mcp on the same criteria. Gaps left visible.

Open the matrix →
Open Source

Built in the open.

MIT licensed. The source is on GitHub, the docs are public, and it is free in any project, personal or commercial.

github.com/db-lyon/ue-mcp
# One command to set up everything
npx ue-mcp init
Community

This gets built with you.

Show me what you're making. Tell me what's broken. The roadmap moves on what people actually hit.

Join the DiscordWho builds this
Get Started

Up and running
in five minutes.

Node 18+, UE 5.4-5.8, and an MCP-capable client.

terminal
# 1. Run the init wizard
npx ue-mcp init
 
# 2. Restart editor once to load the bridge plugin
# 3. Verify: project(action="get_status")
Full Setup Guide →See the 19-step demo

Studios needing custom tooling, air-gapped installs, or managed relay: hello@ue-mcp.com.