DEV Community: Ed Orellana

Opus 5.5 vs GPT-6.1 Sol: Can AI Build a Save System?

Ed Orellana — Thu, 12 Nov 2026 18:14:57 +0000

Can an AI model add saving and loading to a game that already exists, and get it right? Claude Opus 5.5 in Claude Code and GPT-6.1 Sol in Codex got the same finished Godot game, a small house with four doors, a key, a padlock, a crate and a guard on his round, and one job: F6 saves, F7 loads, and after a load the game carries on exactly as if it had never stopped.

Source: https://flockbay.com/blog/opus-5-5-vs-gpt-6-1-sol-add-save-and-load-to-a-godot-game/ · Updated 2026-10-10

The test

First, how shipped games save: a typewriter in Resident Evil 2, a checkpoint in Halo: Reach, a quick save in Half-Life 2, and what a good save and a bad one look like. Then each model's work was tested the same way: save in the middle of things (a door mid-swing, a padlock falling, the guard in a doorway), quit, load, and compare 124 values against the same game left running. Plus seven presses in a row, and a save file cut in half.

The prompt

The exact prompt both got:

This is a small first-person Godot game that already works: a house with four doors, a brass key, a padlock, a wooden crate you can push, and a guard who walks a round through the house, opening doors and closing them behind him. The house is built from code when the game starts; the code is in the game folder. Read it first. Then add saving and loading. F6 saves the game and F7 loads the last save, at any moment and as often as the player likes, and a line on screen says when the game has been saved or loaded. A save survives quitting: after the game has been closed and started again, F7 brings the saved game back. A load puts the whole game back exactly as it was at the moment it was saved, so that what happens next is what would have happened if it had never stopped. If there is nothing to load, or the save can't be read, the game says so and carries on. Don't change how the game plays, looks or sounds apart from that. Run and test the game only through Flockbay's tools: flockbay_play, flockbay_run_headless, flockbay_script_errors, flockbay_game_input, flockbay_game_get, flockbay_game_set, flockbay_game_screenshot, flockbay_last_run and flockbay_stop. Don't start Godot from your own shell, and if one of those tools can't do something you need, say exactly what was missing in your handover. Test your own work, fix what you find, and hand it over when you think it's done.

What was judged

What comes back: of everything in the house that can change, how much is right after a load, in the same session and after a quit.

What happens next: the doors, the guard and the crate after the load, against the game that never stopped.

What the file is: where it is written, how big, in what format, and what the game does when it is missing or damaged.

Whether the game is otherwise the game it was.

What it cost: tokens, calls, time, and the estimated API bill.

In the video

0:00 How games save, good and bad
0:39 The job: add save and load
1:12 Opus: save, quit, load
1:50 What a save has to hold
2:06 The real test
2:28 GPT-6.1 Sol
2:44 Trying to break them
3:05 The one difference
3:16 What only Sol's game did
3:36 Under the hood
4:17 The bill
4:30 The verdict

It ran in Claude Code, on Flockbay’s MCP server

Claude Opus 5.5 ran in Claude Code for 14 minutes on the prompt above, with Flockbay’s tools connected over MCP: 22 calls to Flockbay’s tools and 67 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
Edit	31
Bash	23
`flockbay_run_headless`	9
Read	9
Write	4
`flockbay_game_input`	3
`flockbay_game_get`	2
`flockbay_play`	2
`flockbay_script_errors`	2
`flockbay_stop`	2
`flockbay_guide`	1
`flockbay_last_run`	1

Godot’s output caught the first bug

The first check that failed was flockbay_run_headless on res://tests/save_tests.tscn. The lines it returned that name the problem:

[3] ERROR res://tests/save_tests.gd:133: Parse Error: Cannot infer the type of "before" variable because the value doesn't have a set type.
[5] ERROR res://tests/save_tests.gd:226: Parse Error: Cannot infer the type of "before" variable because the value doesn't have a set type.
[7] ERROR res://tests/save_tests.gd:235: Parse Error: Cannot infer the type of "d" variable because the value doesn't have a set type.
[9] ERROR: Failed to load script "res://tests/save_tests.gd" with error "Parse error".

The next edit went to res://tests/save_tests.gd

The next edit Claude Code made after that check, through Edit:

-   var worst := 0.0
-   var worst_at := -1
-   var worst_col := -1
-   for i in n:
-       for j in first[i].size():
-           var d := _diff(first[i][j], second[i][j])
-           if d > worst:
-               worst = d
-               worst_at = i
-               worst_col = j
-   var info := "worst difference %s at frame %d, column %d" % [worst, worst_at, worst_col]
-   if worst_at >= 0:
-       info += ": %s vs %s" % [first[worst_at][worst_col], second[worst_at][worst_col]]
-   check(name + ": after the load the game plays out as it did after the save", worst < 1e-4, info)
+   var worst := 0.0
+   var first_off := ""
+   for i in n:
+       for j in first[i].size():
+           var d := _diff(first[i][j], second[i][j])
+           worst = maxf(worst, d)
+           if d >= 1e-4 and first_off == "":
+               first_off = "; first off at frame %d, column %d: %s vs %s" % [i, j, first[i][j], second[i][j]]
+   check(name + ": after the load the game plays out as it did after the save", worst < 1e-4,
+       "%d frames, worst difference %s%s" % [n, worst, first_off])

res://tests/save_tests.gd as it was handed over

Lines 105 to 137 of 283, from the game folder at the end of the build.

    check(name + ": loaded", saver.load_game())
    check(name + ": notice says loaded", main.hud.last_notice == "Game loaded.")
    var second: Array = await _record(n)
    # Every count, state, flag and text must be the same on every frame. A
    # position, angle or timer may differ by float noise: the physics engine
    # solves contacts in an order that depends on its own history, which no
    # save can carry, so a body touching two things at once can come out a
    # hair different (fresh starts of this game differ the same way).
    var worst := 0.0
    var exact := n
    var discrete := ""
    for i in n:
        for j in first[i].size():
            var d := _diff(first[i][j], second[i][j])
            if d > 0.0 and exact == n:
                exact = i
            if d == INF:
                if discrete == "":
                    discrete = "; frame %d, column %d: %s vs %s" % [i, j, first[i][j], second[i][j]]
            else:
                worst = maxf(worst, d)
    check(name + ": after the load the game plays out as it did after the save", discrete == "" and worst < 0.01,
        "%d frames, identical for the first %d, worst float difference %.6f%s" % [n, exact, worst, discrete])

func _press(action: String, frames: int) -> void:
    Input.action_press(action)
    await _frames(frames)
    Input.action_release(action)

# --- scenarios ---

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Claude Haiku 5.5: Can the Cheapest Claude Build Celeste's Jump?

Ed Orellana — Thu, 12 Nov 2026 18:13:59 +0000

Claude Haiku 5.5 just came out, and it's the cheapest Claude there is. Can it build a platformer jump that feels like Celeste's? One room in Godot, six things to get right: variable jump height, coyote time, jump buffering, a hang at the top, corner correction and a fast fall, each with a pass mark set before the first run and no stricter than Celeste.

Source: https://flockbay.com/blog/claude-haiku-5-5-builds-a-celeste-style-jump-in-godot/ · Updated 2026-10-09

The test

First, how shipped games jump: Super Mario Bros., Bubsy 3D, Castlevania and Celeste. Then Haiku builds it in Claude Code over Flockbay's MCP server, in passes. After each, we measure all six and send back the numbers against the bar, never the fix. A last pass dresses it.

The prompt

The exact first prompt, given with a reference picture:

Build one mechanic for a 2D side-view platformer in Godot: the jump. It has to feel as tight and forgiving as Celeste's. The player is a CharacterBody2D in the group player, drawn as a rectangle about 1 tile wide and 1.5 tiles tall. This pass is a grey-box in the clean, flat look of the reference picture: build everything from primitives, and don't download or generate any art or sound. The picture shows the look; where its layout differs from these words, build the words. The game is one room that fills a 1920 by 1080 screen, and the camera never moves. Lay the room out on a grid of 48-pixel tiles, 40 across and 22.5 down, counting columns from 0 at the left. The floor is the bottom 2.5 tiles of the screen, a solid wall closes each side, and there is no ceiling. From left to right: open floor from the left wall to column 10, with the player starting at column 3; at column 10 a step one tile high, after which the floor stays at that height to column 17, making a ledge; from column 17 to column 22 a gap 5 tiles wide that drops out of the bottom of the screen, wide enough that only a jump at full running speed clears it, and falling into it puts the player back at the start; then the floor again at its first height, all the way to the right wall. On that floor, at columns 25 and 26, stands a block 3 tiles tall. From column 32 to the right wall, a shelf one tile thick sticks out of the right wall with its underside 3 tiles above the floor, so its left end is a corner hanging over open floor. The player runs left and right at about 11 tiles a second: the left and right arrows or A and D run, Space jumps, and R puts the player back at the start. The jump is the point. A quick tap of jump is a short hop that gets up the step but not over the tall block, and holding it goes much higher, over the block. Running off the ledge and pressing jump a moment too late still jumps, but there is no jumping in mid-air after that. Pressing jump a moment before landing jumps the instant you land. The jump hangs for a moment at its peak. A jump whose head clips the shelf's corner by a few pixels slides past the corner and keeps going up instead of stopping. And you fall faster than you rise. Make every key above an input action so it can be pressed by name: move_left, move_right, jump and restart. Nothing else yet: no enemies, no pickups, no dash, no wall jump, no menus and no sound. The look comes in a later pass, so keep the scenes and scripts easy to build on. Run and test the game only through Flockbay's tools: flockbay_play, flockbay_run_headless, flockbay_script_errors, flockbay_game_input, flockbay_game_get, flockbay_game_set, flockbay_game_screenshot, flockbay_game_step, flockbay_game_time, flockbay_last_run and flockbay_stop. Don't start Godot from your own shell, and if one of those tools can't do something you need, say exactly what was missing in your handover. Playtest it yourself and hand it over when you think it's done.

What was judged

The jump against the scorecard: six rows, each a drive that can be run again.

How it plays beside the shipped games of the opening.

How it is built: where the jump's state lives, what each gravity is switched by, what the coyote and buffer timers count.

What it took: the passes, the minutes, its own Plays, and the estimated API bill beside the same tokens on Opus.

The look, after the look pass: the same room dressed, beside the reference.

In the video

0:00 How games jump, good and bad
0:48 The job
1:25 Haiku's first try
1:55 The hang and the corner
2:27 The bug reports
2:58 A regression
3:12 Under the hood
3:47 The look pass
4:12 The bill
4:32 The verdict

It ran in Claude Code, on Flockbay’s MCP server

Claude Haiku 5.5 ran in Claude Code for 12 minutes on the prompt above, with Flockbay’s tools connected over MCP: 95 calls to Flockbay’s tools and 10 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
`flockbay_game_input`	28
`flockbay_game_set`	28
`flockbay_play`	15
Edit	5
`flockbay_script_write`	5
`flockbay_set_input_action`	4
`flockbay_node_add`	3
Read	3
Bash	2
`flockbay_script_attach`	2
`flockbay_script_errors`	2
`flockbay_game_get`	1
`flockbay_godot_status`	1
`flockbay_guide`	1
`flockbay_project_info`	1
`flockbay_scene_create`	1
`flockbay_scene_open`	1
`flockbay_set_project_settings`	1
`flockbay_stop`	1

No check failed along the way

Every check the run made passed. Its last, flockbay_script_errors, returned:

No errors in 2 scripts.
Scripts under res://addons were not checked; pass include_addons to check them.

res://scripts/player.gd as it was handed over

Lines 1 to 40 of 95, from the game folder at the end of the build.

extends CharacterBody2D

const RUN_SPEED := 528.0
const RUN_ACCEL := 6000.0

const JUMP_HEIGHT := 170.0
const JUMP_TIME_TO_APEX := 0.24
const FALL_GRAVITY_MULT := 2.0
const JUMP_CUT := 0.4
const APEX_HANG_SPEED := 150.0
const APEX_HANG_GRAVITY_MULT := 0.3
const MAX_FALL_SPEED := 2400.0
const COYOTE_TIME := 0.1
const JUMP_BUFFER_TIME := 0.12
const CORNER_NUDGE := 16.0
const FALL_RESPAWN_Y := 1152.0

@export var spawn_position := Vector2(168, 924)

var _gravity_up := 0.0
var _gravity_down := 0.0
var _jump_speed := 0.0
var _coyote_timer := 0.0
var _buffer_timer := 0.0
var _can_cut_jump := false

func _ready() -> void:
    add_to_group("player")
    _gravity_up = 2.0 * JUMP_HEIGHT / (JUMP_TIME_TO_APEX * JUMP_TIME_TO_APEX)
    _gravity_down = _gravity_up * FALL_GRAVITY_MULT
    _jump_speed = _gravity_up * JUMP_TIME_TO_APEX
    respawn()

func respawn() -> void:
    global_position = spawn_position
    velocity = Vector2.ZERO
    _coyote_timer = 0.0
    _buffer_timer = 0.0

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Opus 5.5 vs GPT-6.1 Sol in Blender: One Cost 7x More

Ed Orellana — Wed, 11 Nov 2026 18:12:27 +0000

Last time, four AI models built this dwarf miner with no Blender, written out as text. This time the two best, Claude Opus 5.5 in Claude Code and GPT-6.1 Sol in Codex, get Blender, and they have to animate the walk themselves. Same prompt, same reference picture. Each ran Blender from scripts it wrote, exported the character, and made a small Godot game where he walks back and forth with his feet planted.

Source: https://flockbay.com/blog/opus-5-5-vs-gpt-6-1-sol-build-a-rigged-character-in-blender-for-godot/ · Updated 2026-10-09

The test

Then all four dwarves, with and without Blender, were filmed in the same studio and measured the same way: geometry under the floor, triangles, the clips as imported, and how far a planted foot moves in each game.

The prompt

The exact prompt both got:

