I Built an AI That Actually Creates Unreal Engine Blueprints

There’s a point in every Unreal project where you stop being creative and start doing chores.

Create Blueprint.
Add camera.
Attach spring arm.
Set mesh.
Assign anim BP.
Fix offsets.
Compile.
Repeat.

Do it ten times, and it’s fine.
Do it a hundred times, and you start wondering why you’re still doing this manually.

That’s where Cipher came from.

Not as “another AI assistant.”
But as something that actually does the work inside Unreal.

The shift: from AI assistants → AI builders

Most AI tools right now help you write code.

They suggest things.
They autocomplete.
They explain.

But they stop right before the part that actually matters:

👉 changing your project

Cipher is different.

Instead of saying “here’s how to do it,” it goes:

“I’ll do it.”

What Cipher actually does

At a high level, it works like this:

You give a goal →
Cipher plans the steps →
Checks what exists in your project →
Executes inside Unreal →
Verifies the result →
Fixes anything that failed →
Returns a working Blueprint

That loop is the whole system:

Plan → Validate → Execute → Verify → Retry

No guessing. No blind generation. No “hope this works.”

A real example

Here’s a real command:

build BP_Test_Player with mesh SK_Mannequin anim_bp ThirdPerson_AnimBP and rifle and shooting system

What happens next:

• Cipher creates the Blueprint
• Confirms the parent class is correct
• Finds SK_Mannequin in the Asset Registry
• Assigns it to the character mesh
• Finds the animation blueprint
• Hooks it up correctly
• Adds components (camera, weapon, etc.)
• Verifies everything actually exists and works

And you end up with a playable character Blueprint.

No dragging. No clicking. No hunting through folders.

Why this doesn’t hallucinate like other AI

If you’ve used ChatGPT or Copilot for game dev, you’ve seen this:

“Use SK_PlayerMesh_Advanced_v2”

Cool. That asset doesn’t exist.

Cipher avoids that completely.

Before it does anything, it validates against Unreal itself:

• Uses the Asset Registry to confirm assets exist
• Enforces strict schemas for every action
• Only executes valid tool calls

So instead of:

“Here’s what should work”

It’s:

“This will work because it exists”

That one difference changes everything.

The part that made it feel real

The first time Cipher successfully built a character wasn’t exciting because of the AI.

It was exciting because I didn’t touch the editor.

I gave a sentence.
Watched logs.
Opened Unreal…

…and the Blueprint was just there. Working.

Camera set.
Mesh visible.
Anim hooked up.

That’s the moment it stopped being an experiment.

It doesn’t break when things go wrong

This was a big one.

Most AI systems fail once and stop.

Cipher doesn’t.

If something fails:

• It detects the failure
• Re-checks the state
• Adjusts the plan
• Tries again

Automatically.

That retry loop is built into everything.

So instead of babysitting the process, you just… let it run.

It actually remembers what it did

Cipher also keeps memory.

That means:

• It knows what it already created
• It avoids duplicating work
• It can continue builds instead of restarting

You’re not re-explaining your project every time.

It builds on itself.

Recipes: building more than one step

For bigger systems, Cipher uses recipes (YAML-based).

Think of it like this:

Instead of one command, you define a full build:

Create player →
Add camera system →
Assign mesh →
Assign animation →
Attach weapon →
Setup firing logic

And Cipher runs the entire sequence, validating at each step.

This is where it starts to feel less like a tool and more like a system.

What it can already do

Right now, Cipher can:

• Create character Blueprints
• Assign meshes and animation blueprints
• Attach weapons
• Build camera setups
• Configure components

And it does all of this directly inside Unreal Editor.

No export. No copy/paste. No manual follow-up.

Why this is different from ChatGPT or Copilot

Those tools operate outside your engine.

Cipher operates inside your project.

That means:

• It sees your actual assets
• It works with real Blueprint structures
• It validates against your current state

It’s not generating ideas.
It’s modifying reality.

The bigger idea

This isn’t about skipping effort.

It’s about shifting where effort goes.

Instead of:

“Let me build this step-by-step”

You move to:

“Let me describe what I want”

And let the system handle execution.

That’s a very different way of building games.

Where this goes next

Right now, Cipher is handling structured systems like characters and components.

But the direction is clear:

• More complex gameplay systems
• Full Blueprint graphs
• Multi-actor setups
• Eventually… entire game scaffolding

All from intent.

Final thought

There’s a lot of AI hype right now.

Most of it feels like tools getting slightly better at helping.

This felt different.

Because for the first time, I wasn’t being assisted.

I was being replaced… in the parts I didn’t want to do anyway.

And honestly?

That’s exactly what I wanted.