VibeUE: Unreal Engine Vibe Coding Tool

VibeUE is the MCP Expansion + AI Editor Toolset for Unreal Engine 5.8+. Unreal 5.8 added a built-in MCP server and AI toolsets; VibeUE is an MCP Expansion that plugs straight into them and adds a deep AI Editor Toolset — a library of editor capabilities — Blueprints, materials, landscape, foliage, animation, Niagara, UMG, audio, StateTree, gameplay tags, input, UVs, performance/profiling, and more — registered into the engine's own ToolsetRegistry

and ModelContextProtocol

server, plus rich domain skills served through Unreal's native AgentSkill

system. Any MCP-capable agent (Claude Code, Cursor, Copilot, …) drives your editor through Unreal's standard MCP endpoint.

⚠️ VibeUE requires Unreal's native MCP to be set up first— enable theUnreal MCPplugin (which auto-enablesToolset Registry) and theEditor Toolsplugin, then start the MCP server. Follow Epic's guide:. VibeUE then expands that endpoint —[Unreal MCP in the Unreal Editor]no separate server and no in-editor chat.A free API key (set inEditor Preferences → Plugins → VibeUE) unlocks the real-worldterraintools; everything else works without one.

Unreal 5.8 ships its own AI toolsets (Blueprints, materials, actors, assets, meshes, data tables, …). VibeUE complements them — it focuses on the domains and depth the engine doesn't cover:

Terrain & world— Landscape sculpting/heightmaps/splines, landscape auto-materials + RVT, Foliage, procedural FPS** Map Blockout**, and** real-world terrain**(heightmaps + water from GPS).** Audio**— MetaSound and SoundCue graph authoring.** Animation assets**— AnimSequence keyframe editing, AnimMontage authoring, AnimBP state machines, Skeleton bone/socket/retarget/blend-profile editing.FX depth— Niagara emitter color/curve authoring and** Custom-HLSL scratch-padmodules. UI**— UMG widgets with MVVM bindings, animation authoring, and preview/PIE validation.** Higher-order Blueprint authoring**— timelines, event dispatchers, delegates, custom-event pins, comment boxes, and a batchbuild_graph

builder.Editor safety—TransactionService

wraps the editor's transaction buffer (undo / redo / checkpoints) so an agent can group and roll back its own edits — the engine's toolsets expose none.⚡ Performance & profiling— VibeUE's standout: see the dedicated section below.** Python-first access**— run anyunreal.*

Python in the editor and introspect the whole API.Web research— search / fetch / geocode for in-context research and terrain workflows.

It deliberately does not duplicate the engine's general tools (basic asset/actor/blueprint/material CRUD, screenshots, logs, PIE) — agents use Unreal's native toolsets for those.

Unreal's native AI toolsets have zero performance tooling — they can start PIE/Simulate but can't measure anything. VibeUE's

PerformanceService

fills that gap so an agent can actually diagnose and fixframe rate:

— Game/Render/GPU/RHI thread split + aframe_timing()

CPU-vs-GPU-bound verdict and a concrete next-step hint.Run this first— optimising the GPU does nothing on a CPU-bound frame.Unreal Insights capture—start_trace

/stop_trace

/get_trace_status

, withbookmark

andregion_start

/region_end

markers.— reads the traceanalyse()

and log back and returns a perf summary (frame stats, worst frames, hitches, notable log lines).Trace-attached— profile a representative standalone build, not just the editor viewport.start_standalone

import unreal
print(unreal.PerformanceService.frame_timing())   # CPU vs GPU bound — diagnose FIRST
unreal.PerformanceService.start_trace("cap", "")   # Insights trace
unreal.PerformanceService.stop_trace()
print(unreal.PerformanceService.analyse("both", ""))

Pair with the profiling

and frame-rate

skills for the full CPU/GPU drill-down.

VibeUE plugs into three native UE 5.8+ systems:

Toolsets(ToolsetRegistry

) — VibeUE's services register asUToolsetDefinition

s, so their methods become AICallable tools on the MCP endpoint. They're alsoBlueprintCallable

, so the same methods are callable from Python asunreal.<Name>Service.<method>()

.MCP server(ModelContextProtocol

) — a small set of VibeUE utility tools are registered directly on the endpoint:execute_python_code

,discover_python_module

/_class

/_function

,list_python_subsystems

,deep_research

,terrain_data

.Skills(AgentSkillToolset

) — ~34 markdown skill packs register as nativeUAgentSkill

s, discoverable viaListSkills

and loaded lazily viaGetSkills

, alongside the engine's own skills.

Efficient usage (for agents): execute_python_code

is the workhorse — it batches a whole multi-step task into one round-trip and reaches every VibeUE service plus the full unreal.*

API. Use call_tool

only for skills and the few engine toolsets with no Python path (screenshots, etc.). See Content/samples/AGENTS.md.sample for the full agent guide.

Requirements: Unreal Engine 5.8+ · Git

