Home › How to Write a Custom Unreal MCP Toolset in Python (UE 5.8 and 5.9, 2026)

How to Write a Custom Unreal MCP Toolset in Python (UE 5.8 and 5.9, 2026)

Unreal MCP gives Claude Code, Cursor or Codex hundreds of editor tools, and you can add your own. This guide goes past setup: how to write a Python toolset the way Epic's shipped ones are written, get it registered, check it in the editor and the MCP Inspector, test it, and fix it when the agent can't see it. It uses only Epic's docs, Epic's own create-toolset skill and the official MCP Inspector docs (checked October 31, 2026), and says plainly where they stop. Updated November 10, 2026 with what the UE 5.9 Preview docs change.

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.

The short answer

  1. Check it doesn't exist yet. Ask your agent to run list_toolsets and describe_toolset. Epic's skill says generic jobs often already live in a broader toolset (ObjectTools already gets and sets UObject properties).
  2. Write a class that inherits unreal.ToolsetDefinition, decorated with @unreal.uclass(), in a .py file under a plugin's Content/Python/ folder.
  3. Mark each tool with @toolset_registry.tool_call and @staticmethod. Type hints become the JSON Schema; Google-style docstrings become the descriptions. On UE 5.9, also pass an access mode (5.9 changes).
  4. Load it: restart the editor or run ModelContextProtocol.RefreshTools, then reconnect your agent.
  5. Test it without the agent in the MCP Inspector, then with Epic's ToolCallTestCase tests, and only then hand it to Claude Code, Cursor or Codex.

New to Unreal MCP? Set up the server and your agent first with our Unreal MCP and UEFN MCP setup guide. This page assumes the server already runs on http://127.0.0.1:8000/mcp.

UE 5.9 Preview update: access modes, agent skills, execute_python and cooked builds

The rest of this guide was written against Unreal Engine 5.8. The UE 5.9 Preview docs add a dedicated page, Using Python with AI Agents (under AI Features, Tools, and Plugins), and the 5.9 Unreal MCP page adds sections on tool metadata, agent skills and cooked builds. Both were read on November 10, 2026. They settle two things this guide had flagged as unclear (how registration works and whether Python tools can be async) and add a few new ones. Prerequisites per Epic: Unreal MCP set up with an agent connected, and the Python Editor Script Plugin enabled.

