CodeFizz Editor Agent: drive the Unreal Editor from Claude, Cursor, or any MCP client (615 commands, UE 5.6 to 5.8)

Development Programming & Scripting Blueprint
, , , , , , ,
1

I have been building CodeFizz Editor Agent, a plugin that lets an AI assistant work directly inside the Unreal Editor. It is not a chat window that writes code for you to paste in. The agent calls real editor commands, so it creates the asset in your project, and it can read back what happened and correct itself when something does not compile.

It works with Claude Code, Cursor, VS Code, Gemini, and any MCP client.

Codefizz
Codefizz1536×1024 1.63 MB

I have been building CodeFizz Editor Agent, a plugin that lets an AI assistant work directly inside the Unreal Editor. It is not a chat window that writes code for you to paste in. The agent calls real editor commands, so it creates the asset in your project, and it can read back what happened and correct itself when something does not compile.

It works with Claude Code, Cursor, VS Code, Gemini, and any MCP client.

What it can reach

Right now it is 900+ commands across 28 categories, all editor side. Some of what is in there:

  • Niagara: systems, emitters, modules, renderers, scratch pad HLSL, user parameters
  • Control Rig: bone and control hierarchies, RigVM solve graphs, physics, module rigs
  • PCG: graphs, nodes, edges, runtime generation, subgraphs
  • Procedural Vegetation: grow trees and plants from a node graph, then export them to mesh assets (5.8)
  • Mutable: customizable objects, modular character graphs, swappable garments, runtime instances (5.8)
  • Sequencer: sequences, bindings, tracks, keyframes, cameras, and rendering out through the Movie Render Queue
  • Materials: graphs, material functions, instances, layers, parameter collections, Custom HLSL
  • Audio: MetaSounds, Sound Cues, submixes, effect chains
  • AI: Behavior Trees, Blackboards, and EQS environment queries, including runtime inspection during play
  • Blueprints: variables, functions, event graphs, components, graph nodes, class defaults, compile
  • UMG: the full widget tree, slots, bindings, animations, MVVM viewmodels
  • StateTree, Enhanced Input, Level Actors, Curves, Data Tables, Project Settings, and Insights profiling

That is not the whole list and I can’t paste 900 lines here. The full catalog is searchable at Tools | CodeFizz Editor Agent

How it works

Everything runs through a free command line tool called cfa. The same binary is also an MCP server, so your AI tool can talk to it either way.

irm https://codefizz.dev/install.ps1 | iex
cfa login
cfa install-plugin "E:/Unreal/UE_5.8"
cfa skill install
cfa health_check

The cfa skill install step is the one that matters more than people expect. It installs a reference that teaches the AI how the commands actually behave, the conventions to follow, and the traps to avoid. Without it the model guesses at parameters. With it, it looks things up first and gets it right far more often.

The plugin is under 4 MB and runs entirely on the editor side. Nothing ships in your packaged game.

Versions

UE 5.6, 5.7 and 5.8, Windows 64 bit. Every release is built and tested against all three before it goes out.

Worth saying plainly since people ask: Epic ships its own MCP server in 5.8 now, marked Experimental. If you are on 5.8 and only need the basics, try that first. This covers 5.6 and 5.7 as well, and goes considerably deeper into the subsystems listed above.

Where to look

I will drop some clips of actual runs in the replies below rather than stacking them all in the first post.

Happy to answer anything here. If there is a part of the editor you want reachable that is not in the list yet, say so and I will look at it. Most of what exists now came from exactly that kind of request.

2

Materials and shaders, built by typing what you want

This was the first one I recorded, and it is three separate runs in one video.

First, an iridescent holographic material from a single prompt, written as custom HLSL. Then the same look again from scratch, but with a rule: raw Unreal nodes only, no HLSL anywhere. Two very different graphs, same result on screen.

The third run is the one I actually care about. There is a visual bug in the material, so I take a screenshot and hand it to the agent. It looks at the image, works out what is wrong, researches it, and fixes the material itself. That loop of “look at the result, correct the asset” is the whole reason I kept building this.

3

A full UE5 menu UI with zero images, materials only

One hard rule for this run: no images at all. No textures, no imported PNGs. Every button, panel, label and the background had to be made out of materials.

It starts with the background material, then the Common Button and Common Text setup added straight from the command line. From there I keep pushing the background with prompts, from a fractal fluid look into an actual fluid simulation, plus an abstract shape that keeps shifting and changing colour.