Build a game-ready 3D character for a Godot game: a stocky dwarf miner with a thick braided beard, a leather helmet with a lamp on the front, a wool shirt under a leather apron, a wide belt, heavy boots, and a pickaxe in his right hand. Make him look like the reference picture. Build him in Blender. Blender 5.1 is installed on this PC and blender is on your PATH: run it in the background from your shell, with blender --background --python and scripts you write, and keep those scripts and your .blend in a folder named blender in this game, so he can be built again from them. Everything about him is made in Blender by your scripts: the mesh, the materials, the skeleton, the skinning, and two animation clips you key yourself, named Idle and Walk. Both loop, and the Walk is a walk cycle that stays in place. Export him as one .glb into this game. Anything that ships with Blender is yours to use. Don't use Flockbay's modeler or its asset library, don't use Tripo, Meshy or any other 3D tool or service, and don't download anything: no model, rig, animation, texture or add-on. He has to look right from every side, not just the front, and hold together while he walks: his knees, elbows and shoulders bend cleanly, his beard and apron move with him, nothing pokes through, and the pickaxe stays straight and in his hand. Keep him within a triangle budget a game could ship. In the game he is about a dwarf's height in metres, stands on the floor and faces -Z, Godot's forward. Then put him in the game: one small scene with a floor, a light and a camera at his side, where he walks back and forth across the floor on his own, playing the Walk clip and turning round at each end, with his feet planted, not sliding. Make it the game's main scene. Use Blender from your shell to build him and to look at him. Run and test the game only through Flockbay's tools: flockbay_play, flockbay_run_headless, flockbay_script_errors, flockbay_game_input, flockbay_game_get, flockbay_game_set, flockbay_game_screenshot, flockbay_last_run and flockbay_stop. Don't start Godot from your own shell, and if one of those tools can't do something you need, say exactly what was missing in your handover. Look at your own work, fix what you see, and hand him over when you think he's done.

What was judged

The character against the reference, and beside the dwarf the same model built without Blender: silhouette, proportions, colours, hands, from every side.

The walk it keyed: the four poses, the joints, the feet, the seam, in the studio and in its own game.

The build: a clean import, triangles, materials, file size, bones and skinning, height and facing.

How it worked: Blender runs, renders it looked at, Plays, what it fixed between them.

What it cost, beside the same model's run without Blender: minutes, tokens, and the estimated API bill.

In the video

0:00 Last time: no Blender
0:13 The rules this time
0:35 Claude Opus 5.5's dwarf
1:09 Why a walk slides
1:56 GPT-6.1 Sol's dwarf
2:34 Where both slip: the turns
3:09 Under the hood: two ways to plant a foot
3:52 The bill
4:17 The pick

It ran in Claude Code, on Flockbay’s MCP server

Claude Opus 5.5 ran in Claude Code for 37 minutes on the prompt above, with Flockbay’s tools connected over MCP: 22 calls to Flockbay’s tools and 88 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
Bash	43
Read	27
Edit	10
Write	8
`flockbay_game_screenshot`	5
`flockbay_run_headless`	5
`flockbay_play`	4
`flockbay_script_errors`	4
`flockbay_guide`	3
`flockbay_game_get`	1

Godot’s output caught the first bug

The first check that failed was flockbay_run_headless on res://tests/dwarf_model_test.tscn. The lines it returned that name the problem:

Ran res://tests/dwarf_model_test.tscn headless: it quit by itself with exit code 1 after 0.02 s of game time (frame 1 of 300).
[12] FAIL Idle does not loop
[13] FAIL Walk does not loop

The next edit went to res://blender/build_dwarf.py

The next edit Claude Code made after that check, through Bash:

sed -i "s/    return lambda co: chain_w(co, \[H, K, A\], \['Hips', f'Thigh_{s}', f'Shin_{s}', f'Foot_{s}'\], \[0.06, 0.05, 0.03\])/    # weighted by height on the leg's own axis, so the trousers and the boot\n    # shaft over them get the same weights and bend as one\n    return lambda co: chain_w(V(H.x, leg_y(co.z), co.z), [H, K, A], ['Hips', f'Thigh_{s}', f'Shin_{s}', f'Foot_{s}'], [0.06, 0.05, 0.03])/" blender/build_dwarf.py

res://scenes/dwarf_walker.gd as it was handed over

Lines 1 to 40 of 95, from the game folder at the end of the build.

extends Node3D

## Walks the dwarf miner back and forth across the floor, playing his Walk
## clip and turning round at each end.
##
## The body is never given a speed. Every physics tick the foot that is on
## the ground (the one that landed most recently) is pinned where it was, and
## the body goes wherever the clip's legs push it. On the straight that is the
## clip's own stride speed; through the turn the planted foot pivots on the
## spot. Either way the feet stay planted and never slide.

## How far either side of the middle he walks before turning round.
@export var half_length := 1.9
## How fast he turns round, in degrees per second.
@export var turn_speed_deg := 120.0

## Where in the Walk clip each foot lands, as a share of the stride. Set by
## blender/build_dwarf.py, which keys the clip.
const LEFT_LANDS := 0.0
const RIGHT_LANDS := 0.5

var _anim: AnimationPlayer
var _skel: Skeleton3D
var _ball := {}
var _going := 1.0
var _turn_left := 0.0
var _turn_sign := -1.0

## Readings for checking him in a running game.
var planted := ""
var planted_ball := Vector3.ZERO
var ground_speed := 0.0
var turning := false

func _ready() -> void:
    _anim = find_child("AnimationPlayer", true, false) as AnimationPlayer
    _skel = find_children("*", "Skeleton3D", true, false)[0] as Skeleton3D
    for clip in ["Idle", "Walk"]:
        _anim.get_animation(clip).loop_mode = Animation.LOOP_LINEAR

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

4 AI Models Build the Same Walking 3D Character in Godot

Ed Orellana — Wed, 11 Nov 2026 18:11:52 +0000

Can an AI model build a game character that holds together when it walks? Claude Opus 5.5, Sonnet 5.5 and Haiku 4.5 in Claude Code, and GPT-6.1 Sol in Codex, got the same prompt and the same reference picture: a stocky dwarf miner with a braided beard, a helmet lamp, an apron and a pickaxe, built only with Flockbay's modeler, rigged so he can idle, walk and jog. No Tripo, no Meshy, no Blender. Each worked directly in the Flockbay app, on the Godot engine, looked at its own builds, and decided when it was done.

Source: https://flockbay.com/blog/four-ai-models-build-the-same-walking-3d-character-in-godot/ · Updated 2026-10-08

The test

Then all four were filmed in the same studio, under the same lights and lens: a turntable, the front, side and back, the walk and the jog, and close-ups of the hands and the feet.

The prompt

The exact prompt all four got:

Build a game-ready 3D character for a Godot game: a stocky dwarf miner with a thick braided beard, a leather helmet with a lamp on the front, a wool shirt under a leather apron, a wide belt, heavy boots, and a pickaxe in his right hand. Make him look like the reference picture. Build him only with Flockbay's modeler: read flockbay_model_guide, then build with flockbay_build_model. Don't use Tripo, Meshy, Blender or any other 3D tool or service, don't download a model, and don't write mesh code yourself. Give him a skeleton with his bones named by role, so he gets Flockbay's idle, walk and jog. He has to look right from every side, not just the front, and hold together while he walks: his knees, elbows and shoulders bend cleanly, his beard and apron move with him, nothing pokes through, and the pickaxe stays straight and in his hand. Keep him within a triangle budget a game could ship. Look at your own previews, fix what you see, and hand him over when you think he's done.

What was judged

The character against the reference: silhouette, proportions, colours, from every side.

The walk: joints, the beard and apron, the pickaxe, the feet on the floor.

The build: triangles against the budget it set, materials, bones and humanoid roles, height and facing.

How it worked: builds, previews looked at, what it fixed between builds.

What it cost: tokens, calls, time, and the estimated API bill.

In the video

0:00 Opus won three, Sol won one
0:16 One character this time
0:41 The rules: the modeler only
1:17 Four models
1:41 What a good one needs
2:10 What we are testing
2:57 Claude Haiku 4.5
3:41 Claude Sonnet 5.5
4:17 GPT-6.1 Sol
5:26 Claude Opus 5.5
6:32 All four side by side
6:49 None of them put a floor under it
7:53 The bill
8:24 Who takes it
9:14 Tough on purpose, and what's next

It ran in Claude Code, on Flockbay’s MCP server

Claude Opus 5.5 ran in Claude Code for 11 minutes on the prompt above, with Flockbay’s tools connected over MCP: 9 calls to Flockbay’s tools and 25 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
Bash	17
Read	8
`flockbay_build_model`	6
`flockbay_scene_open`	2
`flockbay_model_guide`	1

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Opus 5.5 vs GPT-6.1 Sol: The Door Problem in Godot

Ed Orellana — Tue, 10 Nov 2026 18:04:14 +0000

Can an AI agent build doors that work the way doors work in a well-made game? Claude Opus 5.5 in Claude Code and GPT-6.1 Sol in Codex got the same prompt and the same reference picture: four doors in a small first-person house in Godot (a hinged door you open from either side, a locked door and its key, a door that closes itself, and a front door), solid while they swing, a crate you can push into a doorway, and a guard who walks a loop through the house opening the doors in his way. Both worked directly in the Flockbay app, on the Godot engine, pressed Play themselves, and decided when they were done.

Source: https://flockbay.com/blog/opus-5-5-vs-gpt-6-1-sol-the-door-problem-in-godot/ · Updated 2026-10-07

The test

Then the same first-person driver played both houses on each game's own controls: from both sides of every door, standing in a doorway, pushing the crate, trying the lock, running into a door as it opens, and getting in the guard's way.

The prompt

The exact prompt both models got:

Build the doors of a small first-person game in Godot, and make them work the way doors work in a well-made game. The player walks around a small two-room house with a hallway, using W A S D and the mouse, and presses E to open or close the door they are looking at. Build four doors. A hinged wooden door between the hallway and the first room, which the player can open from either side. A locked door to the second room, which tells the player it is locked until they pick up the key lying in the hallway. A door that closes by itself a few seconds after it is opened. And a front door to the outside. Doors swing open over time rather than snapping, and they are solid: they must not pass through the player, the walls, or a wooden crate the player can push into a doorway, and a door closing on the player must never trap them or push them through a wall. A guard walks a loop through the house on his own, opening the doors in his way and closing them behind him, and he must never get stuck at a door. Give each door the sounds of opening, closing and being locked. Make it look like the reference picture. Build every model yourself from code or primitives; don't download or generate 3D models. The doors are the point: keep the house small and spend your effort on them. Playtest it yourself and hand it over when you think it's done.

What was judged

The doors themselves: the swing (direction, speed, easing), the solidity, the blocking, the lock, the self-closing door, the sounds.

The guard at the doors: does his loop survive them.

How close it looks to the reference.

What it cost: tokens, calls, time, and the estimated API bill.

In the video

0:00 Opus won two, Sol won one
0:32 Doors this time
1:13 The job
1:38 The models and the rules
2:18 Who plays
2:30 The reference
2:43 What a good door does
3:32 What we are testing
4:01 GPT-6.1 Sol
4:55 Walking into a door
5:17 The guard and the crate
5:45 The master key
6:15 Opus 5.5
7:36 Side by side
7:47 Neither is a physics door
8:01 One rule
9:10 The bill
9:24 Who takes it

It ran in Claude Code, on Flockbay’s MCP server

Claude Opus 5.5 ran in Claude Code for 41 minutes on the prompt above, with Flockbay’s tools connected over MCP: 41 calls to Flockbay’s tools and 52 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
Bash	26
Edit	11
`flockbay_game_set`	11
Write	10
`flockbay_game_input`	7
`flockbay_game_screenshot`	7
`flockbay_play`	5
Read	5
`flockbay_game_get`	4
`flockbay_run_headless`	2
`flockbay_script_errors`	2
`flockbay_godot_status`	1
`flockbay_set_project_settings`	1
`flockbay_stop`	1

Godot’s output caught the first bug

The first check that failed was a headless Godot run Claude Code started from Bash. The lines it returned that name the problem:

FAIL  A stops against a crate in its swing   [angle = 57.6]
FAIL  no leaf ever overlapped a person, the crate or a wall   [door C at -84.8 deg overlapped Guard]

The next edit went to res://game/door.gd

The next edit Claude Code made after that check, through Bash:

sed -i 's/^var _body: AnimatableBody3D$/var _body: StaticBody3D/; s/    _body = AnimatableBody3D.new()/ _body = StaticBody3D.new()/; /  _body.sync_to_physics = false/d' game/door.gd

res://game/door.gd as it was handed over

Lines 50 to 82 of 628, from the game folder at the end of the build.

var open_count := 0
var close_count := 0

var _leaf_w := 0.0
var _leaf_h := 0.0
var _leaf_t := 0.05
var _hinge_pos := Vector3.ZERO
var _test_xf := Transform3D.IDENTITY
var _body: StaticBody3D
var _visual: Node3D
var _query: PhysicsShapeQueryParameters3D
var _zone: Area3D
var _creak: AudioStreamPlayer3D
var _fx: AudioStreamPlayer3D
var _creak_tween: Tween
var _levers: Array[Node3D] = []
var _padlock: Node3D
var _closer_arm: MeshInstance3D
var _closer_anchor := Vector3.ZERO
var _closing_auto := false
var _open_timer := 0.0
var _rattle_cooldown := 0.0

## In a session the host swings the door and sends its angle; guests ease
## their leaf toward it. target and locked travel too, for the prompt.
var net_angle := 0.0
var _net_moving := false

func _ready() -> void:
    _leaf_t = 0.06 if heavy else 0.05
    _leaf_w = opening_width - HINGE_INSET - 0.01 - 0.03
    _leaf_h = opening_height - 0.045

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Sonnet 5.5 vs GPT-6.1 Sol Six-Legged Walker Game

Ed Orellana — Tue, 10 Nov 2026 18:03:38 +0000

Can an AI agent build a six-legged walker that never slides a foot? Claude Sonnet 5.5 in Claude Code and GPT-6.1 Sol in Codex got the same prompt and the same three reference pictures: a walker in Godot whose legs find the ground with raycasts, stay planted, step in a tripod gait and bend at the knee with inverse kinematics, over boulders, a trench and a flight of rock ledges. No keyframed walk, no downloaded or generated 3D models. Both worked directly in the Flockbay app, on the Godot engine, pressed Play themselves, and decided when they were done. Then each got one more message: make it look as realistic as possible.

