Ziva reads Godot editor errors with get_godot_errors and can edit the code inside Godot to fix them. Since 3.1.2 (August), errors reach the agent with file and line. The free MCP bridges hi-godot/godot-ai  and tomyud1/godot-mcp  let Claude Code or Cursor read Output and Debugger errors, then edit the code.

MCP (Model Context Protocol) connects a client’s AI to tools such as error readers. Our test covered Godot’s error reporting; we did not run any AI tool. Every tool description, Ziva’s included, comes from public docs, listings or published source code.

In that test, runtime errors reached Debugger > Errors, the running game’s error list, without appearing in the Output panel. Zivash Inc, the company behind Ziva, publishes this page.

Prices and versions checked September 19, 2026.

TL;DR

Hobby includes error reading. Its pricing card lists all core features. Ziva’s separate Full Game Playtest Agent requires Pro ($50/month) or Ultra.

Where Godot puts errors

We tested four deliberate defects on Linux with Godot 4.7.2  (Arch package build 4.7.2.stable.arch_linux.ed1daf0bf).

We ran the game and editor headless (no windows), with and without the debugger. Our own small test plugin read the editor panels. We did not test a windowed editor.

Static checks used --check-only and Godot’s language server, which sends script diagnostics through the language server protocol (LSP). Godot’s language server sent diagnostics only for scripts our client opened, one at a time. It sent nothing before those requests, even though its startup scan had logged the parse error.

Stack Trace is the debugger tab showing where execution stopped. The stderr/log column covers runs without a debugger.

Without a debugger attached, stderr and user://logs/godot.log reported all four defects. Every headless run stopped with --quit-after 60 and exited 0 despite errors. An exit-code check would falsely pass.

The parse check exited 1 for the parse error, the only defect the static checks caught. The script editor also showed it.

Attaching the debugger changed when the parse error became visible. At startup, the game paused with an empty Errors tab and only the engine banner in its log. Stack Trace showed the error; Errors and the game log received it after we resumed execution. If the log holds only the engine banner, inspect Stack Trace.

Output showed the parse error at project load. During gameplay, Output showed only our print() lines and a test line we sent with printerr(). None of the four defects appeared. Godot’s docs likewise put running-game push_error() messages in Debugger > Errors.

Godot’s debug adapter protocol (DAP), for outside debugging tools, signalled parse and null-call errors as pauses with attached error messages. Its console carried only the banner, print and printerr output. A tool reading only that console would miss all four defects.

For an agent that reads files, check user://logs/godot.log. On Linux, user:// normally resolves to ~/.local/share/godot/app_userdata/<project name>/. Our editor-launched scene logged all four defects after we resumed the breaks. With default logging, godot.log held the latest session; older runs rotated to timestamped files in user://logs.

This stderr record came from line 6, target.queue_free(), where target was get_node_or_null("DoesNotExist"):