TopicUE 5.8 (rest of this guide)UE 5.9 Preview (Epic's docs)
RegistrationDocs page and create-toolset skill disagreed, so we register by hand with a guardDocumented: create a Registration([...]) object (from toolset_registry.registration) in your package's __init__.py and call _registration.register() from the plugin's init_unreal.py
Access modeNot part of the Python decorator@toolset_registry.tool_call(mode=unreal.ToolAccessMode.READ), WRITE or EXECUTE. Unreal MCP sends it to clients and maps it to MCP's readOnlyHint, so clients can decide whether to ask for confirmation. Epic says the default is Execute, so set it on every tool.
Type hintsStandard Python typesMapping spelled out: list[T] → unreal.Array(T), dict[str, V] → unreal.Map(str, V), set[T] → unreal.Set(T), and T | None makes a parameter optional
Async toolsOnly shown in C++Python tools can be async def; Epic's own execute_python is asynchronous
TestsImport and discovery not documentedPut tests in a tests package inside your toolset package and register them from init_unreal.py with register_test_runner('<package>.tests', '<Automation.Path>') (from _unittest_runner.unittest_runner_bridge). They then show up in Session Frontend's automation tests under that path
Tool searchThree meta-toolsFour: list_toolsets, describe_toolsets, describe_tools and call_tool
Agent skillsOnly the Claude Code plugin's skillsSkills inside the engine, written in Python, C++ or Markdown (below)
Packaged gamesNot coveredCooked builds can host the MCP server, but only tools tagged AIRuntimeCallable are available there (below)

The 5.9 registration pattern applied to our example

Epic's example is the GeometryTools toolset in the GeometryToolset plugin (Engine/Plugins/Experimental/Toolsets/GeometryToolset/Content/Python/geometry_toolset/geometry_ops.py): the toolset sits in a module inside a package, the package's __init__.py builds the Registration, and init_unreal.py calls register(). Here's our NamingTools example from below laid out the same way, with a read-only access mode. The layout and names are ours; the calls are Epic's.

# Content/Python/naming_tools/naming_ops.py
@unreal.uclass()
class NamingTools(unreal.ToolsetDefinition):
    """Suggests asset names that follow this project's
    prefix convention (BP_, SM_, M_ and so on)."""

    @toolset_registry.tool_call(mode=unreal.ToolAccessMode.READ)
    @staticmethod
    def suggest_asset_name(base_name: str,
                           asset_type: str) -> str:
        ...  # body unchanged

# Content/Python/naming_tools/__init__.py
from toolset_registry.registration import Registration
from naming_tools import naming_ops

_registration = Registration([naming_ops.NamingTools])

# Content/Python/init_unreal.py
from naming_tools import _registration

_registration.register()

After a change, Epic says to reload the module and run ModelContextProtocol.RefreshTools; connected clients might need to reconnect. Epic's toolset conventions now also say the class docstring should read as guidance on when an agent should use the toolset, and that exceptions a tool raises go back to the client as tool errors.

When the agent writes the Python: execute_python

You don't always need a toolset. In 5.9 the PythonScriptingTools toolset in EditorToolset gives agents execute_python (Execute access mode) to run editor Python, plus search_symbols, get_symbol and grep_stubs to look up the Python API, and a read_me tool meant to be called once per conversation. Epic's rules for those scripts:

Our rule of thumb: if you keep asking the agent for the same script, turn it into a toolset with typed parameters and a READ or WRITE mode, so the client can show what it does before it runs.

Agent skills: workflow knowledge the agent loads on demand

Epic defines an agent skill as a named set of instructions, optionally tied to toolsets, that an agent loads when a task needs it. Epic's examples are placing actors so they rest on the ground and structuring a MetaSound. Put that kind of knowledge in a skill rather than in tool descriptions. Three ways to write one:

Markdown skill folderKey agents pass to AgentSkillToolset.GetSkills
<Plugin>/Skills/<folder> in every enabled plugin/Skills/<PluginName>/<folder>
<Project>/Skills/<folder>/Skills/Project/<folder>
Engine/Extras/AgentTools/Skills/Engine-supplied skills
Extra roots added from C++ with AddSearchRootPer root

Relative links in a SKILL.md are rewritten to absolute paths, so a skill can point the agent at pages and scripts stored next to it. A minimal project skill that goes with our NamingTools example (our wording, Epic's format):

<YourPlugin>/Skills/asset-naming/SKILL.md
---
name: asset-naming
description: This project's asset naming rules. Load before
  creating, duplicating or renaming any asset.
---
- Get every new asset name from NamingTools.suggest_asset_name.
- Never rename assets under /Game/ThirdParty.
- Ask before renaming anything referenced by a map.

For a jam team, a project /Skills/ folder in source control is a natural home for house rules, alongside the server instructions in Project Settings that every agent gets when it connects.

Tools in packaged games: AIRuntimeCallable

The 5.9 page says the MCP server isn't tied to the editor: cooked builds, Shipping included, can host it. You start it with IModelContextProtocolModule::StartServer() at startup or the -ModelContextProtocolStartServer argument. In the editor every AICallable tool is available, but cooked builds have no reflection metadata, so toolsets register from a manifest generated at build time that holds only tools tagged AIRuntimeCallable (which implies AICallable). Epic lists “a tool must run in a cooked build” as a reason to write it in C++. Engine toolsets with runtime-callable tools include NavMesh, Scene Capture, Console, Widget Finder, Perf (CSV and GPU profiler, Stats) and Input. Epic's warnings: cooked games aren't read-only, and the tag is the only thing that limits what a cooked game exposes, so tag tools carefully. If the log says Cannot register Toolset … no entry in baked manifest, the toolset has no AIRuntimeCallable tools. For playtesting setups that use this, see AI playtesting and QA.

Other 5.9 metadata on the C++ side: AIAccessMode = "Read", "Write" or "Execute" (the C++ form of the Python mode), AIIgnore to exclude a function and silence validation errors, and UsesInstanceDispatch() or UsesInstanceArgument() for tools that run on an object rather than statically. The 5.9 release notes also mention new Blueprint and Python scripting libraries for editing Blueprints, chooser tables, StateTrees and Dataflow graphs, so check them before you write a toolset for one of those.

Not hands-on: we haven't run the 5.9 Preview (no Unreal Editor on our Linux test machine), and Unreal MCP is Experimental, so names can change before 5.9 ships. Sources (read November 10, 2026): Epic's Using Python with AI Agents and Unreal MCP pages for UE 5.9, and the UE 5.9 Preview release notes (last updated November 9, 2026). The NamingTools layout and the SKILL.md example are ours.

How a toolset reaches your agent

Unreal MCP doesn't implement tools itself. Per Epic's docs, a toolset is a class that derives from UToolsetDefinition (unreal.ToolsetDefinition in Python) and exposes functions marked as tool calls. The Toolset Registry plugin collects those classes, Unreal MCP wraps each tool call as an MCP tool, and every connected client can use it. Epic adds that other AI features in the engine read the same registry, so a toolset you write for MCP works there unchanged.

Two details change how you test. First, tool search is on by default: tools/list only returns list_toolsets, describe_toolset and call_tool, and your tool is reached through call_tool with toolset_name, tool_name and an arguments object. Second, Epic's skill notes an agent often sees only a toolset's name and class docstring before deciding whether to open it, so that docstring has to stand on its own.

Python or C++?

Epic calls both first-class, and most toolsets that ship with the Toolset Registry plugin (SceneTools, ActorTools, MaterialInstanceTools, ObjectTools) are Python. Epic's skill says Python is generally preferred because it's faster to iterate. Epic's docs say to reach for C++ when:

To see what Python can reach, Epic's skill points to the generated stub at <project_root>/Intermediate/PythonStub/unreal.py (search it, don't read it whole). If it's missing, enable Developer Mode under Edit > Project Settings > Plugins > Python and restart. If the API you need isn't in either language, Epic's advice is to stop rather than work around it, because workarounds make tools that break silently.

Write the toolset

Epic's docs walk through the shipped ActorTools (in Engine/Plugins/Experimental/ToolsetRegistry/Content/Python/toolset_registry/toolsets/core/actor.py). The docs page shows its opening lines: import unreal, import toolset_registry, a helper import, then @unreal.uclass() on class ActorTools(unreal.ToolsetDefinition) with a docstring describing actors, transforms, labels, parent-child relationships and components. Open the full file in your engine install to read the tool methods.

Here's a small toolset in the same shape. It's ours, and deliberately pure Python, so it doesn't depend on any engine API we'd have to guess at. The prefixes are the ones Epic's own Unreal skill recognises (BP_, WBP_, M_, MI_, SM_, NS_ and others).

# Content/Python/naming_tools.py in your own plugin
import unreal
import toolset_registry

_PREFIX = {"blueprint": "BP_", "widget": "WBP_",
           "material": "M_", "material_instance": "MI_",
           "static_mesh": "SM_", "niagara": "NS_"}


@unreal.uclass()
class NamingTools(unreal.ToolsetDefinition):
    """Suggests asset names that follow this project's
    prefix convention (BP_, SM_, M_ and so on)."""

    @toolset_registry.tool_call
    @staticmethod
    def suggest_asset_name(base_name: str,
                           asset_type: str) -> str:
        """Returns a prefixed asset name.

        Args:
            base_name: Name without a prefix, e.g. "Door".
            asset_type: A key from list_asset_types.

        Returns:
            The prefixed name, e.g. "BP_Door".
        """
        if asset_type not in _PREFIX:
            raise ValueError(f"Unknown asset_type: {asset_type}")
        return _PREFIX[asset_type] + base_name

    @toolset_registry.tool_call
    @staticmethod
    def list_asset_types() -> list[str]:
        """Returns the asset types this toolset knows.

        Returns:
            Keys accepted by suggest_asset_name.
        """
        return sorted(_PREFIX)

What each part does, per Epic's docs and skill:

Keep the docstrings short. Epic's test for every line: could a competent reader infer it from the signature, names and types? If so, cut it. Keep units, ranges, odd encodings and what an empty result means.

Register it and load it

Epic's two sources describe this step differently, so it's worth checking rather than assuming:

Epic's Python scripting docs say the editor automatically runs any init_unreal.py it finds in a Content/Python folder, including each enabled plugin's. So a safe approach (ours) is to restart, check whether the class is registered, and only register it if it isn't. Both calls below are in Epic's Python API reference:

# Content/Python/init_unreal.py in the same plugin
import unreal
from naming_tools import NamingTools

reg = unreal.ToolsetRegistry
if not reg.is_toolset_class_registered(NamingTools):
    reg.register_toolset_class(NamingTools)

After any change:

Test it in four steps

Work from the inside out, so you know which layer broke. The order is ours; each step uses a documented tool.

1. In the editor's Python console

Epic's Python API has calls meant for exactly this: is_toolset_class_registered, and get_toolset_json_schema, which the reference says is "meant for use while testing". The schema shows whether your type hints and docstrings came through.

import unreal
from naming_tools import NamingTools

reg = unreal.ToolsetRegistry
print(reg.is_toolset_class_registered(NamingTools))
print(reg.get_toolset_json_schema(NamingTools))

unreal.ToolsetRegistry.execute_tool(toolset_name, tool_name, json_input) runs a registered tool "as if it was being executed by an AI assistant". It returns a ToolCallAsyncResultString: check is_complete, then error (empty means no error) or value (the result as a JSON string). Epic doesn't document the exact toolset-name format, so copy it from get_all_toolset_json_schemas() or from list_toolsets rather than guessing.

2. In the MCP Inspector

Epic calls the MCP Inspector the official debugging client for any MCP server: it lists every advertised tool with its schema and lets you call one through a form, with no agent reinterpreting your request. Per the Inspector docs it needs Node 22.19.0 or newer and runs through npx:

npx @modelcontextprotocol/inspector --cli \
  http://127.0.0.1:8000/mcp --transport http \
  --method tools/call --tool-name call_tool \
  --tool-args-json '{"toolset_name": "<from list_toolsets>",
    "tool_name": "suggest_asset_name",
    "arguments": {"base_name": "Door",
                  "asset_type": "blueprint"}}'

