Skip to content

Godot MCP: connect Claude Code, Codex or Cursor to your Godot game

By Eduardo Orellana · Updated

We make Flockbay. Every other tool here was read from its own site on 29 September 2026.

Godot MCP is a Model Context Protocol server that lets an AI agent such as Claude Code, Codex or Cursor work inside a Godot game: edit its scenes and scripts, run it, read its errors, look at it and play it. Flockbay is one. Open Connectors in the Flockbay app, press Turn on for Connect your agent (MCP), and paste the line it writes into your agent once. Connecting is free to start. Free AI to start: Flockbay's AI and your own Claude, ChatGPT, agent or API key are free for your first build; after that, a plan keeps you building. It runs on Windows, macOS and Linux, on the official Godot engine.

TL;DR. As of 29 Sep 2026, the Flockbay app serves one MCP server, flockbay, on Windows, macOS and Linux. Your agent gets the open Godot editor with one Ctrl+Z per change, the running game to play, picture and read, and Flockbay's library of ready-made objects to search and place. It needs the app open with your game, the free guest account the app makes for itself, and an internet connection. Your agent's own plan pays for its model.

AppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.

Intel or AMD Chromebook, with Linux turned on.

Download for macOSDownload for WindowsDownload for Linux

Godot MCP lets the agent find out for itself

Ask Claude Code to fix a jump that feels floaty and, on its own, it does half the job. It opens the player script, lowers the gravity, and hands the rest to you: you press Play, you jump, you describe what went wrong, you paste the error back. Every round trip goes through your hands.

A Godot MCP server removes the round trip. The agent presses Play itself, holds the jump action for a third of a second, captures the viewport at the top of the arc, reads Godot's stdout and errors, and changes the script again before you have looked at anything.

MCP, the Model Context Protocol, is the plumbing. It is an open standard: a server offers tools, and a client such as Claude Code, Codex or Cursor discovers them and calls them. The protocol is the easy half. What matters is which tools a server hands over, and whether the agent can check its own work with them. The roundup of Godot MCP servers compares a dozen of them; this page is the setup and the reference for Flockbay's.

Connecting Flockbay to your agent is one paste

Flockbay is a free AI game maker built on Godot: a desktop app that works with Godot 4.6+, with the official Godot engine inside, not a fork. Its MCP server lives in the app, so there is nothing to install from npm and no plugin to copy into your project. On Windows, macOS or Linux, the steps are these.

Open the Flockbay app. On first launch it makes itself a free guest account, with no sign-in, and that account is all the connection needs to start. Then open your game, or press Open Godot project… for one you already have; the Godot editor opens with it.

Open Connectors from the Flockbay menu, press Set up on the Connect your agent (MCP) row, and press Turn on.

Pick your agent and press Copy. For Claude Code and Codex it is a command for a terminal. For the others it is a block for the config file the dialog names, and Cursor and LM Studio also get a button that adds it for you.

The line carries three paths that belong to your machine: the Node runtime that ships inside Flockbay, the script that serves the tools, and a small file that tells the server which running app to reach. That is why the app writes it and this page does not. The blocks below show the shape, with those three paths as placeholders. The paths stay the same from one sitting to the next, so you paste once. On Windows the app also puts a flockbay command on your PATH, so there the line is the same on every machine: claude mcp add --scope user flockbay -- flockbay mcp, or codex mcp add flockbay -- flockbay mcp.

The app also runs the line itself. If it cannot start on your machine, the dialog says so in red above it, in the server's own words, instead of letting it fail later inside your agent. For Claude Code and Cursor the same dialog can install Flockbay's skills and hooks, and for Codex and Goose its skills: the instructions that teach the agent how to build with these tools.

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

Or paste one prompt and let your agent check it

Paste this into Claude Code, Codex or Cursor in your game's folder. Your agent checks the connection, reads the project with flockbay_project_info, and changes nothing until you ask. The same text is on the setup prompt page, with a Markdown copy an agent can fetch.