VibeUE is an expansion of Unreal's built-in MCP support, so enable that first. Full details in Epic's guide: ** Unreal MCP in the Unreal Editor**.

Edit → Plugins→ enable** Unreal MCP**(this auto-enables** Toolset Registry**) and** Editor Tools**(the engine's own AI toolsets, so agents get both). These are Experimental. Restart when prompted.** Edit → Editor Preferences → General → Model Context Protocol→ enable Auto Start Server**(or run the console commandModelContextProtocol.StartServer

). Default endpointhttp://127.0.0.1:8000/mcp

(port/path configurable). EnablingTool Search keeps an agent's context small — it seeslist_toolsets

/describe_toolset

/call_tool

and loads tools on demand.

cd /path/to/YourProject/Plugins
git clone https://github.com/kevinpbuckley/VibeUE.git

Build with the project script:

Plugins/VibeUE/BuildAndLaunchGame.ps1                  # builds + launches the editor
Plugins/VibeUE/BuildAndLaunchGame.ps1 -StrictRebuild   # full recompile (warnings-as-errors)

On Linux or macOS, use the platform-detecting shell script:

Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5
Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5 --strict-rebuild

Then Edit → Plugins → enable VibeUE and restart. Its services, tools, and skills now register onto the same endpoint, alongside the engine's own.

Two console commands from the editor (open the console with ```

):

1. Write the MCP server config (.mcp.json

at the project root):

ModelContextProtocol.GenerateClientConfig ClaudeCode

(supports ClaudeCode

, Cursor

, VSCode

, Gemini

, Codex

, or All

.)

2. Write VibeUE's agent guide so the assistant uses the efficient patterns:

VibeUE.GenerateAgentConfig ClaudeCode

This writes the guide to the correct file for your agent — CLAUDE.md

(Claude Code), GEMINI.md

(Gemini), AGENTS.md

(Codex / Hermes / Cursor), or .github/copilot-instructions.md

(Copilot) — or pass All

to write CLAUDE.md + GEMINI.md + AGENTS.md at once. It resolves the plugin location automatically, so it works whether VibeUE was installed from FAB or Git. The guide goes in a managed block, so re-run any time to refresh without disturbing your own notes. Pass import

to link the guide with a one-line @import

instead of copying it (Claude Code / Gemini only — other agents don't resolve imports, so they always get a copy).

The MCP server is loopback-only with no authentication — same-machine use only (per Epic's docs).

The guide teaches: discover before you call (discover_python_class

), batch with execute_python_code

, load skills via ListSkills

/GetSkills

, and when to reach for deep_research

/ terrain_data

.

Skills are lazy-loaded domain knowledge (workflows, gotchas, property formats) served by Unreal's native AgentSkillToolset

:

call_tool(tool_name="ListSkills", toolset_name="ToolsetRegistry.AgentSkillToolset")

call_tool(tool_name="GetSkills", toolset_name="ToolsetRegistry.AgentSkillToolset",
          arguments={"skillPaths": ["/VibeUE/Python/init_unreal_PY.VibeUE_blueprints"]})

ListSkills

is the live source of truth for what's available (it reads each pack's SKILL.md

). Skills tell you what to do and why; use discover_python_class('unreal.<Name>Service', method_filter='…')

for exact signatures before writing code.

Native engine prerequisites (enable in Step 1 — Epic's MCP stack):

Plugin	Purpose
Unreal MCP (ModelContextProtocol )
The native MCP server endpoint
Toolset Registry (ToolsetRegistry )
Native AI toolset + AgentSkill registration (auto-enabled by Unreal MCP)
Editor Tools (EditorToolset )
The engine's own AI toolsets — VibeUE complements these

Enabled automatically by VibeUE: PythonScriptPlugin

(the unreal.*

API), EditorScriptingUtilities

, and the domain plugins its services need — Niagara

, MetaSound

, EnhancedInput

, ModelViewViewModel

, StateTree

, MeshModelingToolset

, GameplayTagsEditor

. (VibeUE also depends on ToolsetRegistry

• ModelContextProtocol

, so enabling VibeUE pulls them in — but you still enable Editor Tools and start the server per Step 1.)

BuildAndLaunchGame.ps1

(project root or Plugins/VibeUE/

) stops the running editor, builds, and relaunches:

-StrictRebuild

— full plugin recompile under warnings-as-errors-Clean

— wipe intermediate/binaries first-SkipBuild

— relaunch only

VibeUE intentionally keeps no static method catalog in this README — the surface evolves with the engine. The authoritative, always-current references are:

→ which domains exist and when to use them.ListSkills

→ exact method signatures.discover_python_class('unreal.<Name>Service')

→ the toolset's tools + JSON schemas (token-heavy; prefer skills + discovery).describe_toolset('VibeUE.<Name>Service')

MIT — see LICENSE. Project home: https://www.vibeue.com/

source & further reading

github.com — original article