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_model_read: reads a model file in the game the way Godot loads it: its height, which way it faces, triangles, materials and textures, bones and animations.

flockbay_blender_run: runs Python in a background Blender, one scene per asset, kept in your project under assets/Models/<name>/source/: new hard-surface models built from their approved concept sheet, animation clips for any rig, finishing a model from elsewhere, and high-to-low bakes. Blender (about 400 MB) downloads from blender.org the first time it is needed.

flockbay_blender_look: renders an asset's Blender scene from several views, or across one animation clip, and returns the contact sheet.

flockbay_blender_land: exports the scene to assets/Models/<name> as a .glb, replacing an earlier model of that name (a flockbay_build_model spec of that name moves into the folder's source/), imports it, lists it in Place and returns Godot's own read of it: meshes, triangles, materials and their maps, bones, clips and size, with what looks wrong.

flockbay_blender_guide: the guide to the Blender tools: when to use Blender rather than flockbay_build_model, the game-ready rules and tried code idioms. Your agent reads it before its first Blender call.

flockbay_concept_sheet: makes a concept sheet for a new asset before it is built: one picture of it alone on a plain background, from the front, side, back and three-quarter, for you to approve its look. It is made on Flockbay's image key and counts against the day's free usage, so it needs no key of yours. The sheet lands in assets/Models/<name>/source/, where Godot never imports it, and is the reference your agent builds the model against; a new sheet for the same asset keeps the one before.

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_class: Godot's class reference from the bundled engine: a class's inheritance, properties with defaults, method signatures, signals, enums and constants, one member, or a search by name. The game's own class_name scripts answer too.

flockbay_file_move: moves or renames a file or folder as Godot's FileSystem dock does, its .import and .uid with it so references by UID follow, and lists what still names the old path.

flockbay_file_delete: deletes a file or folder to the system's trash, and lists the scenes and resources that now point at nothing.

flockbay_import_settings: reads an asset's import settings as the Import dock shows them, such as texture compression or a model's scale, or changes them and reimports it.

flockbay_reimport: has the editor import assets again, such as a model rebuilt in Blender or one whose .import you edited, and answers when the import is done with what the importer reported.

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 or a shader and returns Godot's own parse or shader compile error with its line.

flockbay_script_errors: checks one script or shader, or every script and shader 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_editor_run: runs an EditorScript in the editor, as File > Run does, for a batch edit such as renaming many nodes or baking navigation. Its undoable changes are one step, and the answer has what it printed, its errors and the files it changed.

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. With draw, it renders the game in a window off your screen, beside your Play and without touching it, for your agent's pictures and readings.

flockbay_game_screenshot: a picture of the running game as the player sees it, even while the Game screen is hidden, or of the first frame on which a node's property takes a value, such as the frame an alert icon appears. It can read node properties on the frame it pictures, so a value and the picture agree. It returns the frame at the resolution the game renders, as JPEG or lossless PNG, or one region of it at full resolution. Given a node, it pictures that node close, framed by a camera of its own in the game's world, so a character across the level fills the picture and nothing in the game moves.

flockbay_editor_screenshot: a picture of the editor's 3D or 2D view at its current camera, or of the open scene through a camera of its own, framed on a node, whatever screen you are on and without moving your view.

flockbay_game_input: plays keys, mouse clicks and moves, mouse look, joypad buttons and stick tilt, input actions and typed text into the running game with timing, clicks a menu button by its text, 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, once or on every physics tick for up to two minutes, along with what methods return on each tick, such as a bone's pose; a long read is written to a file with each column's range and mean.

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

flockbay_game_call: calls a method on a node in the running game, such as a function from one of its scripts, and returns what it answers. Whatever the method changes lasts until the game stops.

flockbay_game_time: pauses or resumes the running game, or slows its time down or speeds it up. Your own key presses and clicks in the game, or Resume in its Esc menu, end the agent's pause.

flockbay_game_step: advances a paused game by an exact number of physics ticks and holds it on that frame, with a picture if asked, to look at something that lasts one tick.

flockbay_game_stats: reads Godot's performance monitors in the running game, as the Monitors tab names them: primitives and draw calls, nodes, memory, frame and render times, shader and pipeline compiles, physics, navigation, audio bus levels and the game's own custom monitors. Over a span it samples every frame and gives the minimum, peak and average, so a one-frame spike is caught, and times every frame itself: p50, p95 and p99 frame time, and the worst frames with the game time each came at.

flockbay_game_eval: runs GDScript in the running game, an expression or a few lines, and returns what it answers: an engine value, a raycast, a navigation path. Nothing is written to the project.

flockbay_game_ui: lists the UI controls showing in the running game, with their text, where they are and whether they are disabled.

flockbay_export: exports the game the way Ship > Export does into a local test build, then runs the build headless and returns its errors, for failures only an export shows.

flockbay_game_profile: says where the running game's frame time goes, from Godot's own profiler: the longest frames with their process, physics and script time and the functions that took it, and every script function's self time and calls. For a run started with profile.

flockbay_game_audio: records the running game's Master bus for a span and says what it sounded like in numbers: peak and RMS level, integrated loudness, whether it clipped, and each sound that began, with its time, length, peak and where its energy sits. flockbay_game_input records the same while input plays, so a sound lines up with the key that made it.

On Windows the app takes two flags, for an agent or a script that wants a game without anyone at the window: flockbay-desktop.exe --open-game <folder> --your-own-agent on. --open-game opens the game in that folder in the editor, and makes a new one there when the folder is empty or missing (add --2d for a 2D game); a Godot project already there is added to Flockbay. --your-own-agent on turns the connection on for that game, as Turn on does, and the command prints the same setup line Connectors shows. With the app already running, the command hands both to it. No link can do this: it works only from a command line on your own machine.