Connect your own agent

The Flockbay app runs an MCP server that hands your agent the tools to build in the game you have open: the world tools, the library, and a line into the Godot editor and the running game. Your agent can edit scenes and scripts with undo, run the game, read its errors, look at it and play it. Every tool is listed below.

MCP is the Model Context Protocol. It is a shared standard, not something we invented for this feature, and the server is an ordinary one: any MCP client that can start a local server can be pointed at it. The app writes the setup for eleven of them: Claude Code, Cursor, Codex, Gemini CLI, Cline, Kilo Code, OpenCode, Goose, Devin Desktop and LM Studio, and a local model through Ollama by way of one of those.

This is the reverse of building on your Claude or ChatGPT plan inside the app. There, your plan powers Flockbay’s own chat. Here, your agent stays where it is and reaches into your project.

A connected agent gets the tools listed below and nothing else. The world tools are six in a 3D world and four in a 2D one, which has no water or weather. The tools that change scenes, scripts, resources and signals work through the Godot editor, so they need the game open there; the tools that look into the game need it running.

It cannot change what the app keeps for itself: the files the app generates for the world, the add-ons it installs, the builder's own files and the project settings file. It changes the world with the world tools and project settings with the settings tools instead, and when it asks for something it cannot have, it is told why in words it can act on.

Work done by your agent lands in its own chat, named "Your agent", so it is never mixed up with a conversation you had with Flockbay.

The connection stays on until you turn it off. Quitting the app closes it, and the app opens it again for whichever game you open next, so you never paste the setup twice. End it at any time with Turn off.

Nothing. Your agent runs on your own machine with your own model and your own subscription, so the tokens it spends are paid to whoever provides that model. Flockbay charges nothing for the connection itself.

Building in Flockbay’s own chat is free too, on your Claude or ChatGPT plan or on your own API key.

Flockbay never starts the game under you while you build. If you have used the builder since your agent last asked to play, the game does not start: the chat offers you Play instead, and your agent is told why. Pictures of the game and of the editor never move your screen, and a headless run never opens a window.

Your hands win. If you press a key, click or press a gamepad button while your agent is playing input into the game, its input stops at once, everything it was holding is let go, and it is told you took over. A paused game, because you are on another screen or in the Esc menu, gets no input from it at all.

Every editor change is one Ctrl+Z. Each change your agent makes through the editor 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. A new scene or resource file stays on disk when its step is undone, and project settings and input actions are written by the app, not the editor, so Ctrl+Z does not take them back.

stage_terrain: the ground, real landscape in a 3D world and tiled ground in a 2D one.

stage_water: an ocean the land cuts into. 3D worlds only.

stage_environment: the sky and the light.

stage_weather: rain or snow over time. 3D worlds only.

stage_player: the player, how it moves and how the camera follows it.

stage_placed_objects: individual objects at exact positions.

flockbay_asset_search: searches Flockbay's library of ready-made models, textures and sounds, in plain words.

flockbay_asset_inspect: looks at one result and the files it would bring in, with its licence. Nothing in the game changes.

flockbay_asset_import: brings an inspected result into the game.

flockbay_generate_3d_model: makes a 3D model on your own Tripo key.

flockbay_generate_image: makes a picture on a key you add.

flockbay_generate_sound: makes a sound effect on your own ElevenLabs key.

flockbay_build_model: builds a rigged, game-ready 3D model from a spec of blended shapes, on your computer, with no key and no cost. It lands in assets/Models with its materials, and the reply carries a picture of it.

flockbay_model_guide: the guide to flockbay_build_model: the spec format and how to check a build. Your agent reads it before its first build.

flockbay_status: whether the app is serving your agent, what to do if it is not, and how to use the tools once it is. Until the app serves your agent, it is the only tool listed.

flockbay_godot_status: whether the Godot editor is open on this game and whether the game is running, and what to do when either is missing.

flockbay_project_info: the main scene, renderer, window size, autoloads, input actions, named layers, script classes and plugins.

flockbay_project_files: the game's files as Godot sees them, with their resource types.

flockbay_project_settings: reads project settings by name or prefix.

flockbay_set_project_settings: changes project settings and autoloads. The app writes them, never the editor.

flockbay_set_input_action: creates, replaces or removes an input action, with its keys, mouse buttons and gamepad buttons and sticks.

flockbay_undo: undoes or redoes the last change in the editor, exactly like Ctrl+Z, including a change you made by hand.

flockbay_scene_open: opens a scene in the editor.

flockbay_scene_create: creates a scene with one root node, saves it and opens it.

flockbay_scene_save: saves the scene, or a copy of it under a new path.

flockbay_scene_tree: the scene's nodes, with their classes, scripts, instances and changed properties.

flockbay_node_add: adds a node of any class, or an instance of a scene, with a name, a script and properties.

flockbay_node_delete: deletes a node and its children.

flockbay_node_rename: renames a node.

flockbay_node_move: moves a node to another parent or position, keeping its place in the world.

flockbay_node_duplicate: duplicates a node with its children.

flockbay_node_get: a node's changed properties and script variables, or any property named.

flockbay_node_set: changes a node's properties. If any value is wrong, nothing changes.

flockbay_script_read: reads a GDScript or shader file.

flockbay_script_write: creates or edits a script and returns Godot's own parse error with its line.

flockbay_script_errors: checks one script, or every script in the game, for errors without running it.

flockbay_script_attach: attaches a script to a node, or takes it off.

flockbay_resource_create: creates a resource file, such as a material, a mesh or a collision shape.

flockbay_resource_read: reads a resource file, or a resource stored in the scene.

flockbay_resource_set: changes a resource file. Every node that uses it sees the change.

flockbay_signals: a node's signals and their saved connections.

flockbay_signal_connect: connects a signal to a method, saved with the scene.

flockbay_signal_disconnect: removes a saved connection.

flockbay_play: plays the game in the Game screen, as Play does, and reports its first moments: what it printed, and its errors and warnings with file, line and call stack.

flockbay_last_run: what the running or last game printed, and every error and warning since it started, or since a mark.

flockbay_stop: stops the game.

flockbay_run_headless: runs the game with no window for a few seconds of game time and returns what it printed. It needs no editor and leaves your screen alone.

flockbay_game_screenshot: a picture of the running game as the player sees it, even while the Game screen is hidden.

flockbay_editor_screenshot: a picture of the editor's 3D or 2D view at its current camera.

flockbay_game_input: plays keys, mouse clicks and moves, input actions and typed text into the running game with timing, and can end with a picture. Your real mouse and keyboard are not touched.

flockbay_game_tree: the running game's nodes right now: positions, sizes, visibility and velocity.

flockbay_game_get: reads any property of a node in the running game.

flockbay_game_set: changes a node in the running game to try something out. Nothing is saved; the change lasts until the game stops.