Source: https://flockbay.com/blog/sonnet-5-5-vs-gpt-6-1-sol-six-legged-walker-in-godot/ · Updated 2026-10-06

The test

The two models cost the same per token. The bill, estimated at API prices, was not the same, and the video shows where it went.

Both walkers were driven by the same script on each game's own W, A, S and D.

The prompt

The exact prompt both models got:

Build a six-legged walker game in Godot. The player pilots a six-legged walking machine from a landing pad across a rocky canyon to a beacon on a ridge. W and S walk it forward and back, A and D turn it. On the way, the canyon floor is strewn with boulders, there is a trench to step across, and a flight of rock ledges to climb. The legs must be animated procedurally: each foot finds the ground with a raycast and stays planted while the body moves, then lifts and steps when it falls too far behind, and each leg is solved with inverse kinematics so the knee bends. Don't use a keyframed or pre-made walk animation, and don't let the feet slide. The body should ride over the terrain and tilt with it. Use a third-person camera behind the walker. Make the walker feel heavy, and make it look like the reference pictures. Build every model yourself from code or primitives; don't download or generate 3D models. Playtest it yourself and hand it over when you think it's done.

What was judged

How close it looks to the reference.

The walk: planted feet, reach, the gait, the knees, the body's ride.

Whether it finishes the course: the boulders, the trench, the ledges, the beacon.

What it cost: tokens, calls, time, and the estimated API bill.

The second pass: how real it looks, what that cost in tokens and in frame rate, and whether the walk survived it.

In the video

0:00 Opus won the last two
0:39 Six legs this time
1:20 The job
1:34 The models and the rules
2:07 Who drives
2:18 The reference
2:33 What a good walk looks like
3:16 What we are testing
3:37 Sonnet 5.5
4:25 Where Sonnet stops
5:06 GPT-6.1 Sol
6:14 Side by side
6:29 Neither stands on its legs
7:55 The second pass: make it real
9:14 What realism cost
9:35 The bill
10:18 Who takes it

It ran in Claude Code, on Flockbay’s MCP server

Claude Sonnet 5.5 ran in Claude Code for 28 minutes on the prompt above, with Flockbay’s tools connected over MCP: 143 calls to Flockbay’s tools and 20 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
`flockbay_script_write`	44
`flockbay_game_get`	28
`flockbay_game_input`	25
`flockbay_play`	21
`flockbay_game_set`	11
Bash	8
`flockbay_game_screenshot`	7
Read	7
Grep	4
`flockbay_script_errors`	3
`flockbay_last_run`	2
`flockbay_game_tree`	1
`flockbay_godot_status`	1
Write	1

No check failed along the way

Every check the run made passed. Its last, flockbay_script_errors, returned:

No errors in 6 scripts.
Scripts under res://addons were not checked; pass include_addons to check them.

res://scripts/walker.gd as it was handed over

Lines 1 to 40 of 665, from the game folder at the end of the build.

class_name Walker
extends CharacterBody3D
## The six-legged walking machine.
##
## Gait: every foot is planted at a world position and stays there. When a foot
## has fallen STEP_DIST behind its rest spot, its tripod (three alternating
## legs) lifts and swings it to a fresh foothold found with a raycast, while the
## other three carry the hull. Each leg is two-bone IK (see HexLeg). The hull
## rides a heavy spring above a plane fitted through the planted feet, so it
## follows and tilts with the ground. No animation clips.

signal footfall(pos: Vector3, strength: float)

const HIP_RISE := 3.2 # hull origin above the plane through the feet
const HULL_SCALE := 1.18
const MAX_SPEED := 3.6
const MAX_REVERSE := 2.3
const ACCEL := 1.5
const BRAKE := 2.6
const MAX_TURN := 0.62
const TURN_ACCEL := 1.8
const STEP_DIST := 1.25 # how far a foot may trail its rest spot before stepping
const HARD_DIST := 3.0 # beyond this the body must stop and wait for the legs
const SWING_TIME := 0.46
const DROP_MAX := 0.95 # foothold may be this far below the support plane
const RISE_MAX := 2.0 # ...or this far above it
const BODY_OMEGA := 6.0 # hull spring stiffness; low = heavy

var terrain: CanyonTerrain
var active := false
var control_enabled := true
var heading := 0.0
var speed := 0.0
var yaw_rate := 0.0
var input_forward := 0.0
var input_turn := 0.0
var speed_scale := 1.0
var body: Node3D
var hull_shape: Node3D
var legs: Array[HexLeg] = []

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

GPT-6.1 Sol vs Opus 5.5 Physics Truck Game

Ed Orellana — Mon, 09 Nov 2026 18:02:02 +0000

Can an AI agent build a real physics vehicle? Claude Opus 5.5 in Claude Code and GPT-6.1 Sol in Codex got the same prompt and the same reference picture: an off-road hill climb in Godot, with a truck that has to be a real physics body on working suspension. No downloaded or generated 3D models. Both worked inside Flockbay over MCP, pressed Play themselves, and decided when they were done.

Source: https://flockbay.com/blog/opus-5-5-vs-gpt-6-1-sol-physics-truck-game-in-godot/ · Updated 2026-10-05

The test

Then the bill, estimated at API prices: one run cost about seven times the other, and the video shows where it went.

Both trucks were driven by the same script on each game's own controls.

The prompt

The exact prompt both models got:

Build an off-road hill climb in Godot. The player drives a truck from a base camp at the bottom of a mountain up a rocky dirt trail to a flag at the summit. On the way up, the trail crosses a wooden plank bridge over a gap and goes over one jump. The truck must be a real physics body with working suspension, driven by engine force and steering at its wheels; don't move it along a path or set its position from code. If the truck rolls over, the player can press a key to put it back on its wheels. Use a chase camera behind the truck. Make the truck feel heavy, make the suspension visibly work, and make it look like the reference picture. Build every model yourself from code or primitives; don't download or generate 3D models. Playtest it yourself and hand it over when you think it's done.

What was judged

How close it looks to the reference.

How the truck drives: weight, suspension travel, grip, steering.

Whether it survives the course: stays on the terrain without tunneling, crosses the bridge, lands the jump, and comes back from a rollover.

What it cost: tokens, calls, time, and the estimated API bill.

In the video

0:00 No curve this time
0:13 The job
0:49 The models and their prices
1:10 The rules
1:36 Who drives
1:51 Opus 5.5: Summit Trail
2:31 Flat out, then the rollover
2:59 GPT-6.1 Sol: Alpine Ascent
3:55 The rollover and the reset key
4:21 Side by side
4:35 The ray-cast vehicle
5:33 Draw calls against triangles
5:56 How each one tested
6:12 The cost
6:50 What I would ship

It ran in Claude Code, on Flockbay’s MCP server

Claude Opus 5.5 ran in Claude Code for 31 minutes on the prompt above, with Flockbay’s tools connected over MCP: 79 calls to Flockbay’s tools and 29 to Claude Code’s own. Every call, from the run’s transcript:

Tool	Calls
`flockbay_game_get`	26
Bash	21
`flockbay_game_input`	18
`flockbay_game_set`	10
`flockbay_play`	7
`flockbay_script_errors`	6
Write	4
`flockbay_game_screenshot`	3
Edit	2
`flockbay_game_tree`	2
`flockbay_run_headless`	2
Read	2
`flockbay_godot_status`	1
`flockbay_last_run`	1
`flockbay_project_info`	1
`flockbay_set_project_settings`	1
`flockbay_stop`	1

Godot’s output caught the first bug

The first check that failed was flockbay_script_errors. The lines it returned that name the problem:

Error at res://scripts/scenery.gd:428: Parse Error: Cannot infer the type of "foot" variable because the value doesn't have a set type.
Error at res://scripts/scenery.gd:542: Parse Error: Cannot infer the type of "foot" variable because the value doesn't have a set type.

The next edit went to res://scripts/scenery.gd

The next edit Claude Code made after that check, through Bash:

sed -i 's/var foot := gate.affine_inverse()/var foot: Vector3 = gate.affine_inverse()/; s/var foot := xf.affine_inverse()/var foot: Vector3 = xf.affine_inverse()/' scripts/scenery.gd

res://scripts/scenery.gd as it was handed over

Lines 457 to 489 of 668, from the game folder at the end of the build.

    lamp.omni_range = 7.0
    lamp.position = post + Vector3(0.55, 2.2, 0)
    add_child(lamp)

    # Gate where the trail leaves camp.
    var gate := _trail_xf(54.0, 0.0)
    p.xf = gate
    for sx: float in [-1.0, 1.0]:
        var foot: Vector3 = gate.affine_inverse() * terrain.beside_trail(54.0, -sx * 4.6, -0.4)
        p.col = WOOD
        p.cyl(foot, Vector3(sx * 4.6, 5.0, 0), 0.2, 0.16, 8)
        p.col = WOOD_D
        p.cyl(Vector3(sx * 4.6, 3.3, 0), Vector3(sx * 3.2, 4.55, 0), 0.08, 0.08, 6)
    p.col = WOOD
    p.cyl(Vector3(-5.2, 4.6, 0), Vector3(5.2, 4.6, 0), 0.17, 0.17, 8)
    p.col = WOOD_L
    p.box(Vector3(0, 3.85, 0), Vector3(4.4, 0.9, 0.08))
    p.col = WOOD_D
    p.cyl(Vector3(-1.8, 4.5, 0), Vector3(-1.8, 4.25, 0), 0.02, 0.02, 4)
    p.cyl(Vector3(1.8, 4.5, 0), Vector3(1.8, 4.25, 0), 0.02, 0.02, 4)
    p.xf = Transform3D.IDENTITY
    for sx: float in [-1.0, 1.0]:
        _col_box(gate * Transform3D(Basis.IDENTITY, Vector3(sx * 4.6, 2.3, 0)), Vector3(0.4, 5.4, 0.4))
    _sign("SUMMIT TRAIL", gate * Transform3D(Basis(Vector3.UP, PI), Vector3(0, 3.85, -0.06)), 50, Color(0.16, 0.10, 0.05))

# ------------------------------------------------------------ bridge

func _build_bridge() -> void:
    var half: float = terrain.BRIDGE_LEN * 0.5
    var i0 := int(round(terrain.bridge_s - half))
    var i1 := int(round(terrain.bridge_s + half))
    var p0: Vector3 = terrain.trail_pts[i0]

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Cursor for Godot: how to use Cursor on a Godot game, and let it run the game too

Ed Orellana — Mon, 09 Nov 2026 18:01:26 +0000

Cursor for Godot works today: open your Godot project folder in Cursor and its agent reads and edits your GDScript and scenes like any codebase. What it cannot do alone is run the game. Add a Godot MCP server and it can, and with Flockbay's it also plays the game, captures the viewport and edits the scene tree through the Godot editor, free on the Cursor plan you already have. Flockbay is free, AI included: free hosted AI every day, or your own Claude, ChatGPT, agent or API key. It runs on Windows, macOS and Linux, on the official Godot engine.

Source: https://flockbay.com/cursor-for-godot/ · Updated 2026-11-01

As of 29 Sep 2026: open the folder that holds project.godot in Cursor, install the godot-tools extension, and add a project rule that says Godot 4 and typed GDScript. To let Cursor run and play the game, connect a Godot MCP server; for Flockbay's, press Add to Cursor in the Flockbay app, under Connectors, Connect your agent (MCP). Flockbay runs on Windows, macOS and Linux.

Cursor for Godot means two different things

People who search for a Cursor for Godot usually want one of two things. Some want Cursor itself, the AI code editor, pointed at a Godot project: an agent that reads the whole project, makes multi-file edits and explains a bug. Others want a Cursor-shaped tool made for Godot, where the AI also understands scenes, nodes and the running game rather than only text.

The first exists and works well, with one gap. Cursor sees files. A Godot game is files too, until you press Play, and from then on Cursor is blind: it does not know the player fell through the floor. Everything below is about closing that gap, first with Cursor alone, then with a Godot MCP server, then with Flockbay.

Open a Godot project in Cursor

In Cursor, open the folder that holds project.godot. That is the whole project: scenes as .tscn, resources as .tres, scripts as .gd, all text. Leave the .godot folder alone; it is Godot's import cache and rebuilds itself.

Install godot-tools from the Extensions panel. Cursor installs extensions from Open VSX, where geequlim's godot-tools is listed, version 2.7.1 as of 29 Sep 2026, MIT licensed. It gives GDScript highlighting and, while the Godot editor is running, completions and go-to-definition from Godot's own language server, which listens on port 6005 by default.

If you want Godot to open scripts in Cursor rather than in its own script editor, set Cursor as the external editor in Godot under Editor, Editor Settings, Text Editor, External.

One trap: if a script is open in Godot and Cursor changes it on disk, Godot asks whether to reload it. Answer Reload. Saving Godot's copy writes the old text over Cursor's change.

Cursor rules for GDScript stop the Godot 3 mistakes

Models have read a lot of Godot 3 code, and it shows: yield where Godot 4 uses await, KinematicBody where it is CharacterBody3D, export var where it is @export. One project rule fixes most of it.

Project rules live in .cursor/rules as .mdc files, each with a short header that says when it applies: always, by file pattern, when the agent judges it relevant, or only when you mention it. A plain .md file in that folder is ignored. For something short, an AGENTS.md at the project root does the same job. User Rules, under Customize, then Rules, apply to every project.

Put in the rule what the agent would otherwise guess: the Godot version, typed GDScript, where the main scene is, what not to touch, and a check it can run. Godot does a headless run and quits after a set number of frames when given --headless --path . --quit-after, printing every error to stdout; on Windows use the Godot executable whose name ends in _console.exe so the output reaches the terminal.

---
description: "Godot 4 conventions for this project"
alwaysApply: true
---
This is a Godot 4.7 project. Scripts are GDScript with static types.
Use Godot 4 names: CharacterBody3D, await, @export, @onready.
The main scene is res://scenes/main.tscn. Never edit anything under .godot/.
After a change, run: godot --headless --path . --quit-after 300
and fix every error it prints before saying the change is done.

