A codebase that compiles itself.

Full programmatic control over every Blueprint in your project: build whole node graphs from a JSON spec, rewire nodes in bulk, manage variables, components, functions, interfaces and CDO properties — and thanks to a Sugiyama auto-layout engine, AI-generated graphs actually look like a human made them. DataTables, structs, enums, timelines and Level Blueprints are all covered too.

Hallucinated engine calls die before they reach the compiler. Your AI batch-verifies every symbol it is about to use — does this class exist, does this method exist on it, what is the exact overload signature, is it deprecated and what replaced it — then asks for the canonical #include (and gets warned when the header is private). It pulls real call sites from the engine to copy the idiom from, works out which modules the file needs in Build.cs, and lints a header it just wrote for the UnrealHeaderTool gotchas that cost a full build cycle: missing GENERATED_BODY(), generated.h not last, a missing module API macro, an invalid specifier. When a build does fail, the compiler errors come back with the fix attached — which module is missing from your Build.cs, what the deprecation message actually said. Behind it all, the engine index now resolves 960,000+ symbols including every member variable, so the workhorse types — FScopeLock, FPaths, FSceneView, FCollisionShape — answer properly instead of coming back empty. And all of it answers with the editor closed.

Knows when a change needs a full UnrealBuildTool run and when Live Coding can hot-patch it in seconds instead. Your AI triggers the build, reads the compiler output, and keeps iterating until it links — you never have to touch the editor.

Searches and tails editor logs, pauses and steps Play-In-Editor, drives the viewport camera, and runs the package / cook / lighting / navmesh pipelines. And when the editor goes down, a fatal-error hook has already written a full crash dump — stack trace, error, recent log — that your AI reads over MCP while the crash dialog is still on screen, so it can diagnose the cause, fix it and restart the editor on its own. The report leads with the verdict — is this crash actually fresh, where did it come from, which module is on top — instead of making your AI wade through eight kilobytes of stack to find out, and a compact mode trims a 400-frame dump to under two.

Proves a feature actually works by reading typed runtime state — a UPROPERTY, a GAS attribute, an AI blackboard key, an animation variable, a UMG label's live text and on-screen geometry — instead of screenshotting the viewport and eyeballing it. One Play-In-Editor session batches a whole set of declarative assertions (did the ability apply, did the enemy aggro within two seconds, did the HUD show the right number), advances the real frame loop sampling each tick, and returns a deterministic pass/fail with the exact violating sample. It can even drive the pawn mid-session to trigger the behavior first. Before any of that, a map can be pre-flighted in milliseconds without starting PIE at all — does it compile clean, are there Blueprint errors, is the navmesh built, is there a player start — so you stop losing runs to a "bug" that was really an unbuilt navmesh. And the session itself now runs unthrottled: on a Mac that took sampling from roughly 3 frames a second to 74, which is the difference between a verification pass and a rumour. A typo'd path fails loudly instead of silently vanishing — and pixels stay reserved for the genuinely visual questions: lighting, materials, VFX.

Audits configs across the full INI resolution chain, pulls material shader stats, analyses draw calls and recommends tuning — so a performance pass turns into a conversation instead of a week of spelunking through configs.

SQLite FTS5 full-text search across every indexed asset in your project — marketplace and Fab content included. Find assets by name, type, path or content, trace references between them, and search gameplay tags, so nothing gets lost in a folder tree again. The index updates live as assets change.

Runs your team's Editor Utility Blueprints, Widgets and Tasks headlessly from MCP — run-once utilities, docked tool panels, long-running background editor jobs — your AI can start them, watch them, and cancel them if they go sideways.

One passthrough action to run Python straight in the editor's environment — for that one corner of the API nobody's wrapped yet. The typed surface ends somewhere; the work doesn't have to.

When your AI hits the one thing the built-in actions don't cover, it doesn't ask you to go write a plugin. It writes a Python function, decorates it, and registers it as a live MCP tool — named, schema-validated and discoverable exactly like a built-in, in the same session. No rebuild, no editor restart. New tools persist into the project by default — reloaded every launch, and the rest of the team gets them too — or stay session-only if that's all you wanted. Off by default: turning it on grants the same arbitrary-Python trust as the Python escape hatch, so it's yours to opt into.

Read-only MCP resources for the editor: project info, current level, selection, viewport, log tail, performance stats, plugins and modules. Your AI gets its bearings in seconds instead of burning context poking around. They stay available even when the editor isn't running — start your AI client first, launch Unreal after, and the client picks the editor up on its own rather than sitting there convinced the tools don't exist. Closing and reopening the editor mid-session is a non-event too, and a long Live Coding patch or shader batch no longer looks like a disconnect.

Reusable workflow templates for the jobs you do over and over — build a level, review a Blueprint, debug performance, scaffold a Niagara effect or a GAS ability — exposed as MCP prompts your client can fire off like slash commands.