unreal-lazy-mcp
# unreal-lazy-mcp
**Put it in front of Unreal Engine 5.8's built-in MCP server: about half the
tokens, and almost no failed tool calls.** The official server is not replaced
or modified; your agent searches its 832 editor tools instead of guessing names.
| Same 18 tasks, Claude Code + Sonnet 5.5 | Official server | With unreal-lazy-mcp |
| --- | --- | --- |
| Failed tool calls | 39 | **0** |
| Tokens | 7.98 M | **3.56 M (-55%)** |
| Cost reported by Claude Code | $5.17 | **$1.95** |
The same work cost about 38% as much - roughly 2.5x more tasks for the same spend.
With Haiku 5.5: failed calls 64 -> 1, tokens -38%.
Non-English requests work too: the same six tasks in Korean (Haiku 5.5) - failed calls 68 -> 1, tokens -50%.
## Before and after
From the benchmark logs (task B06: create a material, wire a constant to Metallic, save it).
Official server - the agent guesses a name:
```text
call_tool(AssetTools, "save_asset") -> Unknown tool save_asset
```
With the wrapper - the agent searches first:
```text
find_tools("save asset") -> 1. AssetTools.save_assets "Saves assets to disk."
invoke(AssetTools, "save_assets", {...}) -> true
```
A guessed name still gets a pointer: `get_tool_details(AssetTools, "save_asset")`
returns `found: false` with `save_assets` as the first suggestion.
## Quick start
You need Unreal Engine 5.8 (5.9 is not supported yet) and [uv](https://docs.astral.sh/uv/).
1. In the editor, enable the **Unreal MCP** and **All Toolsets** plugins (Edit > Plugins)
and start the MCP server: turn on **Auto Start Server** under Editor Preferences >
Model Context Protocol, or launch the editor with `-ModelContextProtocolStartServer`.
Leave **Enable Tool Search** on (the default).
2. Add the wrapper to your MCP client. Most clients use this format:
```json
{
"mcpServers": {
"unreal-lazy": {
"command": "uvx",
"args": ["--from", "git+https://github.com/abc11010xyz/unreal-lazy-mcp", "unreal-lazy-mcp"]
}
}
}
```
Claude Code, in one command:
```bash
claude mcp add unreal-lazy -- uvx --from git+https://github.com/abc11010xyz/unreal-lazy-mcp unreal-lazy-mcp
```
Run it in your Unreal project folder (it registers the server for that folder),
or add `--scope user` to use it everywhere. Or as a plugin:
`claude plugin marketplace add abc11010xyz/unreal-lazy-mcp`, then
`claude plugin install unreal-lazy-mcp@unreal-lazy-mcp`.
Other clients (VS Code, Codex, Cursor, Claude Desktop), offline use and
troubleshooting: [configuration](docs/configuration.md#client-configuration).
Do not also register the editor's own `unreal-mcp` entry (the one *Generate
Client Config* writes into your project folder, such as `.mcp.json`) or Epic's
`unreal-mcp-proxy`: the agent could then call the official server directly and
skip both the search and the delete confirmation.
3. Ask for something in the editor. The first tool call reads the editor's tool
list once (about 20 seconds); there is nothing else to set up.
Deleting assets or actors and switching levels ask you first; everything else
runs without asking. The confirmation needs a client that supports MCP
elicitation (Claude Code does); elsewhere those calls are refused. The numbers
above were measured with Claude Code; other clients work the same way but were
not measured. Settings, install without uv, removal: [configuration](docs/configuration.md).
## More
- [Benchmark: method and full results](docs/benchmark.md) - both models, every task, wall time, what the numbers do not show
- [Limitations](docs/limitations.md)
Unofficial; not affiliated with Epic Games. MIT license.
TDQS
Scored across 4 tools
The four tools occupy distinct roles: discovery (find_tools), browsing (list_toolsets), schema inspection (get_tool_details), and execution (invoke). The only overlap is between find_tools and list_toolsets, but the descriptions explicitly steer users toward find_tools, keeping boundaries clear.
Three of four tools follow a clean verb_noun pattern (get_tool_details, list_toolsets, find_tools). The bare verb 'invoke' is a minor but understandable deviation for the terminal execution step.
Four tools is a lean but well-scoped gateway pattern where each tool earns its place (discover, browse, inspect, execute). It is slightly on the minimal side but not thin given the proxy role.
The surface covers the full discovery-to-execution lifecycle for a proxied toolset, including schema inspection before invocation. Minor gaps exist (no bulk tool listing within a toolset, no batch invoke), but agents can work around them via find_tools and repeated invoke calls.