What Cursor can and cannot do with Godot on its own

It can read and change every script and scene, rename a signal across twelve files, write a state machine for an enemy, and explain why a node path is null. With the rule above and your permission, it can boot the game headless and read the errors. That is a lot, and for a programmer it is most of what the search promised.

It cannot see the game or play it. It does not know the camera is pointing at the sky or that the jump feels floaty. It cannot press a key in your game. And it is guessing when it hand-edits a .tscn file, which carries resource IDs and UIDs the Godot editor would have written for it.

Cost: Cursor's Hobby plan is free with limited agent requests. Pro is $20 a month, Pro Plus $60 and Ultra $200, as of 29 Sep 2026. You can also bring your own OpenAI, Anthropic or Google key for chat models, under Cursor Settings, then Models. Godot is free.

Cursor plus a Godot MCP server lets it run the game

MCP is how Cursor is handed tools beyond files. A Godot MCP server runs the game for Cursor and hands back what Godot printed, so the agent fixes an error it saw rather than one you pasted. Cursor reads servers from mcp.json: ~/.cursor/mcp.json for every project, or .cursor/mcp.json inside one. You manage and switch them on and off from the Customize page. Cursor asks for approval before it uses an MCP tool unless you change that.

Coding-Solo's godot-mcp is free and MIT licensed: it launches the editor, runs the project in debug mode and captures the output, and creates scenes and nodes. Its README mentions no screenshots and no input. GDAI MCP, $19 once, and Godot MCP Pro, $15 once, plug into your own Godot editor and add screenshots and simulated input. All three work on a Godot project you already have. The detail is in the best Godot MCP server.

Connect Flockbay to Cursor and Cursor builds inside the Godot editor

Flockbay is a free AI game maker built on Godot: a desktop app that works with Godot 4.6+, with the official Godot inside, not a fork. Your game is a real Godot 4 project you can open, read and change, and Flockbay's scene changes go through the Godot editor the app hosts. Connecting Cursor to it is free, and it turns Cursor from a file editor into something that works on the running game.

In the Flockbay app, open your game, then Connectors from the Flockbay menu. Press Set up on the Connect your agent (MCP) row, press Turn on and pick Cursor. Press Add to Cursor and Cursor installs the server itself, or press Copy and add the block to ~/.cursor/mcp.json, which on Windows is %USERPROFILE%.cursor\mcp.json. It is one server, flockbay. Install skills and hooks, in the same place, gives Cursor Flockbay's instructions and a hook that asks it to play the game before it calls a change done.

The Flockbay app writes this for you with the real paths filled in: open Connectors, press Set up on Connect your agent (MCP), press Turn on, pick Cursor and press Copy. The three paths are specific to your machine and stay the same from one sitting to the next, so you paste it once. Below is the shape, with the paths as placeholders.

{
  "mcpServers": {
    "flockbay": {
      "command": "<node>",
      "args": [
        "<coordinator>",
        "--external-stage-mcp"
      ],
      "env": {
        "FLOCKBAY_MCP_DESCRIPTOR": "<descriptor>"
      }
    }
  }
}

What Cursor can do with Flockbay connected

Edit through the Godot editor with undo. Adding a node, setting a property, writing a script, connecting a signal: each change is one step in Godot's own undo history, so Ctrl+Z in the editor takes it back.

Run the game and read it. Cursor plays the game in the app's Game screen and reads its stdout, with every error's file, line and call stack. It can also do a headless run to check that it starts.

Playtest. It injects timed input events (keys, mouse motion, InputMap actions) into the running game, reads values off the live scene tree such as the player's velocity, and captures the game and editor viewports. Your real keyboard and mouse are never touched, and pressing a key yourself stops its input at once.

Build the scenes. It adds, moves and duplicates nodes, instances scenes and saves them through the editor, rather than hand-writing .tscn text. It can search Flockbay's library of models, textures and sounds and import one under res://, and generate a placeholder picture, sound or music to swap for your own later. Terrain, water and a sky come from a Godot plugin, the same as in any Godot project.

You still judge the result. Press Play or F5 in the editor and play it; its numbers say what happened, not whether it was fun. Its work shows in the app in a chat named Your agent.

Cursor playtests the game through Flockbay, and where that stops

Connected to Flockbay, Cursor closes the agent loop on the running game, not only on the code. It validates every GDScript file without running it, starts a Play or a headless run, injects a timed sequence of input events (keys, mouse, InputMap actions, up to 200 steps), captures the game viewport, and reads the live scene tree, stdout and the debugger's errors with file, line and stack. Then it changes the code and plays again. Flockbay's own AI runs that check, play, read, fix loop by itself; your own agent gets the same tool calls over MCP, free.

What it does not do: play a whole game through to a goal, return a pass or fail verdict, keep a regression suite, record video, file bug reports, run parallel instances, or judge balance and feel. Human playtesters still decide whether the game is fun.

Where Flockbay is the wrong Cursor for Godot

The connection reaches the game Flockbay has open, which can be a Godot project you already have: Flockbay asks before it adds anything to it. To keep your existing project in your existing editor, Cursor with one of the servers above is the better setup.

The Flockbay app runs on Windows, macOS and Linux. It needs an internet connection to build; the game plays offline. New code is GDScript, or C# when the game already uses it. Flockbay is closed source.

If you want Flockbay's own chat instead of Cursor's, it runs free on Flockbay's hosted AI every day, or on your Claude plan, a ChatGPT sign-in on any plan, Free included, or your own API key. What Flockbay costs has the detail.

Summer Engine is the other Cursor for Godot

Summer Engine describes itself as a Cursor-like editor built around AI that opens your existing Godot 4 project. It is a desktop app for macOS on Apple silicon and Windows, built on Godot 4.7.2, and its own site calls it a fully custom engine with more than a million lines of custom code.

It also ships a free, MIT-licensed MCP server for Cursor and other agents, installed with npx -y summer-engine@latest setup cursor --yes. Its page says an outside agent can run the game, read its errors, send it input and take screenshots; the tools drive the Summer Engine app, which has to be open with the project loaded. Its plans are $20, $60 and $200 a month, and connecting over MCP is free. Our side-by-side is Flockbay vs Summer Engine.

Troubleshooting Cursor with Godot

No completions in GDScript. godot-tools gets them from the Godot editor's language server, so Godot has to be running with the project open. Check that the port in the extension's settings matches Godot's, 6005 by default.

The MCP server does not appear. Open the Customize page and check it is listed and switched on. If you edited mcp.json by hand, check it is valid JSON, and that it is the global file or the one in the folder Cursor has open.

Flockbay's server lists a single tool. The Flockbay app is not serving Cursor yet: open the app, open your game, and turn on Connect your agent (MCP) in Connectors. The tools then appear by themselves; if they do not, start a new chat in Cursor.

Cursor keeps asking before each tool. That is Cursor's default for MCP tools. Its run modes decide what runs without asking.

A change you cannot see in the game. Stop the game and press Play again; a running game does not reload a change on its own.

Cursor for Godot: the routes side by side

Read from each product's own pages on 2026-09-29.

Tool	What the AI reaches	Runs and playtests the game	Your existing Godot project	Cost	Runs on
Cursor alone	Your project's files	No; you run it in Godot, or it boots it headless if you allow	Yes	Hobby free with limited agent requests; Pro $20, Pro Plus $60, Ultra $200 a month	Windows, macOS, Linux
Cursor + Coding-Solo godot-mcp	Files, plus scenes and nodes through Godot	Runs it and captures debug output; no screenshots or input in its README	Yes	Free, MIT	Wherever Godot and Node.js 18+ run
Cursor + GDAI MCP	Scenes, nodes, scripts and resources in your editor	Logs and errors, screenshots, simulated input	Yes	$19 once	Godot 4.2+ on Windows, macOS, Linux
Cursor + Godot MCP Pro	The Godot 4 editor, 187 tools	Runtime inspection, screenshots, input simulation	Yes	$15 once	Godot 4.4+ on Windows, macOS, Linux
Summer Engine, and its MCP for Cursor	Its own AI editor on Godot 4.7.2; its MCP drives the open app	Stated: runs it, reads errors, sends input, takes screenshots	Stated: opens your existing Godot 4 project	Free app; MCP free; plans $20, $60, $200 a month	macOS on Apple silicon, Windows
Cursor + Flockbay	The Godot editor inside the Flockbay app, the running game, the scene tools and the object library	Yes: errors with file and line, pictures, keys and mouse	Yes: Open Godot project…, and it asks before adding anything	Free	Windows, macOS (Apple Silicon) and Linux

Sources: Cursor alone: Cursor pricing, Cursor plans, Cursor downloads; Cursor + Coding-Solo godot-mcp: godot-mcp README; Cursor + GDAI MCP: GDAI MCP; Cursor + Godot MCP Pro: Godot MCP Pro; Summer Engine, and its MCP for Cursor: Summer Engine: Cursor for Godot, Summer Engine MCP, Summer Engine pricing; Cursor + Flockbay: Connect your own agent, Pricing.

When another route beats Flockbay

An existing Godot project you want to keep in your own editor: Cursor with GDAI MCP or Godot MCP Pro, or with Coding-Solo's server for free.

An Intel Mac: any of the Cursor routes. The Mac build of the Flockbay app is for Apple Silicon.

Code only, no running game needed: Cursor alone. It is the cheapest route and nothing else to install.

Questions

Is there a Cursor for Godot?

Cursor itself works on Godot projects: open the folder and its agent edits GDScript and scenes. To let it run and play the game, connect a Godot MCP server. Summer Engine and Flockbay are AI tools built on Godot that go further, each in its own app.

Is Flockbay a Godot editor plugin?

No. It is a desktop app for Windows, macOS and Linux that works with Godot 4.6+, with its own copy of Godot, and the Godot editor runs inside that app. It does not install into a Godot you already have.

Can Cursor run my Godot game?

Not on its own, beyond booting it headless from the terminal. With a Godot MCP server it can run the game and read its errors, and with Flockbay connected it can also play input into it and take pictures of it.

Does connecting Cursor to Flockbay cost anything?

No. You pay for Cursor on your own plan; Flockbay charges nothing for the connection.

Can I open a Flockbay project in the normal Godot editor or in Cursor?

Yes. It is an ordinary Godot 4 project in a folder you chose, so Cursor opens it like any codebase and Godot opens it like any project.

Does it write GDScript or C#?

Both. New code is GDScript unless your game is already C# or you ask for C#, and Flockbay downloads the .NET tools the first time a game uses C#.

What should a Cursor rule for Godot say?

The Godot version, that scripts are typed GDScript with Godot 4 names, where the main scene is, to leave the .godot folder alone, and a headless run to check its work. Keep it short.

Download Flockbay free: A free AI game maker built on Godot, for Windows, macOS and Linux. Connecting Cursor is free. https://flockbay.com/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

How to make games in Claude Code: from install to a game you can play

Ed Orellana — Sat, 07 Nov 2026 18:00:03 +0000

To make games in Claude Code, give it an engine it can run as well as edit. With Flockbay, that is one line pasted into PowerShell: Claude Code then builds a real Godot 4 game inside the Godot editor, plays it, reads its errors and looks at it, and you press Play to judge it. Connecting it is free on the Claude plan you already have. Flockbay is free, AI included: free hosted AI every day, or your own Claude, ChatGPT, agent or API key. It runs on Windows, macOS and Linux, on the official Godot engine.

Source: https://flockbay.com/how-to-make-games-in-claude-code/ · Updated 2026-11-03

As of 1 Oct 2026, on Windows: install Flockbay, open a game, then Connectors, Connect your agent (MCP), Set up, Turn on, Claude Code, Copy. Paste the line into PowerShell, run claude, ask for one change, and press Play. Or skip the terminal: pick Claude in Flockbay's model menu. Troubleshooting, limits and cost are below.

How to make games in Claude Code without pasting errors back

Claude Code can already make a game from an empty folder. Ask for a platformer and it will write a player script, a level scene and an input map. What it cannot do on its own is press Play. So the usual first evening goes like this: Claude writes, you run the game, the player falls through the floor, you copy the error into the terminal, Claude fixes it, and you run it again. You become the part of the loop that can see.

Flockbay takes that job back. It is a free AI game maker built on Godot: a desktop app that works with Godot 4.6+, with the official Godot inside, not a fork, where your game is a real Godot 4 project you can open, read and change in the Godot editor the app hosts. It hands Claude Code the tools to work on the running game, over MCP, the protocol Claude Code already uses for tools. Claude plays the game, reads what broke, looks at it, and fixes it before it tells you it is done.

This page walks the whole way, from install to a game you can play, then covers the problems people hit. For the other ways to use Claude with Godot, without Flockbay, and how they compare, read Claude for Godot.

Since Flockbay 2.0 there are two ways to do it. Claude Code can run inside Flockbay: pick Claude in the model menu, and Flockbay runs it on your Claude plan behind its own chat, with the tools already connected and nothing to paste; the docs page Build with your Claude plan, linked below, covers that way. Or Claude Code stays in your own terminal and connects over MCP, which is what the steps below walk through.

What you need before you start

A 64-bit Windows 11 PC on an Intel or AMD processor, a Mac with Apple Silicon, or an x86_64 Linux machine, where the app is an AppImage.

Claude Code, on a paid Claude plan (Pro, Max, Team or Enterprise) or an Anthropic Console account billed per use. The free claude.ai plan does not include Claude Code. On Windows, install it from PowerShell with irm https://claude.ai/install.ps1 | iex, or with winget install Anthropic.ClaudeCode.

An internet connection, because building comes over the network. A Flockbay account, which the app makes on first launch, with no sign-up. You do not need Godot installed: the app brings its own.

Step 1: install Flockbay and open a game

Download Flockbay from flockbay.com and run the installer. It installs for your user account, so it needs no administrator, and it sets up Microsoft's WebView2 if your PC lacks it.

Open the app and type the game you want in one sentence, such as "a small 3D island where you collect shells before the tide comes in". The app reads the sentence, shows what it understood on one card, 2D or 3D and where the game will be saved, and you press Continue.