Text
Connect Flockbay to this session. Flockbay is installed on this computer and serves Godot tools over MCP.

1. Register its MCP server once, for my user. On Windows, in Claude Code run: claude mcp add --scope user flockbay -- flockbay mcp
   In Codex run: codex mcp add flockbay -- flockbay mcp
   In Cursor, add this to ~/.cursor/mcp.json: {"mcpServers":{"flockbay":{"command":"flockbay","args":["mcp"]}}}
   If the terminal says flockbay is not found, tell me to open a new terminal and start again there.
   On a Mac or Linux there is no flockbay command: ask me to paste the line the Flockbay app writes for this machine (Connectors › Connect your agent (MCP) › Set up › Turn on › Copy).
2. Check it: `claude mcp list` or `codex mcp list` lists flockbay. If flockbay is listed but the flockbay_status tool is its only tool, ask me to open the Flockbay app with this game and turn on Connect your agent (MCP), then start a new session.
3. Call flockbay_project_info and tell me in a few lines what this Godot project is: its main scene, its autoloads and the scripts that run the main loop.
4. Change nothing yet. Ask me what to work on.

Godot MCP in Claude Code

Paste the line in any terminal. It registers the server as flockbay with --scope user, so it is there whichever folder you start Claude Code in. Claude Code's default scope is the current folder only, which is how a connection quietly goes missing when you paste in one folder and work in another.

Check it with claude mcp list in a terminal, or type /mcp inside a session. Then ask Claude Code whether Flockbay is connected: the first tool it sees answers with what to do next. On Windows, the Flockbay plugin registers the same server in one step instead: claude plugin marketplace add flockbay/flockbay-plugin, then claude plugin install flockbay@flockbay. More on the workflow: making games from Claude Code.

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

Godot MCP in Codex

Paste the line in a terminal. Codex stores it in its config.toml, by default ~/.codex/config.toml, so every session after that sees it. On Windows, codex plugin marketplace add flockbay/flockbay-plugin adds the Flockbay plugin instead, which you then install from the Plugins Directory.

Check it with codex mcp list, or type /mcp in the Codex terminal. More on the workflow: making games in Codex.

Terminal
codex mcp add flockbay --env "FLOCKBAY_MCP_DESCRIPTOR=<descriptor>" -- "<node>" "<coordinator>" --external-stage-mcp

Godot MCP in Cursor, Gemini CLI, Cline, Devin Desktop and LM Studio

These five read the same JSON shape: an mcpServers entry with a command, its arguments and one environment variable.

Cursor: add it to ~/.cursor/mcp.json (on Windows, %USERPROFILE%\.cursor\mcp.json), or press Add to Cursor in Flockbay's dialog. Gemini CLI: ~/.gemini/settings.json. Cline: MCP Servers, then Configure, then Configure MCP Servers, and add it to that file. Devin Desktop is Windsurf renamed and keeps Windsurf's file, %USERPROFILE%\.codeium\windsurf\mcp_config.json. LM Studio: Program, then Install, then Edit mcp.json, or press Add to LM Studio.

If Cursor is your editor already, Cursor for Godot covers how it fits beside the Godot editor.

More on this: Making games with Kilo Code and Flockbay

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

Godot MCP in OpenCode and Kilo Code

These two read an mcp key with the command as one array. OpenCode: opencode.json in your game's folder, or ~/.config/opencode/opencode.json. Kilo Code: ~/.config/kilo/kilo.jsonc, or kilo.jsonc in your game's folder.

JSON
{
  "mcp": {
    "flockbay": {
      "type": "local",
      "command": [
        "<node>",
        "<coordinator>",
        "--external-stage-mcp"
      ],
      "environment": {
        "FLOCKBAY_MCP_DESCRIPTOR": "<descriptor>"
      },
      "enabled": true
    }
  }
}

