# AI playtesting for Godot: an agent can check that your game works, not that it is fun

Yes: an AI agent can playtest a Godot game automatically, by running it headless or in a window, playing timed input events into it, reading viewport captures, stdout and the debugger, and fixing the code before it plays again. Flockbay's AI does this free on the game it builds and gives any agent the same tools over MCP, Ziva's Playtest Agent plays to a pass or fail verdict on its $50-a-month Pro plan, and godot-ai, GDAI MCP and Godot MCP Pro add input and screenshot tools to your own Godot editor. No agent can tell you whether the game is fun, so Flockbay Playtest sends your build to people and brings their reports back with a replay.

Source: https://flockbay.com/ai-playtesting/ · Updated 2026-10-13

## An AI's 46 checks missed the jam a playthrough found

GPT-6.1 Sol built four doors in a small first-person house in Godot and wrote 46 checks for them. Before the door checks ran, it switched the guard off and moved the player out of the house, so the guard and the player never met. A playthrough found what the checks could not. With the player and the guard in the same room, one rule about what counts as in the way jammed a door and stranded the guard.

Claude Opus 5.5, given the same job, wrote 45 checks and a three-minute stress test with the player popping up in doorways while the guard did his rounds, and its doors handled every case the playthrough tried. Both runs are in [the door problem build log](/blog/opus-5-5-vs-gpt-6-1-sol-the-door-problem-in-godot/).

That is AI playtesting today, in one episode. An agent can boot your game, play input into it, look at it and read what broke, faster and more often than any person. It tests the situations it thinks to try, and whether it thinks of the right ones is the whole difference.

## An AI agent can boot, play, watch and read a Godot game on every change

A headless run is the first check. Godot started with --headless opens no window and renders nothing, runs the game's logic, and prints every error with its file and line; with --quit-after it stops after a set number of frames. It catches a GDScript parse error, a null node path or a script that crashes on load in seconds. It cannot take a screenshot, because it draws no frames.

Timed input events play the game. An agent sends keys, mouse buttons, gamepad input and InputMap actions into the running game, each with a start time and a hold. A viewport capture then shows what the player would see, and a model that reads images can say the camera is pointing at the sky or the HUD covers the health bar.

The live scene tree turns a look into a number. Reading the player's global_position and velocity every physics tick says whether the jump reached the ledge, where a screenshot only suggests it. Godot's performance monitors add frame time, draw calls and node counts while the agent plays.

Determinism makes a failure repeatable. Godot seeds its random number generator from the clock and runs in real time, so the same input can play out differently twice. A fixed step, from --fixed-fps, and a fixed seed make the same input give the same run on the same machine, which is what lets an agent compare its fix against the bug.

The agent loop ties it together: change the code, run, look, read the errors, change it again. The loop is worth more than the model. In Flockbay's Godot 4 coding test, Claude Haiku 4.5 went from 11 of 15 tasks to 14 with one look at the test's output, as [the best LLM for Godot](/blog/best-llm-for-godot/) shows.

## An agent tests whether the game works, not whether it is fun

It only tests what it thinks to try, as Sol's doors showed. People try the things nobody planned for, and that is where most of the breakage hides.

It cannot judge feel. A viewport capture is one frame, and game feel lives between frames and in a player's hands: input latency, the arc of a jump, whether a hit lands with weight. An agent can measure the arc. It cannot tell you the arc feels floaty.

It cannot tell you whether the game is fun, whether a first-time player understands the first room, or whether the difficulty curve holds. Playtesting in the designer's sense means watching strangers play. Valve's testers told it Portal was still a tutorial a year in, and GLaDOS was the answer, as [Playtesters invented GLaDOS](/blog/valves-secret-weapon/) tells. What an agent does today is closer to QA: it checks that the game works.

And it plays on one machine. A headless run skips the renderer, so a shader that fails on another GPU, or a driver crash on a tester's laptop, never shows up in it.

## Flockbay's AI plays the game it builds, for free

Flockbay is a free AI game maker built on the official Godot 4.7.2, not a fork, and the AI that writes the game also plays it. It checks every script without running the game, starts a Play or a headless run, plays up to 200 timed input steps, captures the game viewport, and reads the live scene tree and the game's stdout with every error's file, line and call stack. It can step the game one physics tick at a time and read the performance monitors. Then it changes the code and plays again. It runs on Flockbay's free hosted AI every day, or on your own Claude or ChatGPT.

