Unreal MCP Discipline
Making AI agents a little more careful inside Unreal Engine.
I've been experimenting with AI agents working directly inside Unreal Engine through MCP. They're useful for repetitive tasks, building Blueprint logic, and getting things moving without doing everything manually.
But I kept running into one problem.
The agent would finish a task, the Blueprint would compile, and I'd still spend time figuring out what it had done.
Sometimes there were more nodes than necessary. Sometimes logic already existed somewhere else in the project. And sometimes the agent would make additional changes that I hadn't asked for.
I wanted to keep using these tools without giving up control over my own project.
That's where Unreal MCP Discipline came from.
What is it?
It's a Claude Skill written entirely in Markdown.
No plugin to install inside Unreal. No additional scripts or dependencies.
It gives the agent a set of rules to follow when working with Blueprints through MCP.
The idea is simple: before creating something new, understand what's already there.
How it works
Before making changes, the agent checks whether its available tools can handle the task.
It then reads the relevant Blueprint, its functions, variables, parent class, and any existing function libraries.
If the logic already exists, it should reuse it instead of creating another version.
Before the first write, it also:
- Creates timestamped backups of the assets it will modify.
- Explains what it plans to change.
- Estimates how many Blueprint nodes the work should need.
- Identifies anything it cannot do with the available tools.
During implementation, it works in small batches, compiles each completed unit, and avoids unnecessary nodes or duplicated logic.
I've also set limits around graph size and repeated blocks. They're there to encourage simpler Blueprints, not to force every graph into an arbitrary node count.
The part I care about most
Finding a problem doesn't mean the agent gets to fix it.
This became an important rule as I continued updating the skill.
If I ask an agent to work on one function, I don't want it quietly refactoring three others because it found a better approach.
It can point out problems. It can suggest alternatives. It can explain why something should be changed.
But changes outside the requested work need my approval.
The same applies when auditing existing Blueprints.
The agent can inspect a graph, count nodes, identify repeated logic, and propose a refactor. It doesn't rewrite the graph just because it found something inefficient.
I still want to make those decisions myself.
Keeping track of changes
Another thing I wanted was a proper record of what happened.
At the end of a task, the agent reports which assets it touched, what it reused, the node counts, and whether everything compiled.
It also records what it deliberately left out.
Changes are documented in Content/Docs/agent-log.md, while blueprint-map.md keeps track of what each Blueprint does and what triggers it.
That way, the information stays with the project instead of disappearing into an old chat.
Where it stands
I'm still refining the skill as I use it.
It's built around the official Unreal MCP workflow in UE 5.8, and it's not a guarantee that an agent will always make the right decision. The results still depend on the available tools and how well the agent follows the instructions.
What it gives me is a more predictable way of working, with fewer unexpected edits and less time spent understanding generated logic.
I enjoy experimenting with AI tools, but I also like knowing exactly what's happening inside my projects.
This is my attempt to keep both.
Free, open source, MIT licensed.