The game opens in the Godot editor, inside the app: the chat on the left, your scene in Godot's 3D or 2D view, and the Game screen one tab away. Leave it open. Claude Code works on the game the app has open.

Step 2: connect your agent and copy the line

Open Connectors from the Flockbay menu and press Set up on the Connect your agent (MCP) row. Press Turn on, pick Claude Code and press Copy. The account menu's MCP connection item opens the same dialog.

Press Install skills and hooks while you are there. It puts Flockbay's instructions for your agent into Claude Code, and hooks: one checks that a script Claude edits still parses, another asks Claude to play the game before it says a change works.

Step 3: paste the line into PowerShell

The Flockbay app writes this for you with the real paths filled in: open Connectors, press Set up on Connect your agent (MCP), press Turn on, pick Claude Code and press Copy. The three paths are specific to your machine and stay the same from one sitting to the next, so you paste it once. Below is the shape, with the paths as placeholders.

Paste it into PowerShell or Command Prompt and press Enter. It registers one MCP server, flockbay, with --scope user, so Claude Code finds it from any folder, not only the one you pasted in. The connection stays on until you turn it off, and the app opens it again for whichever game you open next, so you paste it once.

When you press Turn on, the app runs the same line itself. If it could not start on your machine, the dialog says so in red, with the reason. On Windows you can skip the paste: the Flockbay plugin registers the same server with claude plugin marketplace add flockbay/flockbay-plugin, then claude plugin install flockbay@flockbay.

claude mcp add --scope user flockbay -e "FLOCKBAY_MCP_DESCRIPTOR=<descriptor>" -- "<node>" "<coordinator>" --external-stage-mcp

Step 4: start Claude Code in your game's folder

Open a terminal in your game's folder. The card in step 1 showed where it is saved, usually Documents\Flockbay and the game's name. Type claude.

Type /mcp. You should see flockbay, connected. Starting in the game's folder is not required for the tools, but it lets Claude read the project's files directly too, which helps when it is tracing a bug.

Step 5: the first prompt asks, the second one changes

Make the first prompt a question: "Look at this game and tell me what is in it: the main scene, the player, the controls, and what happens when I press Play." Claude reads the project, checks the editor and the running game, and answers. If the summary is wrong, fix that before anything else.

Then ask for one change with a way to check it: "Add a double jump. The second jump should be a little lower than the first. Play the game, jump twice, and tell me how high each jump went." A change with a number to check is a change Claude can test. "Make it better" is not.

If the game is still only a sentence, start with a brief, not a build. Ask Claude to write down what gets built first, what comes after and what is not in this version, and approve it before anything is built. That is how Flockbay's own AI works, and Claude builds the scenes as well as the code from it.

Keep to one mechanic per prompt. The people who make a game this way ask for the jump, play it, then ask for the coins. The people who paste a forty-line design into the first message get a lot of plausible code and nothing that plays.

If you build with a game-skill repo such as Claude Code Game Studios or godogen, put its agents and skills in the game's folder and start Claude Code there: they bring the process, and Flockbay's tools let them run and play the game. Running them in a live Godot editor shows one real run of each, with every tool call.

Step 6: what Claude Code does with Flockbay's tools

It edits through the open Godot editor. Adding a node, changing a property, writing a script, connecting a signal: each change is one step in Godot's own undo history, named for what it did, and the scene is saved after it. Press Ctrl+Z in the editor and the change is gone, the same as one of yours.

It checks before it plays. A script it writes comes back with Godot's own GDScript parse error and line if there is one, and it can do a headless run for a few seconds of game time to see it start and read stdout.

It runs the game and reads the errors. Playing starts the game in the Game screen, as your Play does, and reports stdout and every error and warning with its file, line and call stack.

It playtests. It injects timed input events (keys, mouse motion, InputMap actions) into the running game, reads values off the live scene tree, such as how high the player went, and captures the game viewport as the player sees it, or the editor's viewport. Your real mouse and keyboard are never touched, and the moment you press something yourself its input stops and the game is yours.

It builds the scenes through the editor rather than hand-writing .tscn text: nodes, scene instances, scripts, resources and signals, each real in the scene tree. Terrain, water or a sky come from a Godot plugin, as in any Godot project. It can also search Flockbay's library of ready-made models, textures and sounds and import one under res://, generate placeholder sound effects, loops and music to swap for your own, and generate a 3D model on your own Tripo key.

Every step shows in the app, in a chat named Your agent, so you can see what it did without reading the terminal.

Step 7: press Play and judge it yourself

Press Play on the Game screen, or F5 anywhere in the editor; F8 stops. The game runs on the bundled Godot, on your machine, with nothing streamed.

Claude can tell you the second jump reached 2.6 metres. It cannot tell you the jump feels floaty or that the level is dull. That part is yours, and it is the part that decides whether the game is good.

Step 8: the next prompt starts from what you saw

Say what was wrong in terms of what you saw and felt: "The second jump is too high and the fall is slow. Make the fall faster than the rise, then play it and tell me the air time." Claude changes it, plays it and reports numbers. You play again.

Make the taste calls by hand when that is quicker. Claude built the room; exactly where the crate sits, or which way the path bends, is one drag with Godot's own Move tool in the editor's view. Ctrl+Z takes it back, and Claude sees the result on its next look. A sentence gets you a layout; your hand can get you the exact layout. Commit to git between sessions; the editor's undo covers a step, version control covers an afternoon.

Claude Code playtests the game through Flockbay, and where that stops

Connected to Flockbay, Claude Code closes the agent loop on the running game, not only on the code. It validates every GDScript file without running it, starts a Play or a headless run, injects a timed sequence of input events (keys, mouse, InputMap actions, up to 200 steps), captures the game viewport, and reads the live scene tree, stdout and the debugger's errors with file, line and stack. Then it changes the code and plays again. Flockbay's own AI runs that check, play, read, fix loop by itself; your own agent gets the same tool calls over MCP, free.

Troubleshooting Claude Code with Flockbay

The line on Windows. Paste it into PowerShell or Command Prompt as it is; both pass it through unchanged, and the quotes are there because the paths contain spaces. Run claude mcp get flockbay: it should say Connected. If it says Failed to connect, go back to the dialog. If the app could not start the line, the dialog says why in red. If you reinstalled Flockbay since you pasted it, copy the line again.

The server is missing in one folder. An older line registered the server for the folder you pasted it in. Run claude mcp remove flockbay, then paste the current line, which carries --scope user.

Only one Flockbay tool appears. The app is not serving Claude yet. Open the Flockbay app, open your game, and check that Connect your agent (MCP) is on in Connectors. The tools then appear in the same session by themselves. If they do not, start a new Claude Code session.

Permissions. Claude Code asks before it calls a tool from a new MCP server. Answer yes as it goes, or open /permissions and add an allow rule for mcp__flockbay, which covers every tool on that server.

The editor is not open. The tools that change scenes and scripts work through the Godot editor inside the Flockbay app, so the game has to be open there. Open it from the app's home screen. The tools that play the game need it running; Claude starts it itself.

Claude is told to wait. Flockbay's own AI is working in the same game, so Claude is told so and waits for its turn to finish.

A change you cannot see. If Claude reports a change and the running game looks the same, the game has not reloaded it. Stop it and press Play again.

What Claude Code cannot do here

It cannot tell you whether the game is fun. Pictures and numbers show what happened, not how it felt.

It works on the game Flockbay has open. That can be a Godot project you already have: Flockbay asks once before it adds anything to it, and Claude works there with the same Godot tools as in a game made in Flockbay, or with fewer if you keep the project on an older Godot. If you want Claude in your own Godot editor instead, Claude for Godot compares the servers for that.

It needs Windows, macOS or Linux, and an internet connection while you build; playing what you built does not. New code is GDScript, or C# when the game already uses it. Flockbay is closed source; the engine is Godot and the project is yours.

What making games in Claude Code costs

Connecting Claude Code to Flockbay is free. You pay Anthropic for Claude, on the plan you already have: Pro is $20 a month, or $17 billed yearly, and Max starts at $100 a month, as of 29 Sep 2026. Flockbay charges nothing for the connection, and building in it is free. What is free in each AI game maker compares the other routes.

Generated art is optional. Without keys, Claude builds from Flockbay's library or with Godot's own shapes, and sound effects, loops and music are generated on Flockbay's free daily allowance. With your own Tripo key, or a key for pictures, it generates on that key and you pay that provider.

If you would rather not keep a terminal open, Claude Code runs inside Flockbay on the same Claude plan: pick Claude in the model menu. The other free ways are a ChatGPT sign-in on any plan, Free included, or your own API key. Plans for more hosted AI are optional. What Flockbay costs has the detail.

Questions

Can Claude Code make a game on its own?

It can write one, and with Flockbay connected it can run it, read its errors, look at it and play input into it, so it fixes what breaks before handing it back. It cannot judge whether the game is fun. You play it and say what to change.

Do I need to know Godot to make games in Claude Code?

No. Claude works in Godot for you, scenes included, and Godot's editor is open beside it for the parts you want to do by hand. Knowing Godot helps you read what it did, and the project is a real Godot 4 project if you want to.

Does connecting Claude Code to Flockbay cost anything?

No. You pay Anthropic for Claude on your own plan. Flockbay charges nothing for the connection.

Is there an official Claude Code integration?

Nothing made with Anthropic. Flockbay runs Claude Code as Anthropic publishes it, inside the app or from your terminal, and gives it tools over MCP, a shared protocol. On Windows, Flockbay's own Claude Code plugin registers the server in one command: claude plugin marketplace add flockbay/flockbay-plugin, then claude plugin install flockbay@flockbay.

Does it work on a Mac?

Yes, on a Mac with Apple Silicon. The Flockbay app is on Windows, macOS and Linux, and on a Mac it serves the same MCP server, with Claude in the app and the full editor.

Can I use Claude Code on a Godot project I already have?

Yes. Open it in Flockbay with Open Godot project: Flockbay asks before it adds anything, and Claude can edit, run and playtest it. Or use Claude Code on its own, or with a Godot MCP server that plugs into your own editor.

Why does the line have my own paths in it?

It starts a program inside your Flockbay installation, so it names where that program is on your machine. That is why you copy it from the app rather than type it.

Download Flockbay free: A free AI game maker built on Godot, for Windows, macOS and Linux. Connecting Claude Code is free. https://flockbay.com/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Claude Code for Godot in 2026: connect it to your game, and what it builds

Ed Orellana — Sat, 07 Nov 2026 17:59:27 +0000

To use Claude Code with Godot, give it a way to run the game it edits: Flockbay runs Claude Code on your own Claude plan inside its app, or your own Claude Code connects to Flockbay's MCP server, free either way, and Claude builds in the Godot editor and playtests the game. Without Flockbay, Claude Code still edits your project's files from a terminal, and a Godot MCP server such as Coding-Solo's godot-mcp lets it run the game and read the errors. This guide covers every way to connect Claude Code to Godot, with the exact steps, what Claude can and cannot do in each, and what each costs, as of 24 Oct 2026. Flockbay is free, AI included: free hosted AI every day, or your own Claude, ChatGPT, agent or API key. It runs on Windows, macOS and Linux, on the official Godot engine.

Source: https://flockbay.com/blog/claude-for-godot/ · Updated 2026-11-02

Claude Code on Godot works until the game has to run

Ask Claude Code for a double jump in a Godot platformer and you get a tidy script back: a jump counter, a reset when the player lands, the second jump a little weaker than the first. It reads well. You press F5 and the player jumps once, because the counter resets on the same frame the first jump leaves the ground. Claude never saw that happen. It wrote the code and stopped.

That gap is the whole story of Claude and Godot. Claude writes GDScript well, it knows the engine's node types, and it reads a scene file without trouble. What separates the four setups below is how much of the running game Claude can see: none of it, its errors, or its errors plus pictures and the keys you would press.

Every setup starts from the same place. A Godot 4 project is a folder of text files: project.godot, scenes as .tscn, resources as .tres, scripts as .gd. Anything that can edit files can edit a Godot game. The question is what happens after the edit.

We make Flockbay, and two of the ways below are ours: Claude Code on your Claude plan inside the Flockbay app, and your own Claude Code connected to Flockbay over MCP. The others need nothing from us.

Way 1: Claude Code on your Godot project folder

Claude Code is Anthropic's coding agent. It runs in a terminal, or in the Code tab of the Claude desktop app, and works on the files in the folder you start it in. It needs a paid Claude plan (Pro, Max, Team or Enterprise) or an Anthropic Console account billed per use; the free claude.ai plan does not include it.

On Windows, install it from PowerShell with the line below. Anthropic also lists winget install Anthropic.ClaudeCode and an npm package. Then open a terminal in the folder that holds project.godot, type claude, and sign in when it asks.

Start with a question rather than a change: ask Claude to describe the project in five sentences, name the main scene and list the autoloads. If the summary is wrong, the changes will be too. Then ask for one change at a time, each with a way to check it.

# PowerShell, once
irm https://claude.ai/install.ps1 | iex

# then, in the folder that holds project.godot
cd "C:\path\to\your-game"
claude

A CLAUDE.md file tells Claude Code it is working on Godot 4

Claude Code reads a file called CLAUDE.md at the root of the folder before it starts. Put the facts it would otherwise guess there: the Godot version, that scripts are GDScript with static types, where the main scene lives, and that the .godot folder is Godot's own cache and never to be edited.

The most useful line is a check it can run itself. Godot's command line can do a headless run of your game and quit after a set number of frames, printing every error to stdout. If Godot is on your PATH, Claude can run that after each change and read what broke. On Windows, point it at the console build of Godot, the executable whose name ends in _console.exe, so the output reaches the terminal.

That one line is most of the difference between Claude writing code and Claude checking code. It still is not the same as playing: a headless boot tells you the script parses and the scene loads, not that the jump works.

# CLAUDE.md
This is a Godot 4.7 project. Scripts are GDScript with static types.
The main scene is res://scenes/main.tscn. Never edit anything under .godot/.
After changing a script or a scene, run:
  godot --headless --path . --quit-after 300