Godot MCP in Goose, and with a local model

Goose reads YAML under extensions, in ~/.config/goose/config.yaml.

Ollama runs a model, not an agent, so it has no config of its own here. Run your Ollama model inside Goose, OpenCode or Cline and use that agent's block. The tools are the same; how well a small model uses them is up to the model.

More on this: Prompt templates for your own agent in Flockbay

YAML
extensions:
  flockbay:
    name: flockbay
    type: stdio
    cmd: '<node>'
    args:
      - '<coordinator>'
      - '--external-stage-mcp'
    envs:
      FLOCKBAY_MCP_DESCRIPTOR: '<descriptor>'
    enabled: true
    timeout: 300

Godot MCP through Flockbay reaches the editor, the running game and an asset library

Through the open Godot editor, your agent can open and create scenes; add, delete, rename, move and duplicate nodes; read and set their properties; write scripts and attach them; create and change resources such as materials and collision shapes; and connect signals. Every change is one step in Godot's own undo history, named for what it did, such as "Flockbay: Add Player", and the scene is saved after it. Press Ctrl⌘+Z and it is gone, like a change of your own.

It can read the project's settings, files, autoloads and input actions, and change settings and input actions. Those two are written by the app rather than the editor, so Ctrl⌘+Z does not take them back; your agent sets the old value instead.

It can run the game in the Game screen and read its stdout, with every error and warning's file, line and call stack, or do a headless run for a few seconds of game time. When a script fails to parse, it gets Godot's own GDScript parse error and the line without running anything.

It can capture the running game's viewport as the player sees it, even while the Game screen is hidden, and the editor's 3D or 2D viewport. It can inject timed input events into the game: keys, mouse clicks and motion, InputMap actions and typed text, ending on a viewport capture. And it can read the running game's live scene tree, with positions, sizes, visibility and velocity, and change a node to try something out; that change lasts until the game stops and saves nothing.

On top of Godot, it gets what other Godot MCP servers do not have: Flockbay's library of ready-made models, textures and sounds to search, inspect and import under res://, and placeholder pictures, sound and music generated for the game, to swap for your own later. A 3D model is generated only on your own Tripo key. Terrain, water and a sky come from Godot plugins in the Plugins panel, the same as in any Godot project.

Godot MCP through Flockbay playtests the game, and where that stops

Playtesting here means the agent loop closes on the running game, not 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 for your first build.

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.

Three rules keep your agent from trampling your work

One AI at a time in a game. While Flockbay's own AI has a turn running in that game, your agent is told so and asked to wait until the turn ends.

Your hands win. Press a key, click or press a gamepad button while your agent is playing input, and its input stops at once, everything it held is let go, and it is told you took over. A paused game gets no input from it at all, and your real mouse and keyboard are never moved.

Some files are the app's. Your agent cannot write project.godot or the add-ons Flockbay installs, and when it tries it is told which tool to use instead. Its work lands in its own chat in Flockbay, named "Your agent", so it never mixes with a conversation you had with Flockbay's own AI.

What Godot MCP through Flockbay cannot do

It runs on Windows, macOS and Linux, and the Mac build is for Apple Silicon only.

The app has to be open with your game. The editing tools need the Godot editor open on it, which Flockbay opens with the game, and the tools that look into the game need it running. Your agent can connect before the app is open: it is told to open Flockbay, and it gets the tools as soon as the app is ready, without a restart.

It needs a free Flockbay account and an internet connection, and Flockbay is closed source. If you want a server you can read line by line, the open-source ones in the table below are the honest choice.

It does everything on Godot 4.6 or later, the engine inside the app included. Games made in Flockbay get everything. An existing Godot 4 project opened in Flockbay with Open Godot project… plays, and your agent can edit and run it. Your agent's scene tools work on the project's own scene nodes, so nothing about the project has to be converted first. A project you keep on your own older Godot 4 runs on that engine: class lookups answer from it, and Flockbay says which of its features are not available there. On Godot 3, your agent can edit the files and run the game, without the editor tools.