SCRIPT ERROR: Cannot call method 'queue_free' on a null value.
          at: _ready (res://scripts/b_runtime_error.gd:6)
          GDScript backtrace (most recent call first):
              [0] _ready (res://scripts/b_runtime_error.gd:6)

How each tool gets the errors

The Error source column shows whether a tool reads a running game or only checks scripts. Script checks miss runtime errors. MCP bridges such as hi-godot and tomyud1 connect their error readers to Claude Code or Cursor.

If you paste errors into a chat yourself, see Ziva vs AI Assistant Hub.

Ziva’s error-fixing loop

Per Ziva’s Godot AI page, ordinary editor chats read runtime failures via get_godot_errors. The scene-by-scene loop below works on Hobby: chats launch the game, play through it and screenshot what they see. The separate Full Game Playtest Agent plays the whole game.

Ziva’s changelog says 2.6.0 (April) passed Godot editor errors to Ziva so it could react. Version 3.0.0 (June) added scene launch, input and screenshots in ordinary chats. The Full Game Playtest Agent arrived in 3.1.4 and gained runtime errors in 3.1.5 (both August). Version 3.2.5 (September) added read-only Ask mode.

To work through an error:

1. Use /ask to discuss the error without edits, then /default when ready for changes.
2. Let the agent edit and address script errors returned in its tool results, a feature added in 3.2.5.
3. Ask the agent to run the scene, send input, check screenshots and read the run’s errors with get_godot_errors.
4. Repeat until the run produces no new errors in get_godot_errors or Debugger > Errors.

Since 3.1.8, Ziva stops a turn that loops on the same action. You can also undo a turn. Outside clients can read errors and run or stop the game through Ziva’s local MCP server.

MCP bridges for Claude Code and Cursor

Per hi-godot’s docs, script writes (script_create, script_patch) return diagnostics for the written file. For a startup pause like ours, project_run builds an error record from the break reason and Stack Trace frames, naming the failing script. The workflow is to stop the game, fix the error and relaunch.

tomyud1 added Debugger reading in 0.3.0 (March 31, 2026). On May 5, HobbitDur reported  that the Debugger showed errors while Claude reported none. The 0.6.0 changelog (August 24, 2026) says get_errors now reliably captures them for that issue.

Debugger > Errors entries can appear a few frames after startup, so an immediate check can falsely report zero errors. tomyud1 added wait_ms to delay the check.

Godot MCP Pro documents reading errors, editing scripts and checking again. GDAI MCP says it checks errors and screenshots after running. See the broader MCP comparison for workflow tradeoffs.

Process capture and other routes

AI Copilot’s source  shows stdout/stderr capture for 1 to 30 seconds without -d, Godot’s local debugger flag. That matches the route that carried all four defects in our test.

With -d, we tested only the null call. Stderr carried its error and backtrace. Stdout carried its break reason, frame and a debug> prompt. Our stdin was closed, and the run exited 0.

Coding-Solo’s source starts Godot with -d and keeps stdin open as a pipe. We infer that its game might wait at the debugger prompt, preventing later gameplay errors from occurring or being returned. Both tools capture their own processes, so an independently started game falls outside that capture.

AI Copilot’s check_scripts uses headless --check-only. Two Godot issues report valid autoloads and addon singletons flagged in that mode: #78587  and #111515 . Both were open when checked. Tools using this mode can chase false errors.

Gamedev AI lists Watch Mode as monitoring Output. Godot’s Output missed our gameplay script errors, push_error()/push_warning() and missing-resource errors. In the source we read  (commit 5313e46), we could not find where Output errors are fed into Watch Mode.

Limits to know

Ziva is proprietary: its terms prohibit reverse engineering and decompilation. The MIT-licensed options are hi-godot, tomyud1, AI Copilot, Coding-Solo, Gamedev AI, godot-vscode-plugin, A.I. Essentials Toolkit and AI Assistant Hub.

Ziva’s error reading broke on Godot 4.6 until a fix in its patch notes for January 28 to February 5, 2026. Recheck error capture after an engine update. hi-godot documents capturing startup parse pauses; Ziva’s public docs do not mention them.

MCP client or model usage costs extra. After Hobby’s $3 monthly usage cap, you can wait for a reset or choose a paid plan. Hobby also accepts your Claude/Codex subscription, using its allowance, or local models through Ollama or LM Studio. Paid plans start with Basic at $20/month.

Zhang and Kothari’s 2026 preprint  finds logical failures harder to repair than syntax or runtime errors in Python and Java, not GDScript. We found no Godot-specific benchmark of AI error fixing. Repeat the failing scene and input sequence before accepting a change.

Related reading

• Ziva vs Godot MCP: Plugin Agent or Open-Source Bridge: bridge workflow comparison
• Is there an AI agent that can playtest a Godot game?: runtime verification
• Is there an AI copilot inside the Godot editor?: the wider editor workflow
• GPT-5.6 Benchmark: We Made It Build a Godot Game: build evidence with sample-size caveats