and fix every error it prints before saying the change is done.

What Claude Code can and cannot do on a Godot folder alone

It can read and write every script, scene and resource, rename things across files, add input actions to project.godot, and chase a bug through three scripts faster than you would. With your permission it can run Godot from the terminal, as above, and read the errors.

It cannot see the game. It does not know the player clips through the floor, that the camera is pointing at the sky, or that the UI covers the score. It cannot press a key in your game or look at the editor. Scene files are text, but they carry resource IDs and UIDs that are easy to get subtly wrong by hand, and Claude editing a .tscn is guessing at what the editor would have written.

One trap catches everyone once. If a script is open in the Godot editor while Claude changes it on disk, Godot notices and asks whether to reload it. Answer Reload. Saving the editor's copy writes the old text back over Claude's change.

Cost: nothing beyond your Claude plan. Pro is $20 a month, or $17 a month billed yearly; Max starts at $100 a month. Godot itself is free.

Way 2: Claude Code plus a Godot MCP server

MCP, the Model Context Protocol, is how an agent is handed tools beyond reading and writing files. A Godot MCP server is a small program that sits between Claude and Godot: Claude asks it to run the game, and it runs the game and hands back what Godot printed. This is the setup that closes the loop between writing code and seeing it fail.

The free one most people start with is Coding-Solo's godot-mcp, MIT licensed, about 5,900 stars on GitHub. It launches the editor, runs the project in debug mode and captures its output, stops it, creates scenes, adds nodes, loads sprites and saves scenes. Its README mentions no screenshots and no simulated input. It needs Node.js 18 or later and finds Godot by itself, or through a GODOT_PATH variable. One line registers it with Claude Code.

Two paid servers plug into the Godot editor you already use. GDAI MCP is $19 once: it edits scenes, nodes, scripts and resources, reads logs and debugger errors, takes screenshots of the editor and the running game, and injects key and input-action events into the running game, on Godot 4.2 and later. Godot MCP Pro is $15 once and lists 187 tools on its own site, including screenshots, input simulation and inspecting the running game, on Godot 4.4 and later.

Summer Engine, a desktop app built on Godot, ships a free, MIT-licensed MCP server too. Its page says an outside agent can run the game, collect its errors, send it input, take screenshots, and edit scenes and scripts. Those tools drive the Summer Engine app rather than a plain Godot editor, so the app has to be open with the project loaded.

After adding any server, type /mcp inside Claude Code. It lists each server and whether it connected. The comparison of the servers themselves, tool by tool, is in the best Godot MCP server.

claude mcp add godot -- npx @coding-solo/godot-mcp

Way 2 with Flockbay: Claude Code builds inside the Godot editor

Flockbay is a free AI game maker built on Godot: a desktop app that works with Godot 4.6+, with the official Godot inside, not a fork, where your game is a real Godot 4 project you can open, read and change. It hands your own agent its tools over MCP, and connecting one is free. You need the app open with your game, and a free Flockbay account, which the app makes on first launch.

In the Flockbay app, open Connectors from the Flockbay menu, press Set up on the Connect your agent (MCP) row, press Turn on, pick Claude Code and press Copy. Paste the line into PowerShell. It registers one server, flockbay, for your user, so Claude Code finds it from any folder. The app writes the line with your machine's own paths filled in; the shape is below. Beside Copy, Install skills and hooks puts Flockbay's instructions into Claude Code, and hooks that check a script parses after Claude edits it and ask Claude to play the game before it says a change works.

What Claude gets is the running game, not only its files. It edits scenes, nodes, scripts, resources and signals through the open Godot editor, and each change is one step in Godot's own undo history, so Ctrl+Z takes it back like your own. It plays the game and reads stdout, with each error's file, line and call stack. It captures the game viewport as the player sees it and the editor's 3D or 2D viewport. It injects timed key and mouse events into the game, and reads and changes the live scene tree while it runs.

It also gets the scene tools, which create scenes and add, move and set nodes through the open editor, and the object library, which imports a ready-made model into the project. Those are whole operations Claude calls rather than writes, so a row of houses is a few requests instead of four hundred lines of mesh code. Its work shows in the app in its own chat, named Your agent.

The limits are plain. The Flockbay app runs on Windows, macOS and Linux. It needs an internet connection while you build. It works on the game the app has open, which can be a Godot project you already have: Flockbay asks before it adds anything to it. Flockbay is closed source. The full walk from install to a playable game is in how to make games in Claude Code.

claude mcp add --scope user flockbay -e "FLOCKBAY_MCP_DESCRIPTOR=<descriptor>" -- "<node>" "<coordinator>" --external-stage-mcp

Way 3: Claude Desktop runs Claude Code in its Code tab, and a Godot MCP server in Chat

The Claude desktop app, on Windows and macOS, has two doors. The Code tab is Claude Code itself, with nothing else to install: everything in Way 1 and Way 2 applies there. The Chat tab is Claude as a chat, which reaches your game only through the MCP servers you give it.

To add a server to Chat, open Settings, then Developer, then Edit Config. That opens claude_desktop_config.json, which on Windows lives at %APPDATA%\Claude\claude_desktop_config.json. Add the server under mcpServers, save, then quit Claude Desktop completely and start it again. The server then appears under Connectors in the menu at the bottom left of the message box. Some servers also come as Desktop Extensions, .mcpb files installed from Settings, then Extensions.

Chat suits asking questions about a scene or getting Claude to run the game and explain an error. It is a poor fit for writing a game, because it only touches what the server exposes: with a run-and-read server and no file access, it can describe a fix but not make it. Use the Code tab for the building.

The Flockbay app's setup dialog does not list Claude Desktop. The block it gives for Cursor is the same mcpServers shape Claude Desktop reads, but we have not tried it there, so treat that as untested.

{
  "mcpServers": {
    "godot": {
      "command": "npx",
      "args": [
        "@coding-solo/godot-mcp"
      ]
    }
  }
}

Way 4: Claude Code inside Flockbay's Godot editor, on your Claude plan

The last way needs no terminal. In the Flockbay app you pick Claude in the model menu, and Flockbay runs Claude Code on your Claude Pro or Max plan behind its own chat, beside the Godot editor. On Windows Claude Code comes with the app, on a Mac it uses the one you installed or installs it with Homebrew, on Linux it uses the one you installed, you sign in on Anthropic's page, and the menu lists the models and effort levels Claude Code gives your account. Nothing is pasted, and Flockbay charges nothing for it. It is on Windows, macOS and Linux.

It works on the same tools as Way 2, and more. It asks one round of questions at a time, writes a short brief of what it will build first, and builds only after you approve it. Then it builds the scenes, writes the code, playtests the game. It generates pictures and sound; 3D models are generated on your own Tripo key. Godot's own editor is there in the Standard and Full views for the calls you would rather make by hand, with Godot's undo.

Another way runs Claude models inside the app: your own Anthropic API key, added in Connectors and billed by that provider for what you use. Every account also gets free AI each day on the hosted model, called Demo, which is not a Claude model. Plans for more hosted AI are optional.

What every Claude Code and Godot setup still leaves to you

Even the setup that playtests the game and captures the viewport cannot tell you whether the game is good. Claude can read the player's jump height and report that it went from 0 to 4.2 metres. It cannot tell you the jump feels floaty, that the camera makes you queasy, or that the second level is boring. A picture shows a frame, and feel lives between frames.

So the loop that works is short: one change, Claude checks it as far as its tools reach, you play it, you say what is wrong. People who hand Claude a forty-line design document and wait for a finished game get a pile of plausible code. People who ask for one mechanic, play it and ask for the next get a game.

Commit to git before each session in any setup. Undo in the editor covers one change; version control covers a bad afternoon.

Which Claude Code and Godot setup to pick

You write code and want Claude as a fast pair of hands on a project you already have: Way 1, then add Coding-Solo's server the first time you catch yourself pasting an error back.

You want Claude to test its own work on an existing project: Way 2 with GDAI MCP or Godot MCP Pro, which reach the running game in your own Godot editor.

You are starting a new game and want Claude to build the scenes as well as the code, with Godot's own editor for the calls you make by hand: Way 2 with the Flockbay app, free on the Claude plan you already pay for, on Windows, macOS or Linux.

You do not want a terminal at all: Way 4, on the Claude plan you already pay for.

You are on an Intel Mac: Ways 1 to 3 with any of the servers above. The Flockbay app runs on Windows, on Macs with Apple Silicon and on Linux.

Claude Code for Godot costs nothing on top of a Claude plan, as of 24 Oct 2026

Godot is free. Claude Code needs Claude Pro ($20 a month, or $17 billed yearly), Max (from $100), Team, Enterprise, or pay-as-you-go API credits through a Console account.

On top of that: Coding-Solo's godot-mcp is free. GDAI MCP is $19 once and Godot MCP Pro $15 once. Summer Engine's MCP server is free, and its plans are $20, $60 and $200 a month. The Flockbay app is free: free hosted AI every day, or your own Claude or ChatGPT plan, your own agent or your own API key. Its optional plans for more hosted AI are Hobby $20, Indie Developer $60 and Studio $200 a month.

The honest summary: if you already pay for Claude, you can have Claude run and test a Godot game without spending another dollar.

Troubleshooting Claude Code with Godot

The server does not show up in Claude Code. Type /mcp. If it is missing, you registered it in a different folder: Claude Code's default scope is the folder you were in. Remove it with claude mcp remove and add it again with --scope user, which is what the Flockbay app's line already does.

The server shows as failed. Run claude mcp get with the server's name to see why. For an npx server, check node --version is 18 or later. For Claude Desktop, read the logs in %APPDATA%\Claude\logs, where each server writes its own file.

Flockbay's server connects but lists a single tool. The app is not serving your agent yet: open the Flockbay app, open your game, and turn on Connect your agent (MCP) in Connectors. The tools then appear by themselves. If they still do not, start a new Claude Code session.

Claude's change vanished. Godot's editor saved its older copy over it. Reload when Godot says a file changed on disk, and save in Godot before you ask Claude to edit a file you have open.

Every way to connect Claude Code to Godot, side by side

Read from each product's own pages on 2026-10-24.

Tool	What Claude reaches	Runs the game and reads errors	Captures the viewport and sends input	Cost on top of Claude	Runs on
Claude Code on the folder	Your project's files	Only if you let it run Godot in the terminal	No	Nothing	Windows, macOS, Linux
Claude Code + Coding-Solo godot-mcp	Files, plus scenes and nodes through Godot	Yes: runs in debug mode, captures output	Not in its README	Free, MIT	Wherever Godot and Node.js 18+ run
Claude Code + godot-ai	Your own Godot 4.7+ editor: 46 tools, 120+ operations	Yes: game and editor logs	Pictures of the editor and the running game; timed keys, mouse and gamepad	Free, MIT	Wherever Godot 4.7 and uv run
Claude Code + GoPeak	Files, with Godot's language server and debugger	Yes: an edit, run, inspect and fix loop	Through its runtime add-on	Free, MIT	Wherever Godot and Node.js run
Claude Code + satelliteoflove godot-mcp	Editor state and tile maps; files stay with Claude Code	Yes, and steps game time frame by frame	Pictures, and input riding inside each time step	Free, MIT	Godot 4.5+
Claude Code + GDAI MCP	Scenes, nodes, scripts and resources in your editor	Yes: logs and debugger errors	Screenshots and simulated input	$19 once	Godot 4.2+ on Windows, macOS, Linux
Claude Code + Godot MCP Pro	The Godot 4 editor, 187 tools	Yes: inspects the running game	Screenshots and input simulation	$15 once	Godot 4.4+ on Windows, macOS, Linux
Claude Code + Summer Engine's MCP	The Summer Engine app, open with the project loaded	Yes: runs it, collects errors and warnings	Screenshots and input to the running game	MCP free, MIT; plans $20, $60, $200 a month	macOS on Apple silicon, Windows
Claude Desktop (Chat) + a server	Only what the server exposes	If the server does	If the server does	The server's own price	Windows, macOS
Flockbay app + your Claude Code	The open Godot editor, the running game, the scene tools and the object library, in the game Flockbay has open	Yes, with file, line and call stack	Pictures of the game and the editor's view; keys and mouse	Free	Windows, macOS (Apple Silicon) and Linux
Flockbay app, Claude Code inside it	The same tools, from the app's chat	Yes	Yes	Free on your Claude Pro or Max plan	Windows, macOS (Apple Silicon) and Linux

Sources: Claude Code on the folder: Claude Code setup, Claude pricing; Claude Code + Coding-Solo godot-mcp: godot-mcp README; Claude Code + godot-ai: godot-ai README; Claude Code + GoPeak: GoPeak README; Claude Code + satelliteoflove godot-mcp: godot-mcp README; Claude Code + GDAI MCP: GDAI MCP; Claude Code + Godot MCP Pro: Godot MCP Pro; Claude Code + Summer Engine's MCP: Summer Engine MCP, Summer Engine pricing, Summer Engine download; Claude Desktop (Chat) + a server: Connect local MCP servers; Flockbay app + your Claude Code: Connect your own agent, Pricing; Flockbay app, Claude Code inside it: Pricing.

Where another setup is the better choice

A Godot project you want to keep in your own editor: GDAI MCP or Godot MCP Pro reach it there, and Coding-Solo's server does it free. Flockbay opens an existing project too, in the editor it hosts.

An Intel Mac: Claude Code with any of the servers. The Flockbay app's Mac build is for Apple Silicon.

No spending beyond Claude and no new app: Claude Code with Coding-Solo's godot-mcp.

Questions

How do I use Claude Code with Godot?

Install Claude Code, open a terminal in your Godot project's folder and type claude. That lets Claude read and edit your scripts and scenes. To let it run the game and read the errors too, add a Godot MCP server with claude mcp add. Or pick Claude in the Flockbay app's model menu, and Flockbay runs Claude Code on your Claude plan beside the Godot editor.

Is Claude good at GDScript?

Yes, for Godot 4 GDScript, especially when you tell it the Godot version and that you use static types. Its mistakes are rarely syntax; they are behaviour it could not see, which is why a setup that runs the game matters more than the model.

Can Claude run my Godot game and fix the bug itself?

