A Blueprint can compile without delivering the behavior you intended. The door might never receive its interaction event, the wrong GameMode might spawn a different character, or a level instance might override the value you just changed. Working with Claude inside Unreal Engine means giving it enough context to investigate these problems, not simply asking for another code snippet.

Two capabilities make that workflow possible. Unreal MCP exposes Editor operations through structured tools, allowing a compatible Claude client to inspect and modify supported project elements. Epic documents this as an experimental feature in UE 5.8; other engine versions may require a third-party bridge with different capabilities.

Computer Use addresses a separate need: interacting with the visible Editor and checking what happens on screen. Where supported and approved, Claude can help reproduce a menu problem, inspect a clipped HUD, or navigate a window without a suitable MCP tool.

This guide combines those approaches around a practical development loop: connect to the correct project, make a bounded change, verify compilation and behavior, and save deliberately. The goal is useful, reviewable assistance, not an unattended promise to build your entire game.

Start With Your Unreal Version and Claude Interface

Before installing anything, identify two things: the Unreal Engine version your project uses and the Claude interface you want to connect. Those choices determine the setup, not the general phrase “Unreal MCP.”

For UE 5.8, Epic documents an experimental MCP server integrated into the Editor. That is the main route used in this guide. If your engine installation does not include it, investigate a compatible third-party bridge rather than copying commands intended for another implementation.

For example, chongdashu’s Unreal MCP uses a C++ Editor plugin and a separate Python server. Its repository describes the integration as experimental. Its dependencies, installation process, and tool names differ from Epic’s built-in approach.

Choose Where Claude Will Work

Claude Code suits tasks that combine source-file editing, development commands, and live Editor operations. Epic also publishes an Unreal Engine MCP plugin for Claude Code, which adds Unreal-specific guidance and tool-discovery workflows.

Claude Desktop Chat and Cowork are different surfaces. Do not assume that installing a Claude Code plugin configures their connections or enables Computer Use. Check the setup supported by your chosen client.

Before connecting, establish a small baseline:

• Confirm the engine version and open the intended project.

• Save the current level and create a source-control checkpoint.

• Record existing Blueprint or C++ compilation errors.

• Decide which folder and test level Claude may modify.

This preparation makes later results attributable. If a Blueprint already fails to compile, Claude should know that before making changes. If several Editor instances are running, close unnecessary ones or establish how the integration identifies its target.

Connect Claude to the Editor and Verify the Project

For Epic’s experimental UE 5.8 integration, start inside the project you want Claude to access. Open Edit > Plugins, enable Unreal MCP and All Toolsets, then restart the Editor when prompted. The Toolset Registry dependency is enabled automatically.

These are Unreal plugins. They are separate from the Claude Code plugin discussed earlier, which provides client-side guidance rather than replacing the Editor connection.

Source: Epic Games Documentation

Start the Server and Generate the Configuration

Open the Unreal Editor console and run:

The default endpoint is:

Check the Output Log to confirm the server started. If you changed its port or URL path in Editor Preferences, use the actual address rather than the default.

Source: Epic Games Documentation

Next, generate Claude Code’s project configuration:

According to Epic’s setup documentation, this writes the MCP connection entry to .mcp.json in the project root. Launch Claude Code from that directory so it can find the configuration. Use /mcp to inspect the connection and approve the project server if prompted.

Keep the server local. Epic’s implementation has no authentication layer and is not safe to expose beyond the machine running Unreal. A connection problem is not a reason to open its port to the internet.

Discover Tools Before Requesting Changes

The default discovery sequence is:

Seeing these three tools does not mean the connection is incomplete. Claude first discovers available toolsets, inspects their schemas, and invokes the relevant operation.

Select a recognizable Actor in Unreal, then ask:

Compare the response with the Editor. The selected Actor and level should match your project. A generic capability summary is not proof of access.

Resolve Connection Problems Before Continuing

If Claude cannot find the server, confirm that Unreal is running, the server started successfully, and Claude was launched from the correct project directory. Check the Output Log for port conflicts or plugin errors.

If a needed operation is unavailable, inspect the enabled toolsets rather than guessing a command from another bridge. Requests to Epic’s Editor tools should also run sequentially, not as overlapping mutations.