Your own agent gets the same tools. Claude Code, Codex, Cursor or any MCP client connects to Flockbay's one MCP server, flockbay-stage, and calls flockbay_play, flockbay_run_headless, flockbay_game_input, flockbay_game_screenshot, flockbay_game_get and flockbay_last_run itself, on its own model. Connecting is free, and the app writes the setup for your agent: [Godot MCP for Claude Code, Codex or Cursor](/godot-ai-mcp/).

A person's play becomes a test. Start a Play with recording on and play the bug once, and the agent replays your exact input, stamped by physics tick, with the same seed and fixed step, in a Play or a headless run, before and after its fix. A headless run steps game time faster than the wall clock, so a long check comes back quickly.

What it does not do is play a whole game through to a goal on one command and hand back a pass or fail verdict: you or your agent decide what to try. It works on the game Flockbay has open, which can be a Godot project you made elsewhere, a folder on your computer. The app runs on Windows and Linux, and the Mac build is an earlier release. It needs the internet while you build, and it is closed source.

Verdict: the free pick when you want the AI that builds your Godot game to run it, play it, look at it and fix what it finds.

## Flockbay Playtest puts the build in front of people and brings the bug back fixable

An agent tests what it thinks to try. People try everything else. In the Flockbay app, Share for playtesting turns your game into a link. A tester installs Flockbay Playtest, a small free Windows app, opens the link and plays your build confined: it cannot read their files, start programs or open their browser.

While they play, errors, crashes, frame times, how long they played, their PC's hardware and their input by action, never what they type, come back to you. F7 files a bug report, with a screenshot if they keep it. If you ask for them, the tester can tick a box for clips of the two minutes before a report or a crash, another to record the whole session with the game's sound, and a third for their voice over the microphone. All three start unticked. Your questions come at the end, drafted by Flockbay from your game's brief for you to edit.

The report arrives fixable. Fix with Flockbay turns it into a turn in the game's chat, with the tester's note, the error and its backtrace, the scene and frames from the screenshot or clip attached. Reproduce replays the tester's session in your Play, on their seed and their input, to the moment they reported, and checks the replay against what happened to them. Your own agent gets the same through flockbay_playtest_reports and flockbay_playtest_replay.

Where it stops: testers are 18 and over and play on Windows. A saved Flockbay account makes the links, up to 20 a day. A game's own native libraries, such as a GDExtension, do not load inside the confinement, and you are told which before you share. You find the testers; Flockbay does not supply them.

Verdict: the free way to get human playtest reports back as something your AI can replay and fix, from Windows testers you bring yourself.

## Ziva's Playtest Agent plays to a verdict and leaves the code alone

Ziva is an AI agent that runs inside the Godot editor. Its page for the Playtest Agent, read on 13 October 2026, says the agent reads your code first, launches the game in a sandbox and pauses it between actions so the model has time to think, then plays with keyboard, mouse and gesture input from goals you write in plain English. It measures what happened with screenshots, custom hooks and added logging, and ends on a pass or fail verdict with a video of the run. The page says it can play games through to the end and run dozens of instances in parallel.

It does not fix what it finds: the page says the agent has no write tools, so it cannot edit the game it is judging. Ziva lists Godot 4.2 and later, with Unity in an enterprise beta. The agent needs Ziva's Pro plan at $50 a month, and Ziva's pricing page also lists it on Ultra. Ziva's own page notes that a full playtest uses many more tokens than a chat turn.

Verdict: the most complete packaged AI tester for a Godot 4.2+ game, run from goals you write, at $50 a month; it reports bugs and leaves the fixing to you.

## Godot MCP servers hand your own agent the controller, not the judgment

If your agent already lives in Claude Code, Codex or Cursor, a Godot MCP server with input and screenshot tools lets it playtest your own project in your own Godot editor. Three of them state those tools on their own pages, read on 13 October 2026.

godot-ai, by hi-godot, is free and MIT licensed, for Godot 4.7 and later, with 46 tools. Its tool list covers running the project; keys, mouse, gamepad, input actions and frame-timed input sequences; the running game's scene tree and node info; a capture of the running game's framebuffer; game and editor logs; performance monitors; and a runner for GDScript test suites in the editor. Verdict: the best free way to let your own agent play and test a Godot 4.7 project in your own editor.