Godot MCP earns its keep on tasks with a check in them

Give the agent something it can verify. "Run the game, find the first error, fix it, and run it again until the log is clean." "Hold D for two seconds, then capture the viewport: does the player reach the ledge?" "List every node under the player in the running game with its velocity, then tell me why it slides after I let go."

Small and checkable beats big and hopeful. An agent that can play the game will happily confirm that the game runs. Whether it is fun is still your call, and no server changes that.

Commit to version control before a long session. Every editor change is one Ctrl⌘+Z, but a scene or resource file the agent creates stays on disk when its step is undone.

Game-skill repos such as Claude Code Game Studios and godogen write that check into their rules: a change is not done until the game has run. Over Godot MCP, the agent runs it itself. Claude Code Game Studios and godogen in a live Godot editor shows one real run of each, with the tool calls they made.

More on this: A guide to Godot MCP servers: install, connect, and use one well

Troubleshooting Godot MCP

Your agent sees one tool, and it says Flockbay is not serving. Open the Flockbay app with your game and turn on Connect your agent (MCP) in Connectors. The rest of the tools appear by themselves; you do not restart the agent.

Claude Code does not list flockbay. Run claude mcp list. If it is missing, copy the line from Flockbay again and paste it; the line registers it for your user, not for one folder.

The dialog shows a red sentence saying the connection could not start on this machine. The app ran the line itself and it failed. That sentence is the cause in the server's own words, so keep it for a bug report.

The agent is told no Godot editor is open on this game. Open the game in Flockbay. Until then your agent can still edit the files directly and do a headless run to see its errors.

The agent is told the game is not running. It starts it with Play; the tools that look at the game need a run.

The agent is told Flockbay's own AI is working in this game. A turn of Flockbay's own AI is running there. Let it finish, or press Stop in its chat, then ask your agent again.

A write is refused as owned by Flockbay. The agent reached for a file the app keeps, such as project.godot. The refusal names the tool to use instead: the settings tools for project settings, the scene tools for scenes.

Turning it on asks you to sign in. A guest account connects without one, so this means the app has no account on this computer: a session expired, or the guest account could not be made. Sign in and turn it on again.

Godot MCP servers compared, as of 29 Sep 2026

Read from each tool’s own website on 29 September 2026. Where a site does not say, the table says “Not stated”. The pages each row was read from are listed on the row.

Godot MCP servers compared, as of 29 Sep 2026, checked 29 September 2026
ServerPriceSourceRuns inEdits scenes and scriptsRuns the game, reads errorsPicturesPlays inputSetupRead from
FlockbayFree for your first build; a plan after itClosedThe Flockbay app on Windows, macOS or Linux; Godot 4.6+Yes, one Ctrl+Z per changeYes, with file, line and call stackRunning game and editor viewYes: keys, mouse, input actions, textCopy one line from the appDocs · Pricing
godot-ai (hi-godot)FreeMITYour own Godot 4.7+ editor, as a pluginYes: 46 tools, 120+ operationsYes, game and editor logsEditor views and running gameYes: keys, mouse, gamepad, timed sequencesPlugin from its GitHub releases; its dock writes your client configGitHub · Tools
godot-mcp (Coding-Solo)FreeMITYour own Godot install, launched by the serverCreates scenes and adds nodesYes, debug output and errorsNot in its tool listNot in its tool listOne npx commandGitHub
GDAI MCP$19 one-timeClosedYour own Godot 4.2+ editor, as a pluginYesYes, reads the debuggerEditor and running gameYes: keys and input actionsPlugin in the project, then a line in your client configWebsite
Godot MCP Pro$15 one-timePlugin source on GitHub; server closedYour own Godot 4.4+ editor, as a pluginYes: over 160 tools (its pages say 163 to 187)Yes, errors with stack tracesRunning gameYes: keys, mouse clicks, input actionsCopy the plugin, build the server with npm, add it to your client configWebsite · Store page · GitHub