On failure the CLI exits non-zero and writes one JSON line to stderr with a stable code such as unreachable, tool_not_found or tool_is_error. Two more documented options worth knowing: --format json for clean output you can pipe to jq, and --strict on tools/list, which reports schema portability problems. With tool search on, tools/list only covers the meta-tools, so to lint your own tool's schema there, turn off Enable Tool Search in Editor Preferences while you test (Epic: it then advertises every tool up front).

3. Automated tests

Epic's skill says every tool needs a test for the success path and for each error path. Python tests extend ToolCallTestCase and use assertToolRaisesRuntimeError for errors, following Epic's example:

class NamingToolsTestCase(ToolCallTestCase):
    """Test NamingTools toolset."""

    def test_suggest_adds_prefix(self):
        """Adds the project prefix."""
        name = NamingTools.suggest_asset_name("Door", "blueprint")
        self.assertEqual(name, "BP_Door")

    def test_suggest_raises_on_unknown_type(self):
        """Raises for an asset type it doesn't know."""
        with self.assertToolRaisesRuntimeError():
            NamingTools.suggest_asset_name("Door", "banana")

Epic's skill doesn't show the import line for ToolCallTestCase; it says to read the existing tests in Plugins/Experimental/Toolsets and follow them. To run tests against a live editor through MCP, Epic lists AutomationTestToolset: call DiscoverTests first (skipping it gives empty results), then ListTests, RunTests, GetTestStatus and GetTestResults. After reloading Python tests, call DiscoverTests with force_rediscover=true. Without a running editor, Epic shows UnrealEditor-Cmd.exe <Project>.uproject -ExecCmds="Automation RunTests AI.MyToolset;quit" -Unattended -NullRHI (about 30 seconds of startup).

