Games are systems in motion.
Most coding agents see a game as files in a folder. But the truth lives in the editor, the scene graph, the console, the frame, and the moment a player presses a button.
BIGGI is our attempt to build the agent game developers actually need: one that can enter that loop, understand what happened, make a careful change, and prove the game still works.
Close the distance between writing the change and knowing it works.
The best game programmers do not stop when the code looks plausible. They run the scene, read the engine's verdict, inspect the object that failed, reproduce the mechanic, and measure the result. BIGGI turns that discipline into the default agent workflow.
The work so far.
A short record of the capabilities that changed BIGGI from a general agent into a game-development tool.
A coding agent that recognizes game projects
Engine detection, engine-specific rules, and gameplay, architecture, tech-art, and performance agents made game development the product—not a themed prompt preset.
The Game Loop reaches Godot
BIGGI learned to run Godot 4 projects, parse the real console, inspect scenes, run framework or zero-dependency tests, profile frames, and attach screenshots as evidence.
The running Unity editor becomes an API
A local bridge added compile autopilot, console and play-mode control, tests, screenshots, profiling, safe scene and prefab edits, GUID-aware references, and .meta hygiene.
Errors lead to scene-level root causes
Both deep integrations began connecting code failures to the scene state behind them—from unassigned Unity fields to broken Godot node and resource paths.
The agent starts playing
Tracked scenarios now replay input, wait for state, assert runtime values, capture evidence, and run in the editor or CI. Verification moved from ‘the tests compile’ to ‘the mechanic works.’
The game gains a semantic contract
Unity projects can now expose bounded state, invariants, and explicit gameplay actions. BIGGI can observe, act, and verify behavior through project-owned meaning instead of guessing at arbitrary runtime internals.
What we refuse to hand-wave.
The game is the source of truth
A clean diff is not proof. The running engine, scene state, frame data, and playtest result get the final word.
Capabilities must be honest
Deep Game Loop support is named engine by engine. When a capability is unavailable, BIGGI explains the boundary instead of improvising.
Developers stay in control
Reviewable edits, granular permissions, isolated worktrees, open prompts, bring-your-own keys, and an MIT-licensed core keep the agent inspectable.
Game development is multidisciplinary
Gameplay, architecture, tech art, and performance need different context and different permissions. BIGGI treats them as distinct jobs.
Fork it. Inspect it. Bring your own model.
BIGGI's client and agent runtime are MIT licensed. You can use your own provider keys, local models, or the optional BIGGI gateway. The same core runs in VS Code and the CLI.
Open-source acknowledgements remain in the repository and license. The product story stays focused on the developers and games BIGGI is built to serve.