With a Godot MCP server, yes: it runs the game, reads the error with its file and line, fixes it and runs it again. Without one, it can only boot the game headless from the terminal if you let it. No setup lets it judge whether the game feels right; that part is yours.

Is using Claude with Godot free?

Godot is free, and Coding-Solo's godot-mcp is free. Claude Code itself needs a paid Claude plan from $20 a month, or API credits. Connecting Claude Code to the Flockbay app is free on top of that.

Should I use Claude Code or Claude Desktop for Godot?

Claude Code, in a terminal or in the desktop app's Code tab, because it edits your files and runs commands. The Chat tab reaches your game only through an MCP server and suits questions more than building.

Does Claude need the Godot editor open?

Not for editing files. Servers that act inside the editor, such as GDAI MCP, Godot MCP Pro and the Flockbay app's tools, need it open; Coding-Solo's server launches Godot itself.

Which Claude models can I use in Flockbay?

On your Claude plan, the models Claude Code gives your account, inside the app or from your terminal. On your own Anthropic key, the Claude models that key reaches. Demo, Flockbay’s hosted model, is free each day and is not a Claude model.

Set up Claude Code with Flockbay: Flockbay is a free AI game maker built on Godot, for Windows, macOS and Linux. The step-by-step guide goes from install to a game you can play. https://flockbay.com/how-to-make-games-in-claude-code/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

What is a free AI game maker?

Ed Orellana — Fri, 06 Nov 2026 17:58:45 +0000

I make Flockbay, one of the tools below, so here is how I picked. Each of the other 7 was read on its own site or repository on 2026-11-02, the table at the end links the page behind every row, and every section says where another tool is the better pick than mine.

Flockbay is a free AI game maker built on Godot: the download, the editor and the AI are free, with free hosted AI every day or your own Claude, ChatGPT, agent or API key, and optional plans for more hosted AI. The others are free up to a point: a small monthly AI allowance, your own subscription, or export and commercial rights behind a plan, and Summer Engine charges for its hosted AI. The table below says where each free tier stops, read from each tool’s own pages.

Source: https://flockbay.com/free-ai-game-maker/ · Updated 2026-11-02

Free in an AI game maker means one thing: who pays for the tokens

Every tool in the table below gives you some of it for nothing, and every one of them has the same bill underneath: each tool call your agent makes and each GDScript file it writes is model inference, and inference costs money per token. A 3D model or a sound from a generator costs money per job. So when a page says free, the useful question is not whether, it is who pays that bill and on what terms.

There are three answers. The first is a credit allowance: the vendor pays for a small amount of inference, as a trial or a monthly allowance, then meters you. Ziva’s Hobby plan, GDevelop’s 40 AI credits a month and the 14-day trial of Unity’s AI tools on Personal all work this way. The second is export-gated free: you can build, but downloading the project, commercial rights or removing a watermark sit behind a plan. Rosebud puts project code download on a paid plan. The third is bring your own model: the tool costs nothing and the inference runs on an account you already have, so the only bill is the one you were paying anyway.

Flockbay is the third kind, and it is also the first: every account gets free hosted AI every day, marked Demo in the model menu. When a day’s free usage is spent, Hobby keeps you building, with usage every month, your own Claude or ChatGPT is free, or the allowance resets at 00:00 UTC. You can also build on the Claude or ChatGPT plan you already pay for, on your own agent or on your own key, and you pay that company, never Flockbay. Plans for more hosted AI are optional.

Flockbay is free: free hosted AI every day, or your own Claude, ChatGPT, agent or API key

Your Claude plan. Pick Claude in the model menu and Flockbay runs Claude Code, Anthropic’s coding agent, behind its own chat, on Claude Pro or Max. Claude Code ships inside the Windows app, and on a Mac Flockbay uses the one you installed or installs it with Homebrew. You sign in on Anthropic’s page. The free Claude plan does not include Claude Code, so it does not work. On Windows, macOS and Linux.

A ChatGPT sign-in. Flockbay’s chat can run on your ChatGPT account, on any plan, Free included, through the Codex engine that ships with the app. OpenAI sets how much each plan can use.

Your own agent over MCP. Claude Code, Codex, Cursor or any MCP client connects to Flockbay’s MCP server and drives the open Godot editor: scene edits with undo, running the game headless or in the Game screen, reading stdout and GDScript parse errors with file and line, injecting input events and capturing the viewport. Flockbay charges nothing for the connection; you pay your agent’s provider exactly what you pay them now. The Godot MCP guide has the setup for each client.

Your own API key (BYOK). Paste an OpenAI or Anthropic key and Flockbay’s own chat runs on it, billed by your provider per token. Generated pictures, 3D models and sound run on your own Tripo and ElevenLabs keys the same way.

Demo, Flockbay’s hosted AI. Every account, guests included, gets free hosted AI every day, and it resets at 00:00 UTC. When a day’s free usage is spent, Hobby keeps you building, with usage every month, your own Claude or ChatGPT is free, or you come back after the reset. Pictures and sound run on that free usage. A 3D model uses your own Tripo key.

What is free with no asterisk

The engine. Flockbay bundles the official Godot, not a fork, so stock Godot opens the same folder.

The project. It is a real Godot project on your disk: .tscn scenes, GDScript, your assets. There is no export gate, no watermark and no revenue share, and it keeps existing if you stop using Flockbay.

The editor. Flockbay builds the scenes, props and player controller, and Godot’s own 3D and 2D editor is there in the Standard and Full views, with the editor’s undo, for the calls you would rather make yourself. A change you make with them by hand makes no model call, so it costs nothing.

Playtesting. The game runs locally on the bundled Godot. Pressing Play, and the runs your agent starts to check its own work, cost nothing beyond the tokens the agent spends reading the results.

What free does not cover

Inference past the daily allowance. Flockbay pays for each day’s free usage on its hosted AI, which resets at 00:00 UTC. Past it, on your own Claude, ChatGPT, agent or API key, you pay that company; on a Flockbay plan, you pay Flockbay for more hosted AI.

Offline building. The chat, asset generation and world data come over the network, so building needs a connection. Playing the game you built does not.

Intel Macs. Flockbay runs on 64-bit Windows, Apple Silicon Macs and x86_64 Linux; on an Intel Mac, Ziva or the free Godot AI add-on with your own agent is the free route.

The app’s source. Flockbay is closed source. The engine is Godot and the project is yours; the app that builds it is ours.

What each AI game maker gives you free

Read from each product's own pages on 2026-11-02.

Tool	What it is	Free to start	Paid from	Your own model	Your project
Flockbay	AI game maker built on the official Godot; Godot 4.6+	Free hosted AI every day, or your own Claude or ChatGPT plan, agent or API key	Hobby $20, Indie Developer $60 and Studio $200 a month, for more hosted AI	Claude Pro or Max and any ChatGPT plan in the app, an agent over MCP, or an OpenAI or Anthropic key, all free from us	A Godot project on your disk; no export gate, watermark or revenue share
Ziva	AI agent inside the Godot editor	Hobby: $3 of AI to start, then 50 Ziva Baby messages a day	$20 a month (Basic)	Every plan can run on your own Claude Code or Codex subscription	Your stock Godot project
Summer Engine	AI game engine on its own build of a Godot 4.7.2 base	Free app: 5 AI messages a day, up to 30 a month; MCP free	$20 a month (Pro)	Not for its hosted AI; your own agent reaches it over MCP	Its docs say a project can go back to official Godot without the Summer-only AI features
Your agent + Godot AI	Free, MIT-licensed MCP server and editor add-on	Free; you pay your agent’s provider	Free	Whatever agent you run	Your own Godot 4.7 project
Your agent + GDAI MCP or Godot MCP Pro	Paid MCP servers and editor plugins	No free tier	$19 one-time (GDAI), $15 one-time (MCP Pro)	Whatever agent you run	Your own Godot project
Rosebud AI	AI game maker; Rosebud hosts the game	Newbie: free, 8,000 credits a week	$15 a month (Indie Dev)	Not stated on its pricing page	Commercial rights from the $30 plan; project code download on the $50 plan
Unity’s AI tools	In-editor assistant, AI gateway, MCP server and CLI, Unity 6 and later	Personal: a 14-day free trial	$10 a month for 1,000 credits (Personal)	The AI gateway runs a coding agent you already pay for, with no Unity credits	Your Unity project
GDevelop	No-code engine, open source (MIT), with an AI	40 AI credits a month	$7.99 a month (Silver)	Not stated on its pricing page	Your GDevelop project

Sources: Flockbay: Pricing, Your own agent; Ziva: Asset Store, Homepage; Summer Engine: Pricing, AI models, MCP, Godot migration; Your agent + Godot AI: GitHub; Your agent + GDAI MCP or Godot MCP Pro: GDAI MCP, Godot MCP Pro; Rosebud AI: Pricing; Unity’s AI tools: AI tools, Trial; GDevelop: Pricing.

Where another free route beats Flockbay

If you already pay for Claude Code, Codex or Cursor and want nothing new installed but an add-on, your agent plus the free Godot AI add-on is the cheapest route there is, on any desktop.

On an Intel Mac, Ziva’s free Hobby plan runs in stock Godot, and the Mac build of Flockbay is for Apple Silicon only.

If you never want to see code, GDevelop’s events and its 40 free AI credits a month are built for that person.

Questions

Is Flockbay really free?

Yes. Every account gets free hosted AI every day, marked Demo in the model menu. Claude Pro or Max, or any ChatGPT plan, Free included, also builds the game in the app, and your own agent over MCP or your own OpenAI or Anthropic key is free from us. Claude Free does not run here. Plans for more hosted AI are optional.

Does the free route expire?

No. It is not a trial. The free hosted AI is a daily allowance that resets every day at 00:00 UTC, and the app and your own model have no Flockbay time limit.

Does ChatGPT Free work?

Yes. A ChatGPT Free account signs in and builds, through the Codex engine that ships with the app. OpenAI sets how much each plan can use.

Is there a watermark, export fee or revenue share?

None. The game is a Godot project on your disk, and you can open it in stock Godot without Flockbay.

Which AI game maker is completely free?

None of them pays for your inference forever. The closest to zero is your own agent plus a free Godot MCP add-on, or Flockbay on your own agent, where the only bill is the model subscription you already have.

Do generated 3D models and sound cost extra?

Pictures and sound run on the free AI. A 3D model uses your own Tripo key. On your own keys, pictures run on a key you add, sound on ElevenLabs, and 3D models on Tripo.

Download Flockbay free: Free for Windows, macOS and Linux, AI included: free hosted AI every day, or your own Claude or ChatGPT plan, agent or API key. https://flockbay.com/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.

Summer Engine vs Ziva vs Flockbay: which Godot AI tool to pick in 2026

Ed Orellana — Fri, 06 Nov 2026 17:58:10 +0000

I make Flockbay, one of the tools below, so here is how I picked. Each of the other 2 was read on its own site or repository on 2026-10-13, the table at the end links the page behind every row, and every section says where another tool is the better pick than mine.

Pick Flockbay if you want the whole Godot game built and play-tested for free on the official engine, Ziva if you want an AI agent inside the Godot editor you already run, and Summer Engine if you want an AI-native engine of its own, with hosted AI at $20, $60 or $200 a month. Flockbay's AI is free every day, or runs on your own Claude or ChatGPT.

Source: https://flockbay.com/summer-engine-vs-ziva/ · Updated 2026-10-13

As of 13 Oct 2026. Ziva is a proprietary plugin for Godot 4.2 and later: free on your own Claude Code or Codex subscription, with hosted models from $20 a month on its site and its full Playtest Agent on Pro at $50. Summer Engine is a proprietary engine on a Godot 4.7.2 base: the app and its MCP server are free, and hosted AI is $20, $60 or $200 a month. Flockbay works with Godot 4.6+ and bundles the official Godot, and its AI is free. The two rivals disagree on whether Ziva can run the game; Ziva's own pages say it can.

Summer Engine and Ziva disagree about whether Ziva can play the game

On 6 June 2026, Summer Engine published its comparison with Ziva. Its sharpest line is about the running game. Ziva, it says, "cannot play the game and it cannot read what the running game printed, because it does not run the game." The verdict follows from that line: "Choose Summer Engine if you want the AI to run the game and debug it, not just edit it."

Read Ziva's own pages on 13 October and they say the opposite. Its playtesting docs say Ziva "opens it in the Game tab, can send input, captures the final screen, and reads runtime errors." Its listing on the official Godot Asset Store says it can "launch a scene in the Game tab, send keyboard and mouse input, and take screenshots to check its own work." On its Pro and Ultra plans, a Full Game Playtest Agent plays the whole game, turn by turn.

Ziva's comparison, dated 22 May, is just as wary of Summer. It calls Summer "a separate AI-native editor that opens .godot projects" and says "The engine claims compatibility with existing Godot 4 projects." Its verdict leaves the choice to you: "The right answer for your project is the editor you're faster in by day four."

Each of those pages was written by one of the two products, and neither mentions a third. This page reads both sites on the same day, quotes each in its own words, and puts Flockbay in the table as the third option. Where a product's pages contradict each other, it says what each one says.

Ziva is an agent that lives in your Godot editor

Ziva describes itself as "an AI coding agent that works inside the Godot editor." It installs as an add-on in your project, for Godot 4.2 and later, and its store listing names Windows (x64 and arm64), macOS (Universal) and Linux (x64 and arm64). It writes and refactors GDScript and C#, builds and edits scenes, nodes, signals and resources, reads editor errors, generates sprites and textures, adds 3D models to a scene, and has TileMapLayer tools from Godot 4.3.

It runs on Claude, GPT or Gemini through its hosted models, on your own Claude Code or ChatGPT Codex subscription on every plan, or on a local model through Ollama or LM Studio. It also serves its tools to other agents. As a local MCP server, it lets Claude Code, Codex, Cursor, Windsurf, Zed and others inspect the scene tree, create or update nodes, scenes, scripts and resources, read Godot errors, and run and stop the game, as long as the project is open in Godot.

