Two problems block AI automation in gamedev: bottlenecks that agents can't solve on their own (QA, UI, tech debt) and blockers that prevent agents from forming a pipeline at all. We're building a modular framework that addresses both.
They solve a narrow set of tasks. They can't be chained into a pipeline. And vibe-coded internal tools only make integration harder.
No native access to engine or codebase. Agents talk to chat endpoints, not to UnityEditor or Roslyn.
Break on edge cases. Hard to debug. One unexpected stack trace and the whole loop falls apart.
Can't compose into pipelines. Each tool ships its own chat UI; nothing speaks the same protocol.
In-house glue scripts integrate poorly and add their own debt. Built in a weekend, owned forever.
Even with a working agent, three categories of work block the pipeline. Each needs its own native tooling.
Agent can write code, but can it play the game? QA needs typed access to the running build — debug overlays, cheat commands, frame capture.
Agents reverse-engineer layout from videos and screenshots, then assemble it in uGUI under your conventions. Layout is no longer a handoff.
LLMs absorb the worst patterns in your repo and reproduce them at 10× speed. The Validator catches them deterministically and feeds back fixes.
LLMs absorb the bad practices already present in a legacy codebase. Human reviewers cannot keep up with the rate of generation. Debt compounds silently.
Review cadence roughly matches generation cadence. Bad patterns are caught in PR.
The agent learns how not to write code by looking at the legacy codebase — then reproduces exactly that. Human PR becomes the bottleneck; debt compounds.
In the legacy setup the human ferries errors back into chat. In the native pipeline the Validator speaks to the agent in actionable, deterministic items — and the loop closes itself.
A single integration point. The agent gets typed access to coder tools, the editor, and the running game build over the network.
Symbol-level access. The agent reads, analyses and rewrites C# with the same primitives the IDE uses.
Typed access to UnityEditor workflows: AssetDatabase, Prefab pipeline, scenes, build graph.
Connects to the build over the network. Debug overlays, cheat commands, frame capture — the agent can test the game, not just generate code.
Three steps. The Validator turns a recurring problem into a deterministic rule, then turns matches into actionable items the agent applies on its own.
An engineer notices recurring debt in the codebase: presentation logic in domain layer, deprecated APIs, brittle scene refs.
Configure the Validator to detect it deterministically. Same input → same verdict, every time.
Every match becomes an actionable item. The agent applies the fix; the dashboard tracks the result.
| ✗ | Performance test regressionscene/CombatArena | 12 | +4 | |
| ✗ | Business logic in UI layerHealthBar.cs · 7 more | 8 | +2 | |
| ! | Scene validator: missing refs3 scenes | 5 | 0 | |
| ✓ | Game config schema mismatchresolved 12d ago | 0 | −3 | |
| ✓ | Code convention #1: namingwhole repo | 0 | −6 | |
| ✓ | Code convention #2: structurewhole repo | 0 | −2 | |
| ✓ | Acceptance test failuresCI · last 30 days | 0 | −1 |
Layout handoff is the third chronic bottleneck. Agents reverse-engineer layout and behaviour from videos or screenshots and assemble it in uGUI — bounded by your conventions.
Drop a screen recording, a static mock, or a competitor's reference. The agent infers hierarchy, spacing, anchors and interaction states, then produces real uGUI prefabs against the assemblies you permit.