GDAI MCP is $19 once, for Godot 4.2 and later on Windows, macOS and Linux. Its page says the AI can press keys and input actions in the running game, take game and editor screenshots, and read the output log, debugger errors and script parse errors, and it describes the loop: read the errors, update the script, run the game, check the result in screenshots. Mouse input is not stated. Verdict: a one-time $19 for keys, screenshots and the debugger in any Godot 4.2+ project, on any desktop OS.

Godot MCP Pro is $15 once, for Godot 4.4 and later, tested up to 4.7, on Windows, macOS and Linux, with 187 tools. It simulates keys with modifiers, mouse clicks, input actions and multi-event sequences, captures the running game and the editor, reads the live game's scene tree and node properties, and has test tools of its own: scripted test scenarios, assertions on node state and a stress test that fuzzes random input. Its editor plugin is open source, and the MCP server comes in the paid download. Verdict: the most test-shaped of the plugins, with assertions and input fuzzing, for $15 once.

All three give your agent the controller, not the judgment. You still decide what to test, and the agent still decides what to try.

## GUT and GdUnit4 still run the regression tests, and an agent can write them

A unit test checks one piece of code with fixed input, the same way every time, for free. That is the regression suite an agent's playthrough is not. Ask your agent to write the tests, and run them headless after every change.

GUT, the Godot Unit Test framework, is MIT licensed. Its 9.x releases are for Godot 4, with 9.7.1 for Godot 4.7, and it has doubles, stubs, spies and a command-line runner. Verdict: the free unit-test framework for GDScript with doubles and spies; it tests code, not play.

GdUnit4, also MIT licensed, tests GDScript, C# and scenes. Its scene runner simulates keyboard, mouse and input actions, its command-line tool runs tests outside the editor for CI, and its v7.0.0 lists Godot 4.7 and 4.7.1 as compatible. Verdict: the free pick when you want scene tests with simulated input, and C# beside GDScript.

## A human tester still wins on fun, feel and the thing nobody planned

In one Portal test at Valve, a player spent half an hour shoving a shelf toward a button while a box sat nearby, ignored. That is the information an agent does not produce: what the game says to someone who has never seen it.

The split that works is simple. The agent checks that the game works on every change, and people tell you whether it is worth playing. Flockbay does the first with its AI and carries the second through Flockbay Playtest, both free.

## AI playtesting tools for Godot, compared

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

| Tool | Who plays | Input into the running game | What it sees | Errors and output | Fixes what it finds | Price | Godot and OS |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Flockbay | Flockbay's AI, or your own agent over its MCP server; people through Flockbay Playtest | Keys, mouse, gamepad, input actions and text, up to 200 timed steps; recorded play replayed by physics tick | Viewport captures, the live scene tree, node values every physics tick, performance monitors | stdout and every error with file, line and call stack; headless runs; every script checked without running | Yes: the same AI edits the code and plays again; a tester's report becomes a fix turn | Free | The official Godot 4.7.2 it ships; Windows and Linux, Mac an earlier release; Flockbay Playtest on Windows |
| Ziva Playtest Agent | Ziva's agent, from goals you write in plain English | Keyboard, mouse and gesture input | Screenshots, custom hooks and added logging; a video of each run | Added logging; Ziva's editor agent reads output and errors | No: it has no write tools and ends on a pass or fail verdict | Pro plan, $50 a month; also on Ultra | Godot 4.2+; Unity in enterprise beta; OS not stated |
| godot-ai (hi-godot) | Your own agent, in your own Godot editor | Keys, mouse, gamepad, input actions, frame-timed sequences | The running game's framebuffer, editor views, the runtime scene tree, performance monitors | Game, editor and plugin logs | Your agent does; a GDScript test runner checks it | Free, MIT | Godot 4.7+; OS not stated |
| GDAI MCP | Your own agent, in your own Godot editor | Keyboard keys and input actions; mouse not stated | Game and editor screenshots; runtime scene tree not stated | Output logs, debugger errors, script parse errors | Your agent does: read the errors, update the script, run, check screenshots | $19 one-time | Godot 4.2+; Windows, macOS, Linux |
| Godot MCP Pro | Your own agent, in your own Godot editor | Keys with modifiers, mouse clicks, input actions, multi-event sequences, random-input stress tests | Game and editor screenshots, multi-frame captures, the live game's scene tree and node properties | Editor errors with stack traces, the output log | Your agent does; test scenarios and node-state assertions check it | $15 one-time | Godot 4.4+, tested to 4.7; Windows, macOS, Linux |
| GUT | Your test code | Not stated on its README | What your test asserts | Test results, from the editor or the command line | No: it reports failing tests | Free, MIT | GUT 9.x for Godot 4; 9.7.1 for Godot 4.7 |
| GdUnit4 | Your test code, in GDScript or C# | Keyboard, mouse clicks and movement, input actions, in its scene runner | What your test asserts on a running scene | Test results, from the editor or a command-line tool for CI | No: it reports failing tests | Free, MIT | v7.0.0 lists Godot 4.7 and 4.7.1 |

