You can point an AI agent like Claude or Gemini straight at the Unreal Editor and have it build scenes, set lighting, and wire up materials while you watch. Unreal Engine 5.8 includes an experimental Unreal MCP plugin that turns the editor into a controllable surface for any Model Context Protocol client. This guide is written for creators working in virtual production, arch-viz, and product visualization, not just game studios. It walks through connecting an agent, running a first scene-building prompt, and keeping a human firmly in control. Budget about 20 minutes for the first setup and a few minutes per prompt after that.

What You Need

  • Unreal Engine 5.8 or later, with the Unreal MCP plugin available in the plugin browser.
  • An MCP-capable AI client: Claude Code, the Gemini CLI, Cursor, or VS Code.
  • An account or API access for your chosen model, either Anthropic for Claude or Google's Gemini.
  • A test project. The third-person template or an empty level is enough to learn the loop safely.
  • About 20 minutes for setup. Keep the project under version control before you start.
Matte 3D render of a robotic arm placing a cube into an editor window, a metaphor for an AI agent acting inside the Unreal Editor
The MCP plugin lets an agent act inside the editor instead of just describing changes.

Why Connect an AI Agent to Unreal at All

For most of its life, an AI assistant sat outside the editor. You described what you wanted, it returned text or code, and you copied that back in by hand. The Unreal MCP plugin removes that gap. It runs a small server inside the editor process and exposes engine systems as callable tools, so a connected agent can act on your project directly rather than narrate at it. For a virtual production artist, that means asking for a three-point lighting rig and getting actual lights placed in the level, not a tutorial on how to place them.

This matters because the slow part of a 3D scene is rarely the creative decision. It is the dozens of mechanical steps between the decision and the result: spawning placeholder geometry, naming actors, dialing in intensity values, creating material instances, and re-running test passes. Handing those steps to an agent that understands the editor turns a 40-minute blocking session into a conversation. The same shift is reshaping other creative tools, as covered in our look at agentic creative suites taking the canvas.

Matte 3D render of linked blocks forming a pipeline from a terminal to a 3D scene, a metaphor for the local agent-to-editor connection
The agent talks to a loopback server inside the editor, then drives engine tools step by step.

The Workflow: Connect Claude or Gemini to the Unreal Editor

The whole connection is local. The plugin binds an MCP server to your own machine and your agent talks to it over a loopback address, so nothing leaves your computer during a session. Here is the full path from a fresh install to a finished scene pass.

Step 1: Enable the Unreal MCP plugin

Open Edit > Plugins, search for "Unreal MCP," and tick Enabled. The plugin identifier is ModelContextProtocol. It depends on the Toolset Registry plugin, which activates automatically. Restart the editor when prompted. Per Epic's Unreal MCP documentation, this is an Experimental feature, so enable it in a test project first and use caution before relying on it in a shipping pipeline.

Step 2: Set the server to start with the editor

Go to Edit > Editor Preferences > General > Model Context Protocol and enable auto-start so the server is ready whenever the editor opens. By default the server listens only at http://127.0.0.1:8000/mcp, accepts connections from the same machine, has no authentication layer, and rejects non-loopback origins. That is by design: it is meant for local use, not remote control. Leave it that way unless you fully understand the security trade-off.

Step 3: Generate a config for your agent

Unreal can write the client configuration for you. Run the console command ModelContextProtocol.GenerateClientConfig [ClientName], where the client name is one of ClaudeCode, Gemini, Cursor, VSCode, Codex, or All to register several agents at once. This drops a ready MCP server entry into your agent's config so it knows where to find the editor.

Step 4: Launch the agent and build your first scene

Open your agent from the project root so it picks up the generated config, then confirm it can see the Unreal MCP server. Start small. A good first prompt is concrete and bounded: "Spawn a cube at the world origin, add a directional light angled 45 degrees from the front, and name both actors clearly." Watch the actors appear in the outliner as the agent calls each tool. This first round is about trust, not output. You are checking that the agent reads the scene correctly and that you can follow every action it takes.

Step 5: Add a lighting and material pass by prompt

Once the basics work, move to the kind of task that actually eats studio time. Ask the agent to "replicate a soft overcast key light, add a subtle warm rim light, and create a brushed-metal material instance for the hero object." The plugin can configure lighting and create material instances, so these requests resolve into real editor changes you can then fine-tune by hand. Treat the agent's output as a fast first draft of the look, not the final grade.