4. With your agent

Only now ask Claude Code, Cursor or Codex to use it, in plain language ("Suggest a name for a door Blueprint"). If the agent picks the wrong tool or passes odd arguments while the Inspector call worked, the fix is usually the docstrings, not the code.

Debugging: when the agent can't see or call your tool

SymptomWhat to check (from Epic's docs and skill)
Toolset missing from list_toolsetsIs the class registered (is_toolset_class_registered)? Is the plugin holding Content/Python/ enabled? Run ModelContextProtocol.RefreshTools, then reconnect the client.
Toolset is there, one tool isn'tOnly @toolset_registry.tool_call functions are advertised. Check the decorator, @staticmethod and that every parameter and the return value are annotated.
Agent uses an old signatureThe client is holding the old schema. Run RefreshTools and reconnect, as Epic advises after any hot reload.
Wrong argument or result shapeCompare get_toolset_json_schema with what the Inspector shows. Epic's ModelContextProtocol.WrapPODToolResultsInObject cvar (default true) wraps plain results such as a string in {"result": ...} for clients that expect objects.
Python error when the editor startsCheck the Output Log. For server-side detail, run Log LogModelContextProtocol Verbose.
Calls hangThe editor may be compiling, loading a level or in Play In Editor. Wait and retry. Tool calls run on the game thread.
Overlapping calls give odd resultsEpic's docs page says calls run serially and clients shouldn't overlap them; Epic's newer plugin notes say the server accepts concurrent requests but you should serialize dependent calls and anything touching the same asset. Either way, don't fire dependent calls in parallel.

Design rules Epic follows

Safety: your tool runs with the editor's full access

The server only accepts local connections and has no authentication, and Epic's plugin notes that localhost isn't a trust boundary: any process running as your user can connect. That includes your tools. Our advice: start with read-only tools, keep destructive ones narrow, never add a tool that runs arbitrary code you pass in (Epic already flags ProgrammaticToolset.execute_tool_script for this), and commit before an agent session. More in the limits and safety section of our setup guide.

When you outgrow Python: the C++ route in brief

Does this work in UEFN?

Epic's UEFN MCP page documents the built-in toolsets (Verse, Scene Graph entities, Creative devices, play sessions) and requires the Python Editor Scripting setting, but it doesn't say whether you can add your own toolsets. Treat this guide as Unreal Engine 5.8 only. If you're on the UEFN track, Epic's known issue that the Python toolsets use XYZ rather than UEFN's Left-Up-Forward coordinates applies to anything spatial. UEFN setup is in our setup guide.

Building toolsets before a jam: what the Epic AI MegaJam allowed

The 2026 Epic AI MegaJam ran November 12-15 and is a useful template for any jam that allows AI tools.

Rule 7(h) of the 2026 Epic AI MegaJam Official Rules lets entrants prepare "AI tools, agent configurations, Model Context Protocol (“MCP”) settings, prompt libraries, and scripts" before the contest period, and says Epic may ask for these materials or their version control history. Gameplay, levels and art must be made during the jam. Our reading for toolsets:

What Epic staff said once the jam started (November 12): toolsets and scripts you wrote before the jam are allowed, but content they generate on or after November 12 counts as created during the jam. Declare the toolset or script on your itch.io submission page, because Epic may ask for it or its version history (§7(h)). Staff described pre-jam “scripts” as tooling and pipeline work such as build and packaging automation; gameplay code, including generic menus, input and save systems, has to be written during the jam. These are forum replies, and the Official Rules stay binding. Details and sources: Epic staff answers on the MegaJam page. Submissions closed on Sunday, November 15 at 5:59 PM PST with 2,784 entries on itch.io, and Epic says winners will be notified on or about January 29, 2027; see what happens next.

Dates, prizes and the rest of the rules: Epic AI MegaJam 2026 guide.

What Epic hasn't documented

Unreal MCP is Experimental in UE 5.8, so check Epic's page for your engine version before relying on any of this.

Related: Unreal MCP and UEFN MCP setup · AI tools for Unreal Engine · Epic AI MegaJam 2026 · AI playtesting and QA · Claude Code vs Codex.

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

Sources (checked October 31, 2026): Epic's Unreal MCP in Unreal Editor (Authoring MCP Tools, Configuration Reference and Debugging sections), UEFN MCP and Scripting the Unreal Editor Using Python pages; the Unreal Python 5.8 (Experimental) API reference for unreal.ToolsetRegistry, unreal.ToolsetDefinition and unreal.ToolCallAsyncResultString; Epic's create-toolset skill and unreal-mcp operations reference in the Unreal Engine skills plugin for Claude Code; the MCP Inspector and Inspector CLI docs; and rule 7(h) of the 2026 Epic AI MegaJam Official Rules. The NamingTools example, the registration guard, the test order and the checklists are ours, built from Epic's documented pattern; they aren't Epic code. Unreal MCP is Experimental, so names and behaviour can change between engine versions. VibeStack Weekly isn't affiliated with Epic Games, Anthropic, Anysphere, OpenAI or the MCP project.

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

Our picks (3)

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

+ 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

What changes for custom Unreal MCP toolsets in UE 5.9?

Per Epic's UE 5.9 Preview docs: pass an access mode to the decorator (@toolset_registry.tool_call(mode=unreal.ToolAccessMode.READ, WRITE or EXECUTE); the default is Execute), register with a Registration object called from your plugin's init_unreal.py, and Python tools can be async. Tests register with register_test_runner, tool search has four meta-tools, agents can run editor Python through execute_python, and only AIRuntimeCallable tools work in cooked builds. We haven't tested the Preview.

How do I write an agent skill for Unreal MCP?

In UE 5.9, three ways: a Python class deriving from unreal.AgentSkill with the @agent_skill decorator (discovered automatically), a C++ UAgentSkill subclass, or a folder holding a SKILL.md file with name and description frontmatter followed by the instructions. Markdown skills are found under each enabled plugin's /Skills/ folder, the project's /Skills/ folder or Engine/Extras/AgentTools/Skills/, and agents load them by key through AgentSkillToolset.GetSkills.

How do I add a custom tool to Unreal MCP?

Write a Python class that inherits unreal.ToolsetDefinition, decorate it with @unreal.uclass(), and mark each tool as a @staticmethod with @toolset_registry.tool_call. Put the .py file under a plugin's Content/Python/ folder, make sure it's registered, run ModelContextProtocol.RefreshTools and reconnect your agent.

Should I write Unreal MCP tools in Python or C++?

Epic treats both as first-class, and most shipped toolsets are Python, which is faster to iterate. Use C++ when the engine feature isn't exposed to Python, the signature needs USTRUCT types Python hints can't express, or the tool is called so often that the Python-to-engine cost matters.

Where do Python toolset files go?

In a .py module under any plugin's Content/Python/ folder, one toolset class per file. Epic's shipped ActorTools sits in the Toolset Registry plugin's own Content/Python folder, so it's a good one to copy.

Why doesn't my agent see my new Unreal MCP tool?

Check the class is registered (ToolsetRegistry's is_toolset_class_registered call), the function has @toolset_registry.tool_call and @staticmethod, and every parameter and return value is annotated. Then run ModelContextProtocol.RefreshTools and reconnect the client, which can hold an old schema.

How do I test an Unreal MCP tool without an AI agent?

Call ToolsetRegistry's get_toolset_json_schema or execute_tool from the editor's Python console, then point the official MCP Inspector (npx @modelcontextprotocol/inspector) at http://127.0.0.1:8000/mcp over Streamable HTTP and call your tool through call_tool.

How do tool descriptions get to Claude Code or Cursor?

From your code. Type hints become the tool's JSON Schema, the class docstring becomes the toolset description, and Google-style function docstrings with Args and Returns become the tool and argument descriptions the agent reads.

Can I write custom MCP toolsets in UEFN?

Epic's UEFN MCP docs don't say. They cover the built-in Verse, Scene Graph, Creative device and play session toolsets and require Python Editor Scripting, but adding your own toolsets is only documented for Unreal Engine 5.8.

Could you build Unreal MCP toolsets before the Epic AI MegaJam?

Yes. Rule 7(h) let entrants prepare AI tools, MCP settings, prompt libraries and scripts before the contest period (November 12-15, 2026), and Epic may ask for them or their version control history. The same habits suit any jam that allows AI tools: keep toolsets generic and in git, and make gameplay, levels and art during the jam.

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.