When another Godot MCP server is the better pick

You want it free and open, in the Godot you already have: godot-ai. It is MIT licensed, runs in your own Godot 4.7 editor, and it takes pictures and plays timed input, which the older godot-mcp does not.

You want the smallest thing that runs your game and reads its errors: Coding-Solo's godot-mcp. One npx command, MIT licensed, 5,869 GitHub stars on 29 Sep 2026, and a short tool list an agent will not get lost in. Its last npm release, 0.1.1, came out in February 2026.

You want a paid plugin with a polished setup on Godot 4.2 or later, on Windows, macOS or Linux: GDAI MCP, at $19 once.

You want the longest tool list, from animation trees and particles to shaders and navigation: Godot MCP Pro, at $15 once, on Godot 4.4 or later. That breadth is also its risk, because models choose worse from long tool lists; its editor panel lets you switch tools off one by one.

Flockbay is the pick when you want your agent and Flockbay's own AI working on the same game, with Flockbay's asset library and scene tools, Godot's own editor beside them for what you would rather drag than describe, and placeholder generation. It is also the only one here that needs its own app, on Windows, macOS or Linux, and an account, and is closed source.

Questions

What is Godot MCP?
A Model Context Protocol server for Godot. It turns Godot actions, such as editing a scene, running the game or taking a picture of it, into tools an AI agent like Claude Code, Codex or Cursor can call, so the agent can check its own work instead of asking you what happened.
Is there an official Godot MCP server?
No. The release notes for Godot 4.7 list no AI features and no MCP server. Every Godot MCP server, Flockbay's included, is made by someone other than the Godot project.
Is Flockbay's Godot MCP server free?
Yes, for your first build: connecting is free with a free Flockbay account, and a plan keeps it building after that. Your agent's model is paid for wherever you already pay for it, such as your Claude or ChatGPT plan.
Which agents does it work with?
The app writes the setup for Claude Code, Codex, Cursor, Gemini CLI, Cline, Kilo Code, OpenCode, Goose, Devin Desktop and LM Studio, and for a local Ollama model through one of those. Any MCP client that can start a local server should work.
Does it work on Mac or Linux?
Linux, yes: Flockbay is an x86_64 AppImage for Ubuntu 22.04, Debian 12, Fedora 39 or newer, and it serves the same MCP server. So does the Mac build, for Apple Silicon.
Do I need Godot installed?
No. Flockbay works with Godot 4.6+ and bundles the official Godot, and your game is a normal Godot 4 project in a folder you can also open in Godot yourself.
Can I undo what my agent did?
Yes, in the editor. Each change is one step in Godot's undo history, so Ctrl+Z takes it back. Project settings and input actions are the exception: the app writes those, and the agent restores the old value instead.
Can my agent see my screen or move my mouse?
No. It takes pictures of the game and of the editor's view, not of your desktop, and the input it plays goes into the game only. Your real mouse and keyboard are not touched.
Can I use it on a Godot project I already have?
Yes. Open it in Flockbay with Open Godot project…: Flockbay asks before it adds anything, it plays, and your agent can edit and run it through the editor. Your agent's scene tools work on the project's own scene nodes, so nothing has to be converted first. A project from an older Godot can stay on your own Godot of that version, where Flockbay says which features are not available, or move to the Godot Flockbay includes. Commit it to version control first; what Flockbay adds is recorded in the project, and export leaves its add-on out of the game you ship.
Is Flockbay's MCP server open source?
No. Flockbay is closed source. Among open-source Godot MCP servers, Coding-Solo's godot-mcp and godot-ai have the most GitHub stars, and both are MIT licensed.

Free for Windows, macOS and Linux. Connecting your own agent over MCP is free for your first build, and a plan keeps it building after that.

Download Flockbay free