BB Buckley Builds

Extending Unreal Engine MCP: Toolsets, AI Callable Methods, and Skills

Published 7/8/2026
unreal-enginemcpai-toolstoolsetsagent-skills

Unreal Engine 5.8’s native MCP support gives AI agents a live connection into the editor. That sounds abstract until you separate the system into a few simple pieces:

  • Toolsets group editor capabilities.
  • AI Callable methods are the individual actions inside a toolset.
  • Agent Skills teach the agent how to use tools.
  • Direct MCP tools are for custom protocol-level behavior.

Once you see those layers, Unreal MCP becomes much easier to reason about. You can inspect what Epic already ships, decide what should be a normal toolset, decide what should be a skill, and avoid building custom protocol tools unless you really need them.

Start With The Out-Of-The-Box Tools

Before adding anything custom, look at what Unreal MCP already provides.

Unreal’s built-in MCP tools are discovered through the Toolset Registry. With tool search enabled, an MCP client usually does not receive every tool schema up front. Instead it sees a small set of meta-tools:

  • list_toolsets shows available toolsets.
  • describe_toolset shows the tools and schemas inside one toolset.
  • call_tool executes a specific tool.

That discovery flow matters. It keeps the tool list smaller and lets the agent load details only when it needs them.

The simple mental model:

Unreal MCP discovers tools from the Toolset Registry, then agents call them through the MCP endpoint.

Built-In UE 5.8 Engine Toolsets

UE 5.8 ships a set of engine toolsets with AI Callable methods. Availability depends on which experimental toolset plugins are enabled in the project, so always confirm with tool discovery.

Built-in engine toolsets with AI Callable methods include:

  • Editor Toolset
  • UMG ToolSet
  • Niagara Toolsets
  • MVVM Toolset
  • Gameplay Tags Toolset
  • GAS Toolsets
  • Physics Toolsets
  • PCG Toolset
  • Chaos Cloth Asset Toolset
  • Data Registry Toolset
  • Config Settings Toolset
  • Game Features Toolset
  • Plugin Toolset
  • Semantic Search Toolset
  • Automation Test Toolset
  • Slate Inspector Toolset
  • World Conditions Toolset
  • Dataflow Agent
  • Live Coding Toolset

These cover a lot of everyday editor work: actors, objects, material instances, widgets, screenshots, PIE control, logs, automation tests, data registries, config settings, plugins, and more.

If you are teaching someone Unreal MCP, this should be the first lesson: do not start by writing a new tool. Start by discovering what is already there.

Toolsets Are The Container

Toolsets are small APIs for an editor domain. Think of them as a coherent group of capabilities:

  • actor tools
  • asset tools
  • material tools
  • widget tools
  • automation test tools
  • project settings tools

The two most important phrases to look for are:

  • UToolsetDefinition
  • ToolsetRegistry

In C++, a toolset derives from UToolsetDefinition. In Python, it derives from unreal.ToolsetDefinition. The Toolset Registry discovers those toolsets and makes their callable methods available to MCP.

The teaching phrase:

Toolsets are the container for MCP-visible editor capabilities.

AI Callable Methods Are The Actions

Inside a toolset, the actual actions are the AI Callable methods.

These are focused operations like:

  • get selected actors
  • set a material parameter
  • create a widget
  • start PIE
  • run a test
  • read logs
  • capture a screenshot

The two most important phrases to look for are:

  • AICallable
  • tool_call

In C++, the important marker is usually AICallable. In Python toolsets, the important marker is usually tool_call.

The teaching phrase:

Toolsets are the container; AI Callable methods are the actions.

Agent Skills Are Instructions, Not Actions

Skills are separate from normal editor actions. They are instruction bundles that teach the agent how to use tools correctly.

A good skill explains:

  • when to use a toolset
  • the correct workflow
  • common mistakes
  • safety rules
  • verification steps
  • small examples

The two most important phrases to look for are:

  • AgentSkill
  • AgentSkillToolset

Skills should usually be assets or asset-backed data. A simple skill needs a stable id, a short description, and instructions. You can also load skill content with Python, for example by reading markdown or skill assets at startup and registering them with Unreal’s Agent Skill system.

The teaching phrase:

Skills teach the agent how to use tools; they do not do the work themselves.

What Skill Content Looks Like

A good skill is short and practical. It should feel like a checklist with warnings, not a giant manual.

An actor editing skill might say:

  • Use when the user asks about selected actors, transforms, labels, or attachments.
  • Prefer actor and scene tools.
  • Inspect selection first.
  • Apply one focused edit.
  • Verify by reading actor state again.

A Material Instance skill might say:

  • Use when changing Material Instance parameters.
  • Resolve the asset path.
  • Inspect available parameters.
  • Confirm the exact parameter name.
  • Save and verify the new value.

A PIE testing skill might say:

  • Use when validating runtime behavior.
  • Save needed assets.
  • Start PIE and run the focused check.
  • Read logs or test results.
  • Stop PIE when finished.

That is enough to change the agent’s behavior without stuffing the context window.

Direct MCP Tools Are The Advanced Path

Most editor work should be modeled as toolsets and AI Callable methods. Direct MCP tools are for cases where the Toolset Registry model does not fit.

Good reasons to use a direct MCP tool include:

  • dynamic schemas
  • code execution
  • custom result types
  • web or data proxy tools
  • image handling
  • special discovery tools

The two most important phrases to look for are:

  • IModelContextProtocolTool
  • AddTool

The teaching phrase:

IModelContextProtocolTool is the advanced path. For normal editor actions, prefer toolsets and AI Callable methods.

Useful Unreal MCP Console Commands

These are the built-in console commands worth knowing:

  • ModelContextProtocol.StartServer starts the MCP server.
  • ModelContextProtocol.StopServer stops the MCP server.
  • ModelContextProtocol.RefreshTools re-polls registered tool providers.
  • ModelContextProtocol.GenerateClientConfig ClaudeCode writes MCP config for Claude Code.
  • ModelContextProtocol.GenerateClientConfig Cursor writes MCP config for Cursor.
  • ModelContextProtocol.GenerateClientConfig VSCode writes MCP config for VS Code.
  • ModelContextProtocol.GenerateClientConfig Gemini writes MCP config for Gemini.
  • ModelContextProtocol.GenerateClientConfig Codex writes MCP config for Codex.
  • ModelContextProtocol.GenerateClientConfig All writes config for all supported clients.

GenerateClientConfig writes MCP connection config, such as .mcp.json. Epic’s public Unreal MCP docs do not describe a built-in command for generating agent instruction files like CLAUDE.md, AGENTS.md, or .github/copilot-instructions.md.

The Practical Order

When extending Unreal MCP, use this order:

  1. Discover the out-of-the-box toolsets.
  2. Use existing AI Callable methods where possible.
  3. Add a new toolset when a domain is missing.
  4. Add Agent Skills to teach workflows and guardrails.
  5. Add direct MCP tools only for custom protocol behavior.

That order keeps the system understandable. It also keeps you from turning every problem into a custom MCP server problem.

Start with toolsets. Expose actions with AI Callable methods. Teach workflows with Agent Skills. Reach for IModelContextProtocolTool only when you really need custom MCP behavior.

Sources