Blueprint AI vs MCP

Two measured comparisons, both reproducible below:

vs Epic’s own UE 5.8 MCP plugin (the most direct comparison — first-party tooling, same engine): on an identical “create a Widget Blueprint” task run against a live UE 5.8.0 server in its default mode, Blueprint AI used ~1,500 tokens vs ~3,900–9,600 — ~2.6–6.4× fewer, single-domain. The gap widens with multi-domain work, and for Blueprint-graph authoring it’s categorical: Epic 5.8 ships no such toolset.
vs NeoStack AI v1.0 (the largest competitor that publishes its own number): a typical 5–10 op session runs ~9–14× lighter against their published 4,000 tok/op.

Beyond raw tokens, the CLI validates every op against Unreal’s own schemas before anything runs, so failures come back as real, typed, verified error messages — not a hallucinated success or a silent MCP no-op.

The architectural difference

The Model Context Protocol exposes a server’s tools to the AI. Historically, the assistant loaded the full list of tool names, parameter schemas, descriptions, and return shapes into the prompt at session start, then paid for every token of it on every turn. Recent MCP servers — including Epic’s UE 5.8 plugin — moved to progressive discovery: a small set of meta-tools loads upfront, and the model pulls additional toolsets on demand. That closed much of the original gap, but each loaded toolset still becomes resident from the next turn forward, and each ~80–150-token tool definition keeps billing on every turn it’s in scope.

Blueprint AI ships a single skill file — a short markdown document describing what the plugin can do, when to engage, and how to call the CLI. The skill loads once per session for a fixed ~0.4¢ at Sonnet rates. When the AI decides it needs an operation, it calls cli.py schema <op> on demand — only the schema for the specific op it’s about to run enters the conversation, never the catalog. The CLI handles validation locally, so failure messages come back as concise, typed diagnostics rather than blow-by-blow tool dialogue.

Versus Epic Games’ official UE 5.8 MCP plugin

Unreal Engine 5.8 ships an experimental Epic-built MCP plugin (Engine/Plugins/Experimental/ModelContextProtocol/). It exposes 144 AI-callable tools across 16 toolsets (Niagara, UMG, Physics, GAS, etc.) — but, verified from its source, it defaults to progressive discovery (ModelContextProtocol.DeferredToolLoading = true). In the default mode the initial tools/list returns just 3 meta-tools — list_toolsets, describe_toolset, load_toolset — and the model pulls a toolset’s schemas on demand. The full catalog (~19k tokens if every toolset is eagerly registered) is only reached by explicitly opting out of the default.

Measured, not estimated. We ran a live UE 5.8.0 MCP server (default deferred mode) and a spec-correct Streamable-HTTP client, task = create one Widget Blueprint (asset really created). Every payload tokenized with cl100k_base:

Step	Measured tokens
`tools/list` initial (3 meta-tools)	232
`tools/call list_toolsets`	723
`tools/call describe_toolset(UMG)` — optional inspection	5,735
`tools/call load_toolset(UMG)`	372
`tools/list` after load (16 tools resident)	2,539
`tools/call CreateWidgetBlueprint` result	19

Epic, single “create a widget blueprint” task:

Efficient path (list → load → use, skipping describe_toolset): ~3,885 tokens one-shot, then 2,539 tokens resident every subsequent turn (the loaded toolset catalog stays in context).
Inspect-first path (model calls describe_toolset before loading — the tool’s own description recommends this): ~9,620 tokens one-shot.

Blueprint AI, same task (measured via the real cli.py schema): the 1,398-token skill (resident/turn) + an 87-token create_widget_blueprint schema fetch + a ~19-token result ≈ ~1,504 tokens one-shot, 1,398 resident/turn.

Comparison (single-domain task)	Ratio
One-shot, Epic efficient path	~2.6× lighter (1,504 vs 3,885)
One-shot, Epic inspect-first path	~6.4× lighter (1,504 vs 9,620)
Steady-state resident per turn	~1.8× lighter (1,398 vs 2,539)

So against Epic’s official plugin the realistic gain is ~2–6× for a single-domain task — real, but not the larger multiples that hold against heavier published competitors. The gap widens with multi-domain work: Epic pays a fresh list_toolsets + load_toolset + a resident catalog per toolset, while Blueprint AI’s 1,398-token skill already covers all 1,121 ops and adds only ~87 tokens per op used. And for Blueprint-graph authoring it isn’t a ratio at all — Epic 5.8 ships no such toolset, so Blueprint AI does it and Epic’s MCP can’t.

Versus NeoStack AI v1.0

Betide Studio’s NeoStack AI changelog (v1.0.49) explicitly publishes a per-operation token cost — the only Unreal AI plugin we found that did:

“In v0.5.x, even a simple operation like adding a variable to a Blueprint could consume 40,000–50,000 tokens. In v1.0, the same operation takes roughly 4,000 tokens. That’s a 10x reduction.”

That’s NeoStack’s own number, after their own 10x optimization. Priced at Claude Sonnet rates ($3/MTok input), 4,000 tokens/op is $0.012 per op. Against that:

Session size	NeoStack v1.0 cost	Blueprint AI cost (1,398 skill + ~150/op)	Blueprint AI is
1 op	$0.012	$0.0046	2.6x cheaper
5 ops	$0.060	$0.0064	9.3x cheaper
10 ops	$0.120	$0.0087	13.8x cheaper
20 ops	$0.240	$0.013	18.2x cheaper

A typical “build me a BP_Pickup” session lands in the 5–10 op range — that’s where the 9–14x cost advantage materialises. For an everyday user running ~50 sessions/month, NeoStack’s plugin overhead is ~$6/month on top of the actual chat; Blueprint AI’s is under $0.50. Roughly $5/month back on your Claude bill at typical usage — and for power users running 4-5 sessions a day, the gap stretches to $20+/month.

