Most AI tools stop at generating code.
Cipher doesn’t.
It walks straight into Unreal Engine and builds.
That sounds cool on paper. In practice, it’s been messy, frustrating, and honestly… kind of insane to get working.
This is where we actually are right now.
What Cipher Actually Does (Right Now)
At its core, Cipher is a loop:
Goal → Plan → Validate → Execute → Verify → Repeat
You give it something simple like:
“Create a player character with a mesh and animation”
And instead of spitting out instructions, it:
Talks to a FastAPI server
Writes structured commands
Sends them into Unreal
Modifies Blueprints directly
Verifies if it worked
If it fails, it tries again.
No hand-holding. No guessing.
That loop is alive now.
The First Real Breakthrough
The moment things started feeling real was when we solved mesh + animation assignment.
Sounds basic. It wasn’t.
Unreal doesn’t behave the way you expect when you modify native components like CharacterMesh0.
We tried:
Writing to the CDO → didn’t persist
Recompiling after changes → wiped values
Using handlers → failed on native components
What finally worked:
Use SubobjectDataSubsystem
Modify components through handles
Control the compile order (this mattered more than anything)
Once that clicked, Cipher could:
Assign skeletal meshes
Apply animation blueprints
Verify the result
That was the first time the system felt stable.
Where It Gets Ugly
A lot of things looked like they worked… until they didn’t.
- Unreal Lifecycle Problems
Order matters more than logic.
If you:
assign mesh too early → it gets wiped
compile too often → you lose state
reload incorrectly → you verify the wrong object
We spent time chasing “bugs” that were just timing issues.
- False Positives in Verification
Cipher has a verify step, which sounds great… until it lies to you.
We had cases where:
Mesh looked assigned → but wasn’t saved
Animation existed → but wasn’t actually applied
Blueprint compiled → but still broken at runtime
So we had to build real verification, not surface checks.
Things like:
checking actual asset names
stripping _C from generated classes
validating component existence directly
- Python Listener Hell
Reloading agent_listener.py inside Unreal caused stale callbacks.
Meaning:
new code wouldn’t run
old functions stayed active
behavior became inconsistent
Fix was moving to a persistent dispatcher pattern instead of re-binding functions every reload.
- Blueprint Graph Logic (Still Painful)
We recently started working on node wiring and fan-out logic.
This introduced a whole new class of problems:
duplicate execution pins
broken connections
missing idempotency
Even small mistakes here create invisible bugs.
This is where we are currently fighting.
What Actually Works Today
Right now, Cipher can reliably:
Create / load Blueprints
Add components (camera, spring arm, etc.)
Assign meshes
Assign animation blueprints
Compile + save
Verify correctness
Run in a loop from a goals file
Command loop:
py dev_agent.py --loop goals/aegion_setup.txt
That loop is the foundation of everything.
What’s Coming Next (This Is the Real Shift)
Up to now, we’ve been proving control.
Next, we move into gameplay.
Not just assets. Behavior.
- Animation System Validation
We finish making sure animation blueprints:
attach correctly
play correctly
pass verification every time
No partial success.
- Weapon System (Big One)
This is the next major milestone.
Cipher should be able to:
Attach a weapon to a socket
Validate the socket exists
Add firing logic
Connect input → action
Verify the system actually works
This is where Cipher stops being “asset automation”
and starts becoming gameplay automation.
- Blueprint Modification (Not Creation)
We’re shifting focus:
Cipher should work with existing Blueprints, not just create new ones.
That means:
reading current state
modifying graphs safely
avoiding breaking existing logic
This is much harder than generating from scratch.
- Toward a Gameplay Layer
Long term, the goal is simple:
Cipher should understand:
systems (movement, combat, UI)
interactions (input → response)
rules (win/lose states)
Right now, we’re still at the foundation.
But the direction is clear.
The Reality
This hasn’t been smooth.
It’s been:
debugging Unreal internals
fighting engine behavior
rewriting systems that almost worked
learning that “it compiled” means nothing
But now there’s something real:
A loop that can take intent
and turn it into something inside Unreal
without manual work.
Final Thought
Most AI tools generate ideas.
Cipher executes them.
And we’re just getting past the part where it stops breaking everything.
Next phase is where it starts actually building games.
Top comments (0)