I built a free open-source tool called hera-agent-godot.
The idea is simple:
When an AI helps you build a Godot game, it usually cannot see your Godot Editor.
It can read your files.
It can read your prompt.
It can guess what the scene looks like.
But it does not actually know what is happening inside the running editor.
That is why AI sometimes says:
- “This node exists.”
- “This script should work.”
- “There should be no error.”
- “This scene is wired correctly.”
Then you open Godot and something is broken.
hera-agent-godot gives AI eyes and hands inside Godot
hera-agent-godot is a low-token CLI that lets AI coding agents inspect and control a live Godot Editor.
Instead of only guessing from files, the AI can ask the real editor what is happening.
It can:
- Read the current scene tree
- Check node properties
- Add, remove, or edit nodes
- Attach scripts
- Connect signals
- Run and stop scenes
- Read Godot output and errors
- Take screenshots
- Inspect runtime game state
- Call runtime methods for testing
So the workflow changes from:
“I think this should work.”
to:
“I ran it in Godot, checked the result, and here is what happened.”
A simple example: one-prompt Othello
As a quick test, I asked an AI agent to build a simple Othello/Reversi game in Godot with one prompt.
The AI did not only generate the code.
It also used hera-agent-godot to:
- Create the scene and script
- Set the main scene
- Run the game in Godot
- Take screenshots
- Simulate moves
- Check the score labels
- Check the current turn
- Read the runtime error log
The test sequence was something like:
Initial screenshot
Move: (2, 3)
Move: (2, 2)
Move: (2, 1)
Move: (1, 1)
After each move:
- screenshot
- verify score
- verify turn
- verify no runtime errors
That is the main reason I built this.
Writing code is only half of the job.
The AI should also verify the result inside the actual game editor.
Why not just use MCP?
MCP is great, and there are already Godot MCP tools.
But I wanted something very lightweight.
hera-agent-godot is a CLI-first tool.
That means:
One shell command per action
Compact JSON output by default
No large tool schema loaded every turn
Works with any AI agent that can run shell commands
For example:
hera status
hera scene tree
hera run --current --wait
hera output --type error
hera screenshot --runtime --analyze
The goal is not to replace every possible integration.
The goal is to give AI agents a small, practical bridge to the real Godot Editor.
It also has a Unity sibling
I also built hera-agent-unity with the same idea for Unity.
The problem is the same in both engines:
AI can write code, but it often cannot see the editor.
So the goal is also the same:
Less guessing
More checking
Better feedback loops
Fewer wasted prompts
If you work with both Unity and Godot, the Hera tools try to give AI agents a similar way to inspect, test, and fix real editor state.
Who is this for?
This may be useful if you:
Use Claude Code, Cursor, Codex, Copilot, or another AI coding agent
Build games in Godot
Get tired of AI producing code that does not run in the editor
Want the AI to inspect scenes, nodes, logs, and runtime state directly
Prefer a lightweight CLI over a heavier integration
Work solo or in a small indie team.
Links
GitHub:
https://github.com/NotNull92/hera-agent-godot
Godot Asset Store:
https://store.godotengine.org/asset/notnull92/hera-agent-godot/
Unity version:
https://github.com/NotNull92/hera-agent-unity
Final thought
AI coding tools are getting better fast.
But for game development, file access is not enough.
The editor matters.
The scene tree matters.
Runtime state matters.
The screenshot matters.
The error log matters.
hera-agent-godot is my attempt to give AI agents access to those things in a simple, low-token way.
It is free, open-source, and MIT licensed.
Feedback, bug reports, and feature ideas are very welcome.
Top comments (0)