Step 6: Review every change and version your project

An agent will occasionally make a confidently wrong decision, the way every large language model can. Commit before each agent session, review the diff in your version control or the editor's change list afterward, and keep prompts scoped to one outcome at a time. Epic has been explicit that the editor stays in the creator's hands; the agent is a collaborator that proposes and executes, not an autopilot you walk away from.

Matte 3D render of a control panel with three tool blocks, a metaphor for the actor, lighting, and material tools the agent can call
The Toolset Registry decides what the agent can reach: actors, lighting, materials, and tests.

What the AI Can and Cannot Touch

The plugin exposes editor systems through the Toolset Registry, with shipped tool sets that the documentation names as scene, actor, material instance, and object tools. In practice an agent can spawn actors, configure lighting, create material instances, inspect Slate widgets, and run automation tests. That covers a large share of layout, look-dev, and validation work for a virtual production or arch-viz scene.

The limits are just as important. Only HTTP and Server-Sent Events transports are supported; stdio and WebSocket are not. Live Coding cannot propagate new UFUNCTION declarations, so adding custom tools means an editor restart. The server has no built-in authentication and is loopback-only, which is the right default but also means it is not a remote-collaboration feature. And because it is marked Experimental, behavior can change between releases. None of this is a dealbreaker for a creator using it as an accelerator, but it does mean you should not bolt a shipping pipeline onto it yet.

Troubleshooting Common Failures

  • The agent cannot find the server. Confirm auto-start is enabled and the editor is open. The server only exists while the editor is running, and it lives at the loopback address, so a closed editor means no connection.
  • Connection refused from another device. That is expected. The server rejects non-loopback origins by design. Run the agent on the same machine as the editor.
  • A new custom tool does not appear. Live Coding will not register new UFUNCTION tools. Restart the editor so the Toolset Registry picks them up.
  • The agent made a wrong change. Roll back from version control and tighten the prompt to a single outcome. Broad, multi-step prompts are where confidently wrong decisions slip in.
  • Nothing happens after a prompt. Check that you launched the agent from the project root so it loaded the generated config, and that the client name you generated matches the agent you are running.

What to Try Next

Once the loop feels natural, push it toward repetitive scene work that is tedious by hand: scattering vegetation across a large environment, batch-renaming and organizing an imported asset library, or generating a set of lighting variations to compare. Pair the agent with on-device model work for characters, as in NVIDIA's approach to on-device AI NPCs in UE5, or with upstream asset generation like text-to-CAD models that feed printable, editable geometry into your scene.

The longer arc is worth tracking. Epic has framed the MCP plugin as a foundation for Unreal Engine 6, which it discussed at its State of Unreal 2026 walkthrough and positioned to arrive around 2027 as a unified platform that merges UE5 and the UEFN toolset and leans on the Verse language. The current Experimental plugin is the early, hands-on version of that future. Learning the agent-driven workflow now means you will already be fluent when the MCP-native engine becomes the default way creators build.

Frequently Asked Questions

Do I need to know how to code to use Unreal MCP?

No. The setup is menu-driven and a single console command, and you direct the agent in plain language. Coding knowledge helps when you want to add custom tools or review what the agent changed, but it is not required to spawn actors, light a scene, or build material instances.

Is the Unreal MCP plugin free?

The plugin ships with Unreal Engine 5.8, so there is no extra charge for it. You do pay for whatever model you connect, since Claude and Gemini bill for usage through their own accounts and APIs. The editor side adds no cost.

Which AI models work with it?

Any MCP-compatible client works. Unreal can generate configs for Claude Code, Gemini, Cursor, VS Code, and Codex, or all of them at once. That choice is open by design, so you are not locked into a single vendor's model.

Is it safe to run on a work project?

The server is loopback-only with no authentication, so it does not expose your project to the network. The real risk is the agent itself making a wrong edit. Keep work projects under version control, commit before each session, and review every change. Treat the feature as Experimental, because Epic labels it that way.

Can it replace a technical artist?

No. It removes mechanical steps and speeds up blocking, lighting, and look-dev, but it still needs a creator to set intent, judge the result, and catch errors. It is best understood as a fast collaborator inside the editor, not an autonomous replacement for skilled artists.