Sources: Flockbay: [Connect your own agent](/docs/connect-your-own-agent/), [Godot MCP setup](/godot-ai-mcp/); Ziva Playtest Agent: [Full game tester](https://ziva.sh/full-game-tester), [Pricing](https://ziva.sh/pricing); godot-ai (hi-godot): [README](https://github.com/hi-godot/godot-ai), [Tools](https://github.com/hi-godot/godot-ai/blob/main/docs/TOOLS.md); GDAI MCP: [Website](https://gdaimcp.com/); Godot MCP Pro: [Website](https://godot-mcp.abyo.net/); GUT: [GitHub](https://github.com/bitwes/Gut); GdUnit4: [GitHub](https://github.com/godot-gdunit-labs/gdUnit4).

## When another option beats Flockbay

A packaged AI tester that plays your goals through to a pass or fail verdict, records a video and runs dozens of instances in parallel, without touching your code: Ziva's Playtest Agent, at $50 a month.

Your own agent playtesting a Godot project in your own editor: godot-ai, free on Godot 4.7, or Godot MCP Pro, $15 once, for its assertions and input fuzzing.

A regression suite that runs the same checks on every commit: GUT or GdUnit4, with GdUnit4's command-line tool in CI.

A Mac today: GDAI MCP and Godot MCP Pro state macOS support, and the Mac build of the Flockbay app is an earlier release.

Whether the game is fun: people. Flockbay Playtest brings their reports back, and nothing replaces them.

## Questions

### Can AI playtest a game automatically?

Yes, for whether it works. An AI agent can run a Godot game headless or in a window, play timed input events into it, read viewport captures, stdout and the debugger, then fix the code and play again. It cannot tell you whether the game is fun, and it only tests the situations it thinks to try.

### What is the best AI tool to playtest games?

For a Godot game it depends on who should play and who should fix. Flockbay's AI plays the game it builds and fixes what it finds, free. Ziva's Playtest Agent plays your goals to a pass or fail verdict with a video, on its $50-a-month Pro plan, and does not edit code. godot-ai, GDAI MCP and Godot MCP Pro give your own agent input and screenshot tools in your own editor.

### Can Claude Code or Codex playtest a Godot game?

Not on their own: they read and write files and can boot the game headless from a terminal. Connected to a Godot MCP server with input and screenshot tools, they can play it. Flockbay's server, flockbay-stage, gives them Play, headless runs, timed input, viewport captures, the live scene tree and the game's errors, free.

### Does AI playtesting replace human playtesters?

No. An agent checks that the game works on every change. People tell you whether it is fun, whether the first room makes sense and what they tried that you never planned for. Flockbay Playtest sends your build to testers and brings their reports back with the error, a replay and, if they agree, a clip or a recording.

### What is a headless run in Godot?

Godot started with --headless: no window and no rendering, just the game's logic and everything it prints, stopped after a set number of frames with --quit-after. It is the fastest check that a change boots and its GDScript compiles. It cannot take a screenshot, because it draws no frames.

### How do I make an AI playtest repeatable?

Fix the step and the seed. Godot runs in real time and seeds its random number generator from the clock, so the same input can play out differently. Run at a fixed step with --fixed-fps set to the physics rate, set a fixed seed with seed(), time the input in physics ticks, and the same input gives the same run on the same machine.

### Is Flockbay Playtest free?

Yes. Flockbay has no paid plans. A saved Flockbay account, which is free, makes playtest links, and testers install the free Flockbay Playtest app on Windows.

Download Flockbay 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. https://flockbay.com/

Related: [Godot MCP: connect Claude Code, Codex or Cursor to your Godot game](/godot-ai-mcp/), [The best Godot MCP server](/blog/best-godot-mcp-server/), [The best LLM for Godot](/blog/best-llm-for-godot/), [Cursor for Godot](/cursor-for-godot/), [Playtesters invented GLaDOS](/blog/valves-secret-weapon/), [Connect your own agent](/docs/connect-your-own-agent/)