Versus the rest of the Unreal MCP landscape

NeoStack is the only Unreal-AI competitor with a publicly-cited per-op cost number. The others — Ultimate Engine CoPilot, UnrealAI.studio, NWIRO, BAIB, StraySpark, VibeUE — market efficiency vaguely (“token-optimised”, “low cost”) without publishing the math. For those, the architectural-math estimate is ~86 tokens per tool definition (measured by serializing Blueprint AI’s own 1,121 ops as minified MCP tools), priced at Sonnet rates:

Plugin	Tools (claimed)	Implied upfront cost per turn	Blueprint AI is
UnrealAI.studio	9,000+	~$2.32 if loaded upfront	likely uses progressive discovery — see caveat
Ultimate Engine CoPilot	1,050+	~$0.27	likely uses progressive discovery — see caveat
NWIRO Integration Kit	209	~5.4¢	~12.9x cheaper
StraySpark Unreal MCP	207	~5.3¢	~12.7x cheaper
VibeUE	10 (orchestrator)	~0.3¢	not scope-comparable

What still holds against any MCP architecture, progressive or not:

Skill density. 1,398 tokens of markdown describes 1,121 operations plus the workflow, CLI surface, and rules. JSON tool schemas can’t pack that density per token even with progressive disclosure — the schema overhead per tool stays around 80–150 tokens regardless of when it loads, and you pay for it every turn the tool is in scope.
Verified failures, not silent successes. A typed error from cli.py validate is one short message that names the operation, inputs, and failure mode. MCP’s tool-call dialogue eats more tokens — and more cents — per failure, and a server that doesn’t validate against the engine’s own schemas can return a “success” the model trusts when nothing actually changed.
No structural overhead in the wire format. No tools[] array wrapper, no per-call JSON-schema re-serialization, no MCP framing — the CLI’s input is JSON ops directly.

A concrete example

Create BP_Pickup as an Actor in /Game/Pickups. Add a StaticMeshComponent as root and a SphereComponent for overlap. On BeginPlay, print “Pickup ready”.

That’s roughly four operations (create blueprint, add ×2 components, wire event). Using NeoStack’s own published 4k/op, priced at Sonnet:

Stage	NeoStack AI v1.0	Blueprint AI
Session preamble	(folded into per-op cost)	1,398 tok / $0.0042
4 operations	4 × 4,000 = 16,000 tok / $0.048	4 × ~150 = 600 tok / $0.0018
Validation feedback	(folded in)	4 × ~50 = 200 tok / $0.0006
Total	~16,000 tok / ~$0.048	~2,200 tok / ~$0.0066

About 7.3x cheaper for that specific example. The ratio grows with session length because Blueprint AI’s skill cost is paid once, not per op.

When MCP is the right choice

Three cases where MCP wins on something other than cost:

You already run an MCP-rich workflow and want one protocol across every tool. Blueprint AI is not an MCP server; adopting it means running two integrations.
Your AI client can’t shell out. MCP standardizes the transport. The CLI assumes the assistant can exec a Python process — most can, but if yours can’t, MCP is the workaround.
You need stateful resources, not stateless ops. MCP servers can hold persistent state (open connections, cached lookups). Blueprint AI is stateless — every apply is fresh. For long-lived debugging sessions against a live process, that’s a real trade.

For Unreal asset authoring — the workflow Blueprint AI is built around — the cheaper shape wins.

Reproduce the measurements

The Blueprint AI side, from the project root:

import sys; sys.path.insert(0, 'Plugins/BlueprintAI/Scripts')
import ops
from ops.registry import REGISTRY
import json, tiktoken

# Claude Sonnet 4.6 input pricing (USD per token).
PRICE_PER_TOK = 3 / 1_000_000

enc = tiktoken.get_encoding('cl100k_base')

def to_mcp(name, op):
    props = {
        pn: {'type': p.type, **({'description': p.desc} if p.desc else {})}
        for pn, p in op.params.items()
    }
    req = [pn for pn, p in op.params.items() if p.required]
    return {
        'name': name,
        'description': op.description,
        'inputSchema': {'type': 'object', 'properties': props, 'required': req},
    }

tools = [to_mcp(n, o) for n, o in REGISTRY.items()]
mcp = len(enc.encode(json.dumps(tools, separators=(',', ':'))))
skill = len(enc.encode(open('Plugins/BlueprintAI/Skills/unreal/SKILL.md').read()))
print(f'Ops: {len(tools)}  Skill: {skill} tok (${skill * PRICE_PER_TOK:.4f})')
print(f'MCP-equivalent: {mcp} tok (${mcp * PRICE_PER_TOK:.4f})  Ratio: {mcp/skill:.1f}x')

Requires pip install tiktoken. The snippet derives every Blueprint AI number on this page from the live registry — when new operations land, the ratio recomputes automatically.

The Epic UE 5.8 side requires a live MCP server. Create a throwaway Blueprint-only UE 5.8 project, enable ModelContextProtocol, ToolsetRegistry, and UMGToolSet, and set bAutoStartServer=True in Config/DefaultEditorPerProjectUserSettings.ini. Then run a spec-correct Streamable-HTTP client (persistent SSE read, fresh connection per request, send Mcp-Session-Id and Mcp-Protocol-Version headers, close after the result — a naive client trips HttpConnection.cpp:184). Issue the full flow: initialize → tools/list → tools/call list_toolsets → optional describe_toolset(UMG) → load_toolset(UMG) → tools/list → tools/call UMGToolSet.UMGToolSet.CreateWidgetBlueprint, tokenizing every response with cl100k_base. The numbers in the table above are the exact byte payloads observed against UE 5.8.0 CL 53629095.