Only after this read-only check succeeds should you authorize a small change in a dedicated test level.

Give Claude a Small Level Task With a Clear Finish Line

Use the first connected task to test the workflow, not to generate an entire game. A separate traversal level in an existing Third Person project is a useful starting point. It exercises Actor placement, asset selection, collision, and player spawning without requiring a new gameplay system.

Ask Claude to inspect the existing character, input setup, and available assets before proposing changes. Keep the original level untouched.

Define the Result Before Building

“Create a traversal level” is open to interpretation. Give Claude observable acceptance criteria: the intended character spawns above the floor, the obstacles block movement, and the camera provides a clear view of the starting area.

The task also needs explicit boundaries. Store new content in a dedicated folder, such as /Game/ClaudeTests/, and require approval before modifying shared Blueprints or project-wide settings. A test level should not silently change the default map used by the rest of the project.

Asset references must come from inspection, not invented names. Claude should verify that a mesh exists before assigning it and identify the class it intends to spawn.

Check Placement and Behavior Separately

After creation, inspect Actor transforms, floor coverage, collision settings, and Player Start placement. Then use Play In Editor to verify the acceptance criteria.

A successful spawn operation proves that an Actor was created. It does not prove the player can stand on it or navigate around it. Likewise, a viewport screenshot can show composition but cannot establish collision behavior.

If gameplay interaction is unavailable through the connected tools, use approved Computer Use or perform that check manually. Save the level deliberately once the checks pass, and record what remains unverified before expanding the prototype.

Source: Epic Games Documentation

Blueprint and C++ Changes Need Different Verification

A Blueprint edit and a C++ edit do not follow the same validation path. Ask Claude to identify what it changed and choose the appropriate checks before reporting completion.

For a Blueprint, begin with the asset path and the relevant graph, component, or property. The connected toolset must support the requested operation. After editing, compile the Blueprint and inspect the reported errors or warnings.

Source: Epic Games Documentation

Also distinguish class defaults from instance overrides. Changing a default on BP_Door may not update a placed door that already overrides that property. Claude should inspect the intended instance rather than assuming the asset change propagated.

Use a bounded verification request:

Treat C++ Compilation as a Separate Step

Saving a .cpp file does not mean Unreal has loaded the new implementation. Claude must run the appropriate build or Live Coding operation, wait for completion, and inspect its output.

Live Coding can rebuild and patch C++ binaries while Unreal is running, but it is not a guarantee that every structural change can be applied safely without restarting. Changes involving reflected declarations, object reinstancing, or cached references need particular care. The Live Coding Console also has its own compilation output, separate from the standard Output Log.

Source: Epic Games Documentation

Verify the Behavior After Compilation

A successful compile establishes that the change passed a build check, not that the feature works. Test the specific interaction in the dedicated level.

Where relevant tests exist, use Unreal’s Automation Test Framework. Claude should report whether tests started, finished, and passed. If no suitable test exists, say so explicitly and record the manual checks performed.

Use Computer Use for the Parts a Tool Response Cannot Confirm

Structured tools can confirm that a widget exists or a property was updated. They do not necessarily establish that the player can navigate a menu, regain character control, or read the HUD at a smaller window size.

Claude Computer Use provides screen inspection and interaction with approved applications. Support depends on the client: Desktop supports macOS and Windows, while the Claude Code CLI capability is currently a macOS research preview with specific account requirements. Enable it separately from Unreal MCP and approve access to Unreal when requested.

Source: Anthropic

Use this capability for bounded, observable checks. The following workflows are practical examples, not guarantees of reliable operation across every Unreal project.

Verify Menu Focus, Not Just Button Appearance

A pause menu can look correct while keyboard navigation fails or player input continues underneath it. Test the transition into and out of the menu, not just its screenshot.

Have Claude separate observations from assumptions. Clicking Resume and seeing the menu disappear does not prove character control returned.

Viewport focus also matters. In Play In Editor, input can be captured by the game viewport. Claude must distinguish an unfocused viewport from a broken input system before proposing a repair.

Reproduce a HUD Layout Problem