The last part of the video is me walking through what it actually built: the materials, a per state material instance for every button, the panels, the styles, and how the whole thing wires into the main menu.

4

A fully procedural forest with PCG, from a prompt

I described the forest I wanted (big rocks, small rocks, trees, foliage) and pointed the agent at a marketplace asset pack. It read the meshes out of that pack by name, decided where each one should go, and generated the whole PCG graph itself.

Then I dropped the graph in the level and scaled the PCG bounds up to cover the landscape.

The first result was honestly not great. Too many big rocks, no grass anywhere. So I re-prompted it to cut the rocks down and spawn grass around them, and it rebuilt the graph. Second pass looks far cleaner with full grass coverage. I left that part in because that is what using it actually looks like.

5

A whole solar system in Niagara, no nodes wired by hand

One prompt, and it authors the entire Niagara system: the planets, their orbits, the sun, the asteroid belt.

It builds the custom materials for each planet and the sun first. When it hits an error, it asks Unreal what went wrong and fixes it, without me stepping in. Then it places the effect in the world, takes screenshots, looks at what is right and what is not, and keeps making its own calls from there. I only stopped it once, to point it at the material overrides step.

The part worth watching is the end. Everything is exposed as user parameters: asteroid belt radius and count, orbit tint colours, planet colours and sizes, sun glow intensity, overall system scale. All of it updates live and can be driven from gameplay at runtime, so it is not a one shot asset you throw away.

6

A level prototype from one prompt and a reference image

I gave it one prompt and a reference image, and it blocked out the whole level. It plans the layout first, before it builds anything, then creates the materials, lays out the blockout geometry, and arranges the pieces into place. Errors along the way it checks and fixes itself.

What comes out is a prototype level for wall running that you can walk through straight away, instead of greyboxing the whole thing by hand.

Worth being clear about the limits: this run uses plain cube blockout meshes. If you point it at your own ready made static meshes in the prompt, it arranges those into the level instead.

7

A stylized ocean water material, written from scratch in about twelve minutes

No water plugin, no starter content, no nodes placed by hand.

I asked for stylized water with full control over waves and foam. It reads its own material reference first to confirm the conventions, then does every asset operation through the command line. It writes Gerstner waves summed across several octaves inside one Custom HLSL node, each layer with its own wavelength, amplitude, steepness and direction, and derives the normals analytically rather than sampling a normal map.

It does not compile the first time. It reads the error back out of Unreal and fixes it itself, finishing at zero errors and 2005 pixel instructions, then clears the orphaned nodes and wires refraction distortion into the depth sampling.

Four assets come out: the water material, a Gerstner waves function, a foam function, and a material instance. Shoreline foam blends properly because it is driven by scene depth against pixel depth. From the instance I can change shallow and deep colour, subsurface scatter, foam colour and coverage, wind direction, wave scale, amplitude and choppiness, without ever opening the graph.

That is the bit that matters to me. A hand written water shader is usually a day of work for a tech artist. This was a prompt, a self correcting build, and a parameter pass.

8

Full Control Rig on a clothed character. No manual node work, no controls placed by hand.

Full run: https://youtu.be/g4JeJNZf3iM

I told it what I wanted: a root and a centre of gravity control, FK down the spine, IK on both arms and both legs, and physics on the hair, the breasts and the butt. The long braid and the front and side bangs each get their own chain. Colliders sized off her real mesh so the hair slides over her shoulders and back instead of sinking into them.

It reads the skeleton and derives every chain from the geometry rather than the bone names, which matters here because the arms and the legs run on opposite axes on this rig. It also found the mesh already had an artist authored physics asset and read those capsules instead of authoring its own.

It checks its own work. It simulates the rig, reads the values back, and tests whether anything is jittering, sitting stuck, or never settling. Its first pole placement came out on the wrong side of the midline, so it discarded that and placed them again against the real protrusion. Its own gate then reported that a few of the controls had not actually been checked, so it went back for them. Finished at zero errors across 194 nodes and 21 graphs.

Hair stiffness, damping and gravity, flesh stiffness and damping, and one overall jiggle intensity float are exposed as rig variables, so the physics tunes without opening the graph, and that float can be driven from an animation blueprint at runtime. It builds Control Rig graphs, Control Rig Modules and full Modular Rigs.

That is the bit that matters to me. Rigging a character with working secondary motion is usually an afternoon at minimum. This was a description of what I wanted, a self correcting build, and a tuning pass.

codefizz.dev if you want a look.