Home › Unreal MCP and UEFN MCP: Connect Claude Code, Cursor and Codex (2026)

Unreal MCP and UEFN MCP: Connect Claude Code, Cursor and Codex (2026)

Unreal Engine 5.8 and Unreal Editor for Fortnite (UEFN) both run an MCP server inside the editor, so a coding agent like Claude Code, Cursor or Codex can place actors, edit Verse, configure devices and start play sessions for you. This guide covers the setup step by step, using only what Epic's docs and each client's docs say (checked October 30, 2026): how to turn it on, how to connect each agent, what the agent can and can't do, the safety limits, and what to have ready before the Epic AI MegaJam.

Last updated:

Free download · one page + PDF · updated weekly, current edition November 16, 2026

🎁 Free: The AI Game Dev Stack 2026

The best AI tool for each job in a solo or indie game (3D, sprites and pixel art, animation, audio, NPCs), MCP setups for Unity, Unreal, Godot and Roblox, and which free plans you can actually ship with.

Yours free when you join the VibeStack Weekly: new AI game-dev tools and releases every Monday, 5-minute read. Unsubscribe anytime.

Unreal MCP vs UEFN MCP at a glance

Unreal MCP (Unreal Engine 5.8)UEFN MCP (Unreal Editor for Fortnite)
StatusExperimental plugin. Epic warns that many features are incomplete and APIs can changeBeta, available since August 20, 2026. Epic says to expect rough edges
InstallEnable the Unreal MCP and All Toolsets plugins (Edit > Plugins)Built in, no plugin to install. Check Python Editor Scripting and UEFN MCP Toolsets in Project Settings
Start the serverAuto Start Server in Editor Preferences, or ModelContextProtocol.StartServer in the consoleConfigure auto-start; to start or stop the server you close and reopen the editor
Default endpointhttp://127.0.0.1:8000/mcp (server name unreal-mcp)http://127.0.0.1:8000/mcp
Client configModelContextProtocol.GenerateClientConfig writes it for ClaudeCode, Cursor, VSCode, Gemini, Codex or AllEpic's page shows writing .mcp.json by hand in your UEFN project's root folder
What agents can doSpawn actors, set up lighting, create material instances, inspect Slate widgets, run automation tests, plus any custom tools you addRead, write and compile Verse; create Scene Graph entities; place Creative devices and edit their properties; start, stop and inspect play sessions
PlaytestingPlay In Editor (PIE)Play-in-Client (PIC), not PIE
Clients Epic namesClaude Code, Cursor, MCP Inspector, plus config support for VS Code, Gemini and CodexClaude Code, Cursor, Codex and the MCP Inspector

Both are the same plugin underneath. Epic's announcement says UEFN's toolsets come through the same Toolset Registry as UE 5.8, but not every UE 5.8 toolset works in UEFN yet, and more are coming “on the road to UE6.” If you only need the short version, our AI tools for Unreal Engine guide has a summary. This page goes step by step.

Commercial alternative (not covered here): UE Conduit is a paid third-party UE 5.8 Win64 plugin + local MCP server (569 tools per vendor; shop from $29.99; no free tier; checked November 7, 2026). It is separate from Epic's Unreal MCP / UEFN MCP. Notes: AI tools for Unreal · tool page.

Update: Unreal Engine 5.9 MegaJam Preview (November 9, 2026)

The steps below were written for UE 5.8. Epic's UE 5.9 MegaJam Preview (launcher, GitHub or Linux download) changes a few things, per Epic's announcement and known-issues post:

Everything here is Experimental and we haven't run the Preview ourselves. Test on a copy of your project; Epic says the full 5.9 release ships next year. UEFN isn't part of this Preview.

Run Claude Code, Codex, Cursor or OpenCode in the Unreal Assistant panel (UE 5.9 Preview)

Epic's 5.9 docs page Run External AI Agents in the Unreal Assistant Panel (read November 10, 2026) explains how the panel works: the editor starts your agent as a local program, talks to it over the Agent Client Protocol (ACP), and connects it to the editor's own Unreal MCP server, so you don't write a client config file. Your agent supplies the replies, the model and the tool calls, using your own account with that agent's provider; while an external agent is selected, your chat goes to that agent, not to Epic's Unreal Assistant service. The panel connects to one editor at a time.