Choose specific test sizes, such as 1920 × 1080 and 1280 × 720. Ask Claude to inspect objective text, button visibility, and overlapping panels under the same gameplay conditions.

If a layout fails, capture the affected state before changing anything. Record the window size, active menu, and steps needed to reproduce it. Then investigate the relevant widget settings, anchors, or scaling behavior.

A screenshot returned by MCP may be enough for static visual comparison. That is image analysis, not Computer Use. Screen control becomes useful when the task requires resizing a window, opening a menu, or interacting with the game.

Inspect a GUI-Only Editor Workflow

An Editor Utility Widget or third-party plugin may expose controls that the available MCP toolsets cannot reach. Computer Use can provide a fallback for opening the window and inspecting its behavior.

Define which window Claude may operate and whether any changes are allowed. A harmless-looking button might export files, replace assets, or run a bulk operation. Require approval before those actions.

Prefer structured tools when they cover the task. Screen interaction is useful for finding visible failures and producing reproduction steps, but it should not replace deterministic tests, frame-accurate gameplay checks, or human evaluation of game feel.

Put Claude to Work on Materials, Assets, and Cinematics

Once the connection is reliable, use Claude for repetitive production work with a defined scope. Before requesting any operation, have it discover the relevant toolset and inspect its schema. The capabilities listed on Epic’s Unreal Engine MCP plugin page do not guarantee that every tool is enabled in your project.

Create Material Variations Without Rebuilding the Parent

Material instances are a useful bounded task when the parent material already exposes suitable parameters.

Claude should confirm that the parameters exist, assign the instance only to the approved target, and compare the result under consistent lighting. A successful parameter update does not establish that the intended mesh received the material.

Source: Epic Games Documentation

Audit Assets Before Renaming Them

Ask for an inspection report first:

Review the findings before authorizing changes. Asset renaming can affect references and redirectors; it is not equivalent to renaming an ordinary file. Keep those operations inside Unreal’s supported asset workflow.

Success means a specific list of affected assets and proposed repairs, followed by verification of approved changes. Avoid a project-wide cleanup request with no exclusions.

Adjust One Sequencer Shot at a Time

For cinematics, start with an existing Level Sequence and a single shot.

After approval, use supported tools to make the adjustment. Inspect playback around the changed shot, including its boundaries. A camera transform can look correct in isolation while the sequence still uses another camera or has a broken binding. Computer Use can help inspect visible playback when appropriate.

Source: Epic Games Documentation

Organize a Level Without Changing Its Composition

Actor labels and folders are another practical task:

Compare the selection before and after. Define which Actors are in scope rather than asking Claude to organize everything visible.

Across these tasks, keep creation, modification, and deletion as separate decisions. Ask Claude to report changed asset paths, saved packages, and unresolved checks. That makes the work reviewable and provides a clear starting point if a later iteration introduces a problem.

Turn Performance Complaints Into Measurable Investigations

“Optimize this level” gives Claude neither a reliable baseline nor a clear finish line. Start with a repeatable workload: the same map, camera route, resolution, graphics settings, and test duration.

Ask for evidence before a change:

Unreal Insights provides tracing and analysis tools for investigating engine performance. Claude needs access to actual measurements, whether through a supported toolset, exported data it can interpret, or approved interface inspection. Do not assume an MCP connection automatically exposes every profiler feature.

Source: Epic Games Documentation

Compare Equivalent Runs

Record whether the measurement comes from the Editor, PIE, or a packaged build. These environments carry different overhead, so their numbers should not be treated as interchangeable.

Also separate temporary work, such as shader compilation, from a persistent gameplay bottleneck. A brief slowdown while the Editor processes content does not justify rewriting a gameplay system.

Prefer frame-time evidence over an isolated FPS screenshot. A higher number after one change might reflect a different camera angle, fewer visible objects, or a completed background task.

Once a likely cause is identified, change one relevant setting or system and repeat the workload. Check visual quality and behavior alongside performance. An improvement achieved by accidentally removing required effects or gameplay is not a successful optimization.

Claude’s final report should distinguish measured improvements, plausible hypotheses, and questions that need further profiling.

Protect Binary Assets and Keep Runtime Experiments Separate