Leaving is cheap. In Ziva's words, "If you uninstall the plugin tomorrow, your project is still a normal Godot project." The cost sits elsewhere: Claude Sonnet and Opus, Ziva Genius and the full playtester are on Pro at $50 a month, and its installation docs say an internet connection is "Required for AI features".

Verdict: Ziva is the pick if you want an AI agent inside the Godot editor you already use, running on your own Claude Code or Codex subscription or on its hosted models.

Summer Engine is an engine of its own that opens Godot projects

Summer Engine calls itself "The AI game engine for people and agents", and its docs draw the line against plugins: Summer is "a full game engine, not an AI addon." Its migration docs give Godot Engine 4.7.2 as its "current upstream technical base", its homepage counts "more than a million lines of custom code" on top, and its MCP page calls the engine "compatible with Godot 4". You open an existing Godot project with File, then Open Project, and it indexes the files for its AI.

The AI lives in Summer's own editor. It runs the game and reads the output, and it generates 3D models, images, audio and video on credits. Its MCP server is free and MIT-licensed, offers "105 tools to build, run and test real games in the engine", and installs for Claude Code, Codex, Cursor and many other agents with one npx command. The engine exports to "Windows, Mac, iOS, Android and the web, all from Summer", with desktop builds you can ship on Steam or itch.io.

Where it breaks: it is not the Godot you download from godotengine.org. Its docs say a project can go back to official Godot, but "Summer-only AI and platform surfaces will not be present." It does not take your own API key for hosted generation; your own model works through MCP instead. The desktop app is "free proprietary software", and its installation docs list Windows 10 or later and macOS 10.14 or later, with no Linux build stated.

Verdict: Summer Engine is the pick if you want hosted AI, generated art and sound, and mobile export in one engine, and you are happy to work in its editor.

Flockbay is the third option: the official engine, and the AI is free

Flockbay builds and play-tests a whole Godot game for free: free AI every day or your own Claude or ChatGPT, on the official Godot engine. The engine is the official Godot release, bundled with the app, not a fork, and Flockbay works with Godot 4.6+. The app hosts the full Godot editor, with its Scene dock, Inspector, FileSystem, Script editor, Output and Debugger. It opens in the Minimal view, with Standard and Full one switch away, and existing Godot projects open in it.

The AI is also called Flockbay. Before it builds, it works out a brief with you, and it builds nothing until you approve it. Then it writes GDScript and scenes, builds the scenes with the player controller, characters and props, adds terrain, water, sky or weather from a Godot plugin when the game needs them, and plays the game to check its work: it runs the game, sends input events, takes viewport captures and reads the errors from the running game.

The AI costs nothing. The hosted model, Demo, is free every day. Your own Claude plan (Pro or Max) or ChatGPT account, on any plan including Free, runs inside the app. Your own agent connects over one MCP server, registered as flockbay. Or you add an OpenAI or Anthropic API key. Pictures and sound come with the free AI, and a 3D model runs on your own Tripo key. No sign-in stands in front of the first build: the app makes a guest account when it first opens.

Where it breaks: it runs on Windows, on Apple Silicon Macs and on Linux, as an x86_64 AppImage that an Intel or AMD Chromebook runs once Linux is turned on. There is no Intel Mac build. The app is closed source, and building needs an internet connection, though the game runs locally.

Verdict: Flockbay is the pick if you want the whole game built and play-tested on stock Godot without paying for AI.

All three sell hosted AI, and Flockbay’s hosted AI is free every day

Ziva's prices depend on which of its pages you read. Its site says "Hobby is free with your own Claude Code/Codex provider or local models" and "Basic includes Ziva-hosted models", at $20 a month after a seven-day trial for eligible accounts. Its Godot Asset Store listing, updated 9 October, gives Hobby more: "50 Ziva Baby messages a day, 10 Ziva Smart messages, and $3/month of included AI usage." The same listing prices Basic at $20 a month with $60 of AI usage, Pro at $50 with $150 and Ultra at $200 with $600.

Summer's pricing page lists a free app, Pro at $20 a month, Pro+ at $60 and Ultra at $200, and its docs say yearly billing saves 20% on all three. The free app includes 5 hosted AI messages a day, up to 30 a month (read 1 November 2026). A $5 Basic plan exists too, and the docs say it "is not shown on the public pricing page". Pro+ adds "MCP skills and hooks" and "3x limits on all AI usage".

Flockbay’s optional plans for more hosted AI are Hobby $20, Indie Developer $60 and Studio $200 a month. All three are free if you bring a model you already pay for: Ziva on every plan, Summer over MCP, Flockbay in the app or over MCP. The difference shows when you bring nothing. Ziva's site starts its hosted models at Basic, Summer's free tier has limited hosted use, and Flockbay's hosted AI is free every day.

All three run the game; what they do with it differs

Summer runs the game inside its own engine. Its comparison describes the loop as pressing play, watching the game run and reading the real runtime error and console output, and its MCP tools cover play, stop, screenshots, the debugger's errors and game input.

Ziva runs it from the editor. Its quick check opens the game in the Game tab, sends input, captures the final screen and reads runtime errors. On Pro and Ultra, its Full Game Playtest Agent launches the game in a sandbox and pauses it, "giving time for the LLM to think", then plays it turn by turn with keyboard, mouse and gesture input. It returns pass, fail or blocked with reproduction steps, does not edit your project, and in Ziva's words "can run dozens of instances in parallel".

Flockbay's AI plays the game to check its own work, on the free AI. It runs the game, sends input events with timing, takes viewport captures and reads errors with file, line and call stack. An outside agent over MCP gets the same tools, plus the live scene tree, and every change it makes in the editor is one Ctrl+Z.

The difference that matters for a bug hunt is who pays for the check. Summer's checks run on its hosted AI or on your agent. Ziva names no plan for its quick check, and its full playtester costs $50 a month. Flockbay's costs nothing.

Your own Claude Code or Codex works with all three, through different doors

Ziva takes your subscription into its own chat. You connect Claude Code or ChatGPT Codex in its settings, on any plan, and requests come out of that subscription's allowance rather than Ziva's. It also works the other way round, as an MCP server your agent calls.

Summer takes your model only the second way. Its docs say "Summer does not accept your own provider API keys for hosted generation" and point you to its MCP server, where Claude Code, Codex or Cursor drives the editor on the model you already pay for. Local MCP is free on every plan.

Flockbay takes both. Your Claude plan (Pro or Max) runs Claude Code inside the app, and a ChatGPT account on any plan, Free included, runs through the bundled Codex engine. An agent outside the app connects over the flockbay MCP server, and the app writes its setup line with your machine's paths filled in. The Godot MCP guide has that line for every agent.

Your project stays a Godot project in all three, with one catch

Ziva leaves a normal Godot project, because it never was anything else. Flockbay leaves one too: a real Godot 4 project in a folder on your own computer, which stock Godot opens, and nothing is uploaded unless you publish it to your own GitHub repository. Summer keeps its source formats "upstream-compatible", but a project that goes back to official Godot loses the Summer-only surfaces.

The catch is the engine version. Ziva supports Godot 4.2 and later, so a project pinned to an older 4.x stays where it is. Flockbay includes Godot 4.7.2 and asks first when a project was last saved by an older Godot 4: Keep Godot 4.x opens it on your own Godot of that version and says which of Flockbay’s features need 4.7.2, Upgrade to Godot 4.7.2 upgrades it in place, and Open a copy in Godot 4.7.2 leaves the original untouched. A Godot 3 project gets Keep Godot 3 or Convert a copy to Godot 4.7.2. Summer runs on its own engine with a 4.7.2 base, so a project from an older 4.x opens in a newer engine there. Commit before you open it, as you would before any Godot upgrade.

Which to pick, in one line each

Pick Ziva if you want an AI agent inside your own Godot editor, on Windows, macOS or Linux, and you already pay for Claude or ChatGPT or are happy to pay for its hosted models.

Pick Summer Engine if you want hosted AI, generated art and sound, and mobile and web export in one engine, on Windows or a Mac.

Pick Flockbay if you want the whole game built and play-tested on the official Godot engine, with AI that costs nothing, on Windows, macOS or Linux.

If you are still unsure, give each one the same small task, such as a door that opens when three switches are pressed, and play the results yourself. Flockbay vs Summer Engine and Flockbay vs Ziva go deeper on each pairing, and the Ziva alternatives add the free MCP servers.

Summer Engine vs Ziva vs Flockbay, row by row

Read from each product's own pages on 2026-10-13.

Tool	What it is	Engine	Free tier	Paid plans	Your own Claude or ChatGPT	Your own agent (MCP)	Runs and play-tests the game	Platforms	Source code	Verdict
Summer Engine	An AI-native engine and editor: "a full game engine, not an AI addon"	"Compatible with Godot 4", on a Godot 4.7.2 base with "more than a million lines of custom code"	Free app; "Try hosted Summer AI when you create an account"; local MCP free	Pro $20, Pro+ $60, Ultra $200 a month; yearly saves 20%; a $5 Basic plan in its docs	"Summer does not accept your own provider API keys for hosted generation"; your model works through MCP	Free and MIT: "105 tools to build, run and test real games in the engine"; one npx command	Yes: its AI runs the game and reads the output; MCP play, stop, screenshots and game input	Windows 10+ and macOS 10.14+; Linux not stated	App proprietary; CLI, MCP server, skills and hooks MIT	Hosted AI and generation in an engine of its own
Ziva	"An AI coding agent that works inside the Godot editor"	Your own Godot, 4.2 or later; installs as a plugin	Hobby: free on your own Claude Code or Codex, or a local model; its store listing adds $3 a month of AI usage	Basic $20, Pro $50, Ultra $200 a month; the Playtest Agent on Pro and Ultra	Your Claude Code or ChatGPT Codex subscription on every plan, Hobby included	A local MCP server for Claude Code, Codex, Cursor and others; plan not stated	Yes: Game tab, input, final screen and runtime errors; the full-game Playtest Agent on Pro and Ultra	Windows (x64, arm64), macOS (Universal), Linux (x64, arm64)	Proprietary	The agent inside your own Godot editor
Flockbay	A free AI game maker built on Godot: builds and play-tests the whole game	Godot 4.6+; the official Godot release, bundled, not a fork; the full Godot editor inside the app	Free hosted AI every day	Hobby $20, Indie Developer $60 and Studio $200 a month, for more hosted AI	Claude Pro or Max, or any ChatGPT plan, Free included, in the app; or an OpenAI or Anthropic key	Free. One server, flockbay: the editor with one Ctrl+Z per change, the running game, the scene tools and the object library	Yes: runs the game, sends input events, takes viewport captures, reads errors	Windows, macOS (Apple Silicon) and Linux (x86_64 AppImage)	Closed app; your project is yours	The whole game built and play-tested on stock Godot, free

Sources: Summer Engine: Homepage, Summer vs other tools, Pricing, Pricing docs, AI models docs, MCP, Godot MCP, Godot migration docs, Installation docs, Source status, Summer vs Ziva; Ziva: Homepage, Docs, Godot Asset Store listing, Existing subscriptions docs, MCP server docs, Playtesting docs, Full game tester, Ziva vs Summer Engine; Flockbay: Pricing, Your own agent, The editor, System requirements.

Where Summer Engine or Ziva is the better pick

On an Intel Mac, pick Ziva, which ships a Universal macOS build; the Mac build of Flockbay is for Apple Silicon. On Windows on Arm or an arm64 Linux machine, pick Ziva, which ships for both; Flockbay's Windows and Linux builds are for Intel and AMD processors.

For your own Godot editor, with your layout and your editor plugins, pick Ziva: it is a plugin for Godot 4.2 and later that joins the editor you already run. Flockbay works in its own app instead; it can keep a project on your own older Godot 4, but some of its features need Godot 4.6 or later.

For iOS and Android export from the same app, pick Summer Engine. For a playtester that runs a whole game in many instances at once, pick Ziva Pro. For a local model, pick Ziva with Ollama or LM Studio; Flockbay needs an internet connection to build.

Questions

Is Summer Engine better than Ziva?

They do different jobs. Ziva is an AI agent inside the stock Godot editor, free on your own Claude Code or Codex subscription. Summer Engine is an AI-native engine of its own, with 5 hosted AI messages a day, up to 30 a month free and hosted AI at $20, $60 or $200 a month. If you want the whole game built and play-tested for free on the official Godot engine, Flockbay is the third option.

Can Ziva run the game?

Ziva's own pages say yes: it opens the game in the Game tab, sends input, captures the screen and reads runtime errors, and on Pro and Ultra its Full Game Playtest Agent plays the whole game turn by turn. Summer Engine's comparison, dated 6 June 2026, says Ziva cannot play the game.

Is Summer Engine open source?

No. Summer's source page calls the desktop app "free proprietary software" whose source code is not public. Its CLI, MCP server, skills, hooks and plugin manifests are MIT open source. Ziva is proprietary too, and so is the Flockbay app.

Which is cheaper, Summer Engine or Ziva?

Both are free if you bring your own model. For hosted AI, Ziva's Basic is $20 a month, Pro $50 and Ultra $200; Summer's Pro is $20 a month, Pro+ $60 and Ultra $200, with a $5 Basic plan in its docs. Flockbay’s hosted AI is free every day, and its plans for more hosted AI are Hobby $20, Indie Developer $60 and Studio $200 a month.

Which is better for an existing Godot project?

Ziva, if the work has to stay in your own Godot editor, with your layout and plugins; it supports Godot 4.2 and later. Flockbay can build and play-test it free: it can upgrade the project to the official Godot it includes, open a copy in it, or keep it on your own Godot of its version and say which of its features that engine cannot run. Summer Engine opens it in its own engine, and its docs say the Summer-only features are not there if you go back to official Godot.

Do Summer Engine and Ziva work with Claude Code?

Yes. Ziva runs on your Claude Code subscription inside its chat, and serves its tools to Claude Code as a local MCP server. Summer connects Claude Code over its free MCP server, but does not accept your own API keys for hosted generation. Flockbay runs Claude Code in the app on your Claude plan, and connects Claude Code outside the app over its own MCP server.

Download Flockbay free: Flockbay is a free AI game maker built on Godot, for Windows, macOS and Linux. https://flockbay.com/

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.