AgentWhat the editor runsInstall (per Epic's table)
Claude Codeclaude-agent-acpnpm install -g @agentclientprotocol/claude-agent-acp
Codexcodex-acpnpm install -g @agentclientprotocol/codex-acp
Cursoragent acpInstall the Cursor CLI
OpenCodeopencode acpInstall the OpenCode CLI
CustomYour own command and argumentsYour own ACP agent

Epic notes the two npm adapters are published by the Agent Client Protocol project, not by Epic Games.

Before you start (Epic's prerequisites): the Unreal Assistant and Unreal MCP plugins are enabled (both are on by default); All Toolsets, or the specific toolset plugins your agent needs, is enabled, because without toolsets the agent has no editor tools (the same trap as known issue UE-412135 above); the MCP server is running (it starts with the editor by default); Node.js is installed if you use an npm adapter; your agent's CLI is installed and signed in (claude login or codex login), since the adapter uses that sign-in; and the adapter is installed, after which you restart the editor so it finds the adapter on your PATH.

  1. Open the panel: Window > Unreal Assistant, or click Assistant on the right of the status bar at the bottom of the editor.
  2. Pick your agent: Edit > Editor Preferences, under General select Unreal Assistant, expand External Agent, choose Claude Code, Codex, Cursor, OpenCode or Custom in the External Agent dropdown, then enable Use External Agent. External Agent Status should show the full path to the adapter. Custom adds Custom Agent Command and Custom Agent Arguments fields; Epic warns not to put credentials there, because that text shows in the panel and is written to the editor log.
  3. Approve it: the first time the editor runs an agent's command in a project, it asks. Allow saves the approval for that project (per user, per project and per command line) and starts the agent; Don't Allow turns Use External Agent off and keeps the Unreal Assistant service.
  4. Prompt it: the Agent selector at the top left switches between Unreal Assistant and each external agent (agents whose adapter isn't installed are grayed out), and each keeps its own chat history. The prompt bar shows the agent's own settings: for Claude Code the permission modes are Manual, Accept edits, Plan, Auto and Bypass permissions. Expand Required Actions to see each Unreal MCP tool call.

Gotchas from Epic's troubleshooting table: “Could not find <command>” means install the adapter and restart the editor (it reads PATH at startup; if it still fails, fully quit the Epic Games Launcher, including from the system tray, or use Custom with a full path). Pressing Enter adds a new line; click the send arrow. Claude Code in Manual mode can sit on “Waiting for your approval” with no buttons; switch to Auto or Accept edits, start a New Chat and resend. If the agent replies but can't see the editor, check the MCP server is running. The prompt bar shows the previous agent's model until you send your first message.

Epic's 5.9 Preview release notes (last updated November 9, 2026) add that Unreal Assistant gains a tool-access setting (Ask, Read, Edit, Auto or Full) that controls how much it may do on its own, notification preferences (a sound, a taskbar flash or a badge when it needs you), and a custom command to hand work to an external agent. Our advice for a jam: keep approvals on (Accept edits rather than Bypass permissions), commit first, and read what each tool call did.

Prefer your own terminal or IDE, or want one agent driving several editors? Use the config-file route below instead. Epic says it suits clients the panel doesn't support and multi-editor setups.

Unreal MCP setup changes in UE 5.9 Preview

The step-by-step section below is for 5.8. Epic's Unreal MCP page for 5.9 (read November 10, 2026) changes these details:

The Fab toolset: what Epic has documented so far

Epic's Fab roadmap card Fab Agent API and MCP (Experimental) (posted November 9, 2026) says Fab now exposes search, asset details, your library and downloads to agents, “so an assistant can find an asset and bring it into a project without the developer leaving the editor.” The API covers searching the catalog, reading an asset's details and downloading free assets, “with licence acceptance handled as part of the flow.” The companion Fab toolset in the editor does the same and adds searching your library and downloading and installing items you've already bought. That's all Epic has published: we couldn't find a setup page, plugin name or tool list for it in the 5.9 docs on November 10, 2026. So enable All Toolsets, ask your agent “What toolsets are available?”, and keep tool approval on, since an agent accepting a licence is accepting it for you. The Quixel Megascans now free on Fab are an obvious use (see our Megascans notes for the licence details).

Lore source control through Unreal MCP

Epic's Getting started with Lore for Unreal Editor tutorial says the Lore plugin is Experimental from UE 5.9 Preview 1. You run a local Lore server, create a repository next to the .uproject, add a .loreignore, then pick Lore as the provider under Revision Control > Connect to Revision Control. Through Unreal MCP an agent can then check status, check out, validate and submit changes, browse history, sync, revert and manage branches. Epic's caution: an MCP submission includes every file eligible for check-in, so review pending changes before you let the agent submit.

PCG graphs through Unreal MCP: Epic's workflow (UE 5.9 Preview)

Epic's 5.9 page Working with PCG and LLMs Using Unreal MCP (Experimental; read November 10, 2026) covers the dedicated PCG toolset for building and editing Procedural Content Generation graphs over MCP. Epic says the advice comes from “day-to-day production use”.

  1. Connect your agent to Unreal MCP as above.
  2. Load the PCG toolset: ask your agent to load it, or enable the PCGToolset plugin in Edit > Plugins.
  3. Load the skill Skill_PCGGraphGeneration: Epic calls this a mandatory part of session setup. Without it, models “misunderstand PCG concepts”, overcomplicate solutions, misuse nodes and produce unreliable graph logic. It's for anything you can describe as a rule or pattern (scattering vegetation, populating city blocks, road networks), not one-off placement. Epic says how you load a skill depends on your client's documentation.
  4. Point it at examples: Epic says reference graphs give the most reliable results. The PCG plugin ships samples under Engine > Plugins > Procedural Content Framework (PCG) > SampleContent. Reuse a graph if one already works, duplicate and modify one that's close, and only build from scratch when nothing fits; that also saves context.
  5. Give explicit context: select the assets in the Content Browser or actors in the Level Editor before you ask, instead of letting the agent go looking. Otherwise it may write temporary Python scripts to inspect content, which costs time and tokens. Epic says Semantic Search (shipped with UE 5.8 or later) is also available to the agent, but searching the Content Browser yourself is often faster.
  6. Plan, then run in small steps: for big graph edits or attribute work, ask for a plan and the list of nodes it will change first, then watch and interrupt early if it heads the wrong way.

Prompts Epic suggests: “Look for an example graph that performs a similar operation.” · “Review the graph before acting.” · “List the nodes you intend to modify.” · “What examples or references are you planning to use?” · “Use Data View for the attribute inspection.”

Watch the cost: analyzing large or multiple graphs, big datasets or many assets is slow and eats context. The agent can't read PCG point attributes directly; the toolset's Dataview does that work outside the context window, and Epic recommends naming it in your prompt because models don't always pick it. Combine this with the roughly 120-second Claude Code timeout above and keep each request small.

Extra PCG skills the agent can scan for, or that you can ask it to load:

SkillUse it for (per Epic)
Skill_PCGShapeGrammarDefinitionRule-driven sequences of modules along a path: building facades, corridor modules, street furniture.
Skill_PCGMeshPartitionProjects that use Mesh Terrain as the landscape: layer order, material weight channels and writing to the terrain without breaking priorities.
Skill_PCGInstancingOnMeshActorCovering a mesh with detail (greebles, clutter, micro-props) with Poisson sampling, without generating millions of points on a big mesh.
Skill_PCGBiomeCoreA biome system from scratch: what spawns where by landscape rules, priority zones and density filters, with guardrails for the common silent failures where nothing spawns.

We haven't run the PCG toolset ourselves (no Unreal Editor on our test machine). Everything above is from Epic's page. Prefer an in-editor assistant? Bezi also assembles PCG graphs; see AI tools for Unreal Engine.

What MCP is, and what the Unreal server exposes

The Model Context Protocol is an open spec (modelcontextprotocol.io) for how an AI client talks to a server. A server can offer Tools (functions the agent calls with typed parameters), Resources (read-only data) and Prompts (reusable templates). Per Epic's docs, Unreal MCP only offers Tools: no shipping toolset advertises Resources or Prompts.

The tools themselves come from the Toolset Registry, not from the MCP plugin. That's why Unreal Engine needs the All Toolsets plugin (or individual toolset plugins): with only the MCP plugin enabled, the server starts but has no tools. Epic's Claude Code plugin README says the registry exposes hundreds of tools across 30+ toolsets, covering actors, Blueprints, assets, materials, meshes, animation and Control Rig, Sequencer, Niagara, UMG widgets, gameplay tags and GAS, automation tests, screenshots and the content browser.

Tool search is on by default. Instead of listing every tool, the server gives the agent three discovery tools, list_toolsets, describe_toolset and call_tool, and the agent looks up toolsets as it needs them. That keeps the tool list small. It's the Enable Tool Search setting in Editor Preferences; turning it off advertises every tool up front, with a much bigger schema payload.

Set up Unreal MCP in Unreal Engine 5.8

  1. Enable the plugins. Open Edit > Plugins, search for Unreal MCP and tick Enabled, then do the same for All Toolsets. The Toolset Registry plugin they depend on is enabled automatically. Restart the editor when prompted. Want fewer tools? Enable individual toolset plugins instead of All Toolsets.
  2. Start the server. Open Edit > Editor Preferences, go to the General group, select Model Context Protocol and turn on Auto Start Server (it's off by default). The server then starts with the editor on http://127.0.0.1:8000/mcp. The same panel sets the port (default 8000) and URL path (default /mcp). To start it only when you need it, leave auto-start off and type ModelContextProtocol.StartServer in the editor console (optionally with a port, e.g. ModelContextProtocol.StartServer 8000). Launch flags also work: -ModelContextProtocolStartServer and -ModelContextProtocolPort=N.
  3. Generate the client config. In the editor console (backtick key by default), run ModelContextProtocol.GenerateClientConfig ClaudeCode, or swap in Cursor, VSCode, Gemini, Codex or All. Epic's Claude Code plugin docs say where the file goes: next to your .uproject in an installed (launcher) build, or at the workspace root (next to Engine/) in a source build. The Output Log shows where it was written. The Claude Code file looks like this:
    {
      "mcpServers": {
        "unreal-mcp": {
          "type": "http",
          "url": "http://127.0.0.1:8000/mcp"
        }
      }
    }
    JSON configs (Claude Code, Cursor, VS Code, Gemini) are merged with existing entries, so re-running is safe. The Codex config is TOML and write-once: the command won't overwrite an existing .codex/config.toml, so delete a stale one or edit it by hand.
  4. Start your agent from that folder. Launch the agent from the project or workspace root where the config was written, after the editor (and server) is running. If the agent was already open, reconnect it.
  5. Test it. Epic's suggested first prompts: “What actors do I have selected?” and “What are a few things you can do in Unreal?”

Optional: run the agent inside the editor. Epic documents using the Terminal plugin (Edit > Plugins, search Terminal, restart) with three Startup Commands under Editor Preferences > General > Terminal: set the terminal type (set TERM=xterm-256color on Windows cmd, export TERM=xterm-256color on bash or zsh, otherwise CLIs like claude may print raw escape codes), cd to the folder that holds .mcp.json (the Terminal starts in the engine install folder in launcher builds), then the agent command, e.g. claude.

Set up UEFN MCP

  1. Turn it on per project. In your Project Settings, check Python Editor Scripting and UEFN MCP Toolsets. Epic says both must be enabled. (The announcement calls this enabling the UEFN MCP toolset under beta access.)
  2. Auto-start the server. Epic lists configuring MCP auto-start as a prerequisite. In UEFN you can't start and stop the server from the console: Epic's tip is to close and reopen the editor. If port 8000 is taken, change Server Port Number in Editor Preferences.
  3. Create the client config. Epic's UEFN page walks through it by hand: in your UEFN project's root folder, create a text file, paste the JSON for your agent, and save it as .mcp.json (not .mcp.json.txt; delete any leftover .txt copy). Epic's example is Claude Code's format, the same as above, pointing at http://127.0.0.1:8000/mcp. For Cursor or Codex, use their formats below.
  4. Launch the agent from the project root where the config file is. (One line of Epic's prerequisites says to start the agent from the Fortnite UEFN install directory, but the connection steps and troubleshooting both say the project or workspace root where the config lives, so use the folder with your .mcp.json.)
  5. Check each toolset with Epic's test prompts below, then save and keep a copy of the project before bigger changes.

The UEFN toolsets, per Epic's docs:

ToolsetWhat it doesEpic's test prompts
VerseReads, edits and compiles your project's Verse. File operations are sandboxed to your project“List the Verse files in my project.” “Add a log message when the round starts, then compile the Verse and tell me if it was built.”
Verse Scene Graph (entities and components)Creates entities, adds components, reads and edits transforms“Create an entity at the origin and give it a mesh component.” “Move it up by 500 units.”
Creative DevicesBrowses the device catalog, places devices and edits any @editable properties“What devices are available to place in this project?” “Place a player spawner and a timer device in the level.”
SessionsStarts, stops and inspects a play session (Play-in-Client), pushes Verse-only changes to a running session, reads the client log“Start a play session for my project.” “Push just the Verse changes to the running session.” “Check the client log for any errors, then stop the session.”

Epic's announcement also mentions building UI with UMG in UEFN; the UEFN docs' toolset list doesn't show a separate UMG toolset, so ask your agent to list its tools to see what your version has. Epic's own tips: be specific with names (“the Timer device,” not “that thing I added”), ask the agent to list available tools first, ask for a plan before multi-step changes, and keep each change small enough to review.

Connect Claude Code, Cursor or Codex

Epic's docs say to follow your client's own docs for connection details, so here is what each one documents for a local HTTP server like this.

Claude Code

Cursor

Cursor reads project MCP servers from .cursor/mcp.json in your project (or ~/.cursor/mcp.json for every project), and a remote or HTTP server is an entry with a url. For Unreal Engine, ModelContextProtocol.GenerateClientConfig Cursor writes Cursor's config for you. For UEFN, where Epic only shows Claude's JSON, Cursor's documented format with Epic's endpoint is:

{
  "mcpServers": {
    "unreal-mcp": {
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

Open the project folder in Cursor and turn the server on or off from Customize in the sidebar. Cursor asks for approval before it runs MCP tools by default, and you can expand a call to see its arguments, which is worth doing for anything that edits your level.

Codex

Codex keeps MCP servers in config.toml: ~/.codex/config.toml by default, or .codex/config.toml in a project (trusted projects only). The Codex CLI, IDE extension and ChatGPT desktop app share it. For Unreal Engine, ModelContextProtocol.GenerateClientConfig Codex writes the project file (once; see above). By hand, a streamable HTTP server is a table with a url:

[mcp_servers.unreal-mcp]
url = "http://127.0.0.1:8000/mcp"

Check it with codex mcp list, or /mcp inside the Codex TUI. Codex also documents tool_timeout_sec (default 60 seconds) per server, plus enabled_tools and disabled_tools allow and deny lists if you want to limit what the agent can call.

Comparing the agents themselves? See Claude Code vs Codex and Cursor vs Windsurf vs Claude Code.

Same idea in Godot: Godot doesn't ship an MCP server like Unreal MCP, but community servers connect the same three agents to Godot, from running your project and reading its errors to editing the open editor. Setup, a comparison and our test results are in Godot MCP: connect Claude Code, Cursor or Codex.

Same idea in Roblox: Roblox Studio has an MCP server built in, so there's no plugin to install: you turn it on in Assistant and connect Claude Code, Cursor or Codex with Quick connect or one config entry. Exact configs, its 28 tools and the safety steps are in our Roblox Studio MCP setup guide.

Comparing engines? Unity, Unreal, UEFN, Godot and Roblox Studio MCP side by side (official vs community, setup, tools, playtesting, safety) are in game engine MCP servers compared.

Add your own tools (Unreal Engine)

Unreal MCP is built to be extended, and every toolset you write also works for the engine's other AI surfaces that use the registry. Epic documents two routes:

Epic's advice: one tool, one job, descriptive names and structured return types instead of free-form strings. Claude Code users can scaffold a toolset with the plugin's create-toolset skill. For the full walkthrough (a worked Python example, registration, testing in the editor and the MCP Inspector, and debugging), see how to write a custom Unreal MCP toolset in Python, which now covers the UE 5.9 changes (access modes, execute_python, agent skills, AIRuntimeCallable).

Example: a medieval city built with Unreal MCP and the Tripo CLI

Tripo's tutorial Build a Medieval City with Tripo and Unreal MCP (first published September 18, 2026, updated October 27) shows the whole loop in Unreal Engine 5. It uses the same two plugins as our setup above (Unreal MCP and All Toolsets), plus the Tripo CLI so a coding agent (GPT-6 Astra in the post) can make the 3D models itself:

We haven't run this tutorial ourselves. The Tripo side spends API credits, not Studio credits; our Tripo CLI notes show how to see the cost with --dry-run before anything is generated. Try it: Tripo (try Tripo ↗*)

Limits and safety

Troubleshooting

ProblemWhat Epic's docs suggest
Agent doesn't see the serverLaunch it from the folder that holds the config file, after the editor and server are running. Reconnect if it was already open.
Server not runningCheck the Output Log: on startup the server logs its address, port and path, and bind failures show up there. For more detail run Log LogModelContextProtocol Verbose. In UEFN, check both Project Settings boxes and restart the editor.
Port 8000 already in useChange Server Port Number in Editor Preferences (or -ModelContextProtocolPort=N), restart, and regenerate the config so the URL matches.
A toolset is missingRun ModelContextProtocol.RefreshTools, and check the toolset's plugin is enabled in the project.
Two editors openEach editor serves on its configured port and a client talks to whatever answers there. Give each project its own fixed port and config, and start each agent from its own project.
Is it the agent or the server?Run the official MCP Inspector (npx @modelcontextprotocol/inspector) and point it at http://127.0.0.1:8000/mcp over Streamable HTTP. It lists every tool and lets you call one without an agent in the way.

Epic AI MegaJam prep checklist

Rule 7(h) of the 2026 Epic AI MegaJam Official Rules says entrants “may prepare AI tools, agent configurations, Model Context Protocol (“MCP”) settings, prompt libraries, and scripts before the Contest Period,” and that Epic may ask for these materials or their version control history. Gameplay, levels and art must be made during the jam (November 12-15). Our checklist, based on that and the docs above:

Update, November 13 (the jam is live): Epic staff have since answered the main tooling questions in the official forum threads. Pre-jam scripts and MCP toolsets are fine, but anything they generate on or after November 12 counts as jam work, so declare them. “Scripts” means tooling and pipeline (build, packaging), while menus, input and save systems are game code. Art made before the jam, AI-generated or not, can't be used. List sourced assets and pre-jam declarations on your itch.io submission page. Submissions closed November 15 at 5:59 PM PST (6:59 PM MST) with 2,784 entries; winners are due by January 29, 2027. Full summary: Epic staff answers and what happens next.

Dates, prizes, team rules and submission formats are in our Epic AI MegaJam 2026 guide.

Related: AI tools for Unreal Engine · Roblox Studio MCP setup (Studio has its own built-in MCP server) · AI playtesting and QA · UEFN conversations for LLM NPCs · how to vibe code a game.

Building with agents? Get the VibeStack Weekly digest: new AI game-dev tools and workflows, every Monday.

UE 5.9 Preview sources (read November 10, 2026): Epic's Unreal MCP page for 5.9, Working with PCG and LLMs Using Unreal MCP, Run External AI Agents in the Unreal Assistant Panel, UE 5.9 Preview release notes (last updated November 9, 2026), the UE 5.9 MegaJam Preview announcement and known issues and Fab Agent API and MCP roadmap card (both November 9, 2026), and Epic's Lore for Unreal Editor tutorial.

Sources (checked October 30, 2026): Epic's Unreal MCP documentation (Unreal Engine 5.8) and UEFN MCP documentation; the fortnite.com post Unreal MCP is now available in UEFN and its forum announcement (August 20, 2026); Epic's Unreal Engine skills plugin for Claude Code (README, setup and operations references); the MCP pages of the Claude Code, Cursor and Codex docs; and the 2026 Epic AI MegaJam Official Rules (rule 7(h)). The Cursor and Codex snippets are each client's documented config format filled in with Epic's default endpoint. The checklist and troubleshooting order are ours, not Epic's. Both features are Experimental or beta, so menu names and defaults can change; check Epic's pages for your editor version. VibeStack Weekly isn't affiliated with Epic Games, Anthropic, Anysphere or OpenAI.

Get the Starter Stack ($12) Get the free weekly digest

*Some links on this page are affiliate links: if you sign up through them we may earn a commission at no extra cost to you. It never affects our picks. Disclosure

Our picks (4)

Claude Code

AI Code Editors & Agents

Anthropic's agentic coding tool for the terminal, VS Code and JetBrains. Uses a Claude Pro/Max plan or the API.

#cli#agent
freemium

Cursor

AI Code Editors & Agents

AI-first code editor with agent mode, built on VS Code.

#editor#agent
freemium

OpenAI Codex

AI Code Editors & Agents

OpenAI's coding agent: CLI, IDE extension, web and cloud tasks. Included in ChatGPT plans (Free with limits). Unity ships an official Codex skills plugin (unity@unity-agent-plugin) for Unity 6+. The ModRetro Chromatic plugin (November 2026) builds Game Boy and Game Boy Color games as GB Studio projects, playtests them in a built-in emulator and can flash them to a Chromatic handheld cartridge.

#cli#agent

UE Conduit

Game Dev Tools

Commercial Unreal Engine 5.8 editor plugin + local MCP server from Jag Journey, LLC (ueconduit.com). Plugin is compiled Win64-only (no C++ source); MCP server is open source MIT via npm (stdio or Streamable HTTP; plugin listens on port 9377). Vendor home (checked November 7, 2026): 569 tools across 89 categories; editor panel lists 6 LLM providers; works with Claude Code, Claude Desktop or any MCP client. Shop SKUs (Nov 7, 2026): UE Conduit $29.99 (UEC-UE58-WIN64 — product title does not spell “3 months”; Terms license lengths are 3 months / 12 months / lifetime), 12 months $99 (UEC-UE58-WIN64-12M), Lifetime $2,999 (UEC-UE58-WIN64-LIFETIME). No free tier on shop. Stripe; all sales final once key/download delivered; one license locked to one computer (up to 3 moves / 12 months). May ship games built with the Plugin. Affiliate probes (/affiliate /affiliates /partners /referral) → 404 → affiliate null. Not the same product as Fab/conduit.unrealtools.com “Conduit” (~95 tools). We haven't tested it hands-on.

#unreal#mcp#agent#win64#paid

+ Your tool here

Reach builders, vibe coders & indie game devs. Featured listings from $49/mo.

Advertise →
🧰 The Vibe Coder's Starter Stack: AI rules files, a prompt library and a ship-it checklist. $12.
Get the pack

FAQ

Can Claude Code build PCG graphs in Unreal Engine?

Yes, in the UE 5.9 Preview, per Epic's Working with PCG and LLMs Using Unreal MCP page. Connect the agent to Unreal MCP, load the PCG toolset (or enable the PCGToolset plugin), then load the Skill_PCGGraphGeneration skill, which Epic calls mandatory. Point it at the sample graphs in the PCG plugin's SampleContent folder, select the assets yourself, ask for a plan first and use Dataview for attribute inspection. It's Experimental and we haven't tested it.

How do I run Claude Code inside the Unreal Editor?

In the UE 5.9 Preview, use the Unreal Assistant panel. Install Node.js and the ACP adapter (npm install -g @agentclientprotocol/claude-agent-acp), sign in with claude login, enable All Toolsets, and restart the editor. Then in Editor Preferences > Unreal Assistant > External Agent pick Claude Code, enable Use External Agent, allow the command when asked, and open Window > Unreal Assistant. Codex uses @agentclientprotocol/codex-acp, Cursor runs agent acp and OpenCode runs opencode acp. No config file is needed. Epic documents this; we haven't run it.

What is the Fab toolset in Unreal MCP?

A new Experimental toolset in the UE 5.9 Preview that lets an agent search the Fab catalog, read asset details, browse your library and download and install free or already-purchased assets into your project, with licence acceptance handled as part of the flow (Epic's Fab roadmap post, November 9, 2026). Epic hasn't published a setup page or tool list for it yet, so enable All Toolsets and ask the agent to list its toolsets.

Why does my agent have no tools in Unreal Engine 5.9 Preview?

It's a known issue in the UE 5.9 MegaJam Preview (UE-412135): new projects start the Unreal MCP server but leave the toolset plugins off, so list_toolsets returns no actor, level, asset, Blueprint or Python tools. Enable All Toolsets in Edit > Plugins (or add AllToolsets to the .uproject), restart the editor, then reconnect the agent.

What is Unreal MCP?

An Experimental plugin in Unreal Engine 5.8 that runs a Model Context Protocol server inside the Unreal Editor, so MCP-compatible agents like Claude Code, Cursor or Codex can call editor tools: spawning actors, lighting, material instances, Slate widget inspection, automation tests and custom tools. The tools come from the Toolset Registry via the All Toolsets plugin.

Does UEFN have MCP?

Yes. Since August 20, 2026, Unreal MCP is built into Unreal Editor for Fortnite as a beta, with no plugin to install. Check Python Editor Scripting and UEFN MCP Toolsets in Project Settings, create the client config, and agents can work with Verse, Scene Graph entities, Creative devices and play sessions.

What URL does Unreal MCP use?

By default http://127.0.0.1:8000/mcp, in both Unreal Engine and UEFN. You can change the port (Server Port Number) and, in Unreal Engine, the URL path in Editor Preferences. The server only accepts local connections and has no authentication.

How do I connect Claude Code to Unreal Engine?

Enable the Unreal MCP and All Toolsets plugins, start the server (Auto Start Server or ModelContextProtocol.StartServer), run ModelContextProtocol.GenerateClientConfig ClaudeCode to write .mcp.json, then start claude from that folder and approve the server. Epic's unreal-engine-skills-for-claude-code plugin adds an Unreal skill on top.

Can Cursor or Codex use Unreal MCP?

Yes. Epic's GenerateClientConfig command supports Cursor and Codex (as well as VS Code and Gemini). Cursor reads .cursor/mcp.json with a url entry; Codex reads an [mcp_servers.name] table with a url in config.toml. Codex's generated TOML is write-once, so delete a stale file before regenerating.

Is it safe to use Unreal MCP?

Use it on your own machine with source control. Epic says the server isn't safe to expose beyond the local machine, any local process running as your user can connect, tool calls can move or delete assets, and one tool can run arbitrary Python. Keep per-tool approvals on and commit before long sessions.

Can I set up MCP before the Epic AI MegaJam?

Yes. Rule 7(h) allows AI tools, agent configurations, MCP settings, prompt libraries and scripts to be prepared before the November 12 start. Gameplay, levels and art must be made during the jam, and Epic may ask for your prep materials or their version control history.

Why can't my agent find the Unreal MCP server?

Usually it was launched from the wrong folder or before the editor started. Start the agent from the folder with the config file after the server is running, check the Output Log for the server's address, and in UEFN confirm both Project Settings boxes are checked and restart the editor.

Free download · one page + PDF · updated weekly, current edition November 16, 2026

📬 Get the VibeStack Weekly + the free AI Game Dev Stack 2026

The best AI tool for each job in a solo or indie game (3D, sprites and pixel art, animation, audio, NPCs), MCP setups for Unity, Unreal, Godot and Roblox, and which free plans you can actually ship with.

Yours free when you join the VibeStack Weekly: new AI game-dev tools and releases every Monday, 5-minute read. Unsubscribe anytime.