Unreal projects contain binary assets, not just editable source files. Claude should not treat .uasset or .umap files as text documents. Blueprint, material, and level changes belong in supported Editor operations, with a source-control checkpoint before substantial work.

Respect the project’s checkout and locking policy. An asset being accessible does not mean it is safe to overwrite, particularly when another teammate is editing it.

Separate Temporary Tests From Saved Changes

Values adjusted during PIE are not automatically permanent. Unreal provides Keep Simulation Changes for supported Actor changes, but Claude should not assume every runtime adjustment can be retained.

After testing, stop the session, inspect the Editor-side values, and save only the intended packages. Ask for a summary of changed asset paths and anything that remains unsaved.

Require explicit approval before bulk deletion, asset renaming, shared parent Blueprint changes, or project-wide settings updates. Undo is useful, but it is not a substitute for recoverable checkpoints.

Source: Epic Games Documentation

Diagnose Before Repeating a Failed Request

A timeout does not prove that an operation failed. Inspect the level or asset before submitting the same creation request again.

For connection failures, check the endpoint, enabled toolsets, Editor workload, and Output Log. For incorrect behavior, inspect the smallest relevant change.

Keep the repair scoped. A broken material assignment should not trigger an unrelated project-wide rendering change.

Give Unreal More Room to Run With Vagon

Claude can help you iterate, but your workstation still has to run Unreal. Dense environments, demanding lighting, shader compilation, and C++ builds can turn a quick change into a long wait on an underpowered laptop.

Vagon Cloud Computer for game development gives you access to a powerful cloud desktop without purchasing a new workstation. Choose resources around your workload: GPU capacity matters for rendering-heavy scenes, while CPU performance and memory support compilation, asset processing, and larger projects. Access that environment from a lightweight device while the cloud machine handles Unreal.

Keeping Unreal, Claude, and the MCP connection on the same cloud computer also simplifies the setup. Project files and the Editor remain together, and the local MCP endpoint refers to that machine rather than your laptop. Keep the server local instead of exposing it publicly.

For Computer Use, verify that your chosen Claude client supports the cloud operating system and can access the active Unreal session. Streaming the desktop does not automatically grant Claude screen-control permissions.

Vagon strengthens the development environment, not Claude’s cloud-hosted model inference. A stable connection still matters, particularly for interactive checks. Likewise, performance measured on a powerful cloud workstation does not replace testing on your intended player hardware.

When local hardware slows your iteration loop, move your Unreal workspace to Vagon and give demanding development tasks more room to run.

FAQs

Can Claude directly control Unreal Engine?

Yes, through a compatible MCP connection that exposes Editor tools. Computer Use provides a separate way to interact with approved windows. Both require configuration; asking Claude about your project does not automatically grant access.

Is Unreal MCP an official feature?

Epic documents Unreal MCP as an experimental UE 5.8 feature. Third-party integrations also exist, but they have different requirements and capabilities. Identify which implementation a tutorial uses before following its instructions.

Can I use this with an older Unreal version?

Potentially, through a compatible third-party bridge. Check its supported engine versions, plugin build requirements, and maintenance status. Do not assume Epic’s UE 5.8 setup commands apply to earlier installations.

Do I need Claude Code rather than Claude Desktop?

This guide uses Claude Code for the main setup. Other Claude surfaces may support suitable connections, but their configuration differs. A Claude Code plugin does not automatically configure Desktop Chat or Cowork.

Can Claude create or modify Blueprints?

Supported integrations can expose Blueprint operations. The available toolset determines what Claude can inspect or change. Compile affected assets, check instance overrides, and verify behavior before accepting the result.

Is Computer Use necessary when MCP is connected?

No. Structured tools may cover the entire task. Computer Use helps when you need visible interaction, such as checking menu focus or navigating a window without an appropriate tool.

Can Claude test gameplay reliably?

It can assist with bounded checks and supported automated tests. That does not replace comprehensive playtesting, deterministic validation, or human judgment about controls and game feel.

Can this workflow run on a cloud computer?

Yes, with compatible software and permissions. Keep Unreal and the MCP client together where practical, and account for streaming latency during interactive checks.