Reference
MCP tool reference
Every tool Flockbay’s MCP server lists to your agent once the app serves it, by group, with its arguments. Until then the server lists one tool, flockbay_status, which says what to do.
How to read this
Each row is the tool’s name as your agent calls it, what it does in the words the server gives your agent, and its arguments: each one’s name, its type as the tool’s input schema states it, whether it is required, and the first sentence of its description. The full descriptions are in the tool list your agent reads over MCP (tools/list).
Under most tables is a real call an agent made to one of the group’s tools, with the first lines of what the server answered. A group with no example has no recorded call yet.
Tools that change the game in the editor need the Godot editor open on it; tools that read the running game need it running. The Publishing tools groups (Video studio, Steam page, Website, Social posts and Ads) are listed when that feature is on for your account, and while one needs a plan or a saved account its tools answer with what it needs. Connect your agent (MCP) covers setup.
Play, run and export
Play and Stop are the app’s own, the same run the Game screen shows. The headless run and the export need no editor open.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_play | Play the game | stop_first (boolean): Stop a game that is already running and start again (default true).; wait_ms (integer): How long to watch the game after its first frame before replying; a run that ends sooner replies then.; scene (string): The res:// path of a scene in this game to run instead of the main scene, such as res://tests/playtest.tscn.; input (object): Input the game plays from its first frame: what flockbay_game_input takes (steps, wait_after_ms, screenshot, max_size, sample), with at_ms and the sample's rows counted from that frame, such as {"steps": [{"key": "W", "hold_ms": 550, "at_ms": 0}, {"key": "D", "hold_ms": 2050, "at_ms": 0}]}.; render_size (array of integer): [width, height]: the resolution the game renders at for this run, whatever the Game screen's size, such as [1920, 1080].; vsync ("on" | "off"): "off": the game draws as fast as its frame time allows, above the display's refresh rate; "on": it waits for each refresh.; seed (integer): A whole number given to Godot's seed() before any autoload's _ready and before the main scene's nodes are made, such as 7: randi, randf, Array.shuffle and pick_random then roll the same numbers each run with the same input.; fixed_fps (integer): Godot's --fixed-fps for this run: every drawn frame advances game time by exactly 1/fixed_fps s, whatever the wall clock does, so the run is the same however fast the Game screen draws.; record (string): Keep your play in this run as a recording of that name, such as "breaks-at-door": every key, mouse and gamepad event they make, stamped with its physics tick, in .flockbay/recordings/<name>.json with the run's seed and fixed step, written every second and as the run stops.; replay (string): Replay a recording: its events go back in on their ticks from the first frame, before each tick's _physics_process, with the recording's seed and fixed step unless you name your own (one kept in real time replays at the physics rate).; max_fps (integer): Godot's --max-fps for this run, 0 for uncapped, such as 0 with vsync "off" to profile what the game can draw.; profile (boolean): Start this run reporting to Godot's profiler, so flockbay_game_profile can answer for it.; creator_asked (boolean): true only when your own message asks you to load, restart or replay the game. |
flockbay_last_run | Read the game's output | since (integer): Only entries after this mark.; severity (string): "error" for errors only, "warning" for errors and warnings.; limit (number): Most entries to return, newest kept. |
flockbay_stop | Stop the game | creator_asked (boolean): true only when your own message asks you to stop the game. |
flockbay_export | Export the game and run the build | target ("windows" | "macos"): What to build for.; smoke_seconds (integer): Game seconds the exported build runs headless, at 60 frames a second, to show its errors.; preset (string): The name of one of the game's export presets in export_presets.cfg (its name= line), such as "Windows Desktop Demo". |
flockbay_run_headless | Run the game headless | scene (string): res:// path of the scene to run.; script (string): res:// path of a script that extends SceneTree (or MainLoop), run as Godot's --script in place of any scene, as godot --headless --script res://tests/traverse.gd would: its _initialize and _process drive the test, and it ends with quit(code).; seconds (integer): How much game time to run, at most 1800.; fixed_fps (integer): Game frames a second the run is stepped at, as Godot's --fixed-fps: each frame advances game time by 1/fixed_fps.; seed (integer): A whole number given to Godot's seed() before any autoload's _ready and before the main scene's nodes are made, as flockbay_play takes it, such as 7.; replay (string): A recording flockbay_play kept with record: its events go back in on their ticks from the first, with its seed and fixed step unless you name your own, so a person's play repeats with no window.; draw (boolean): Render the run instead: the game in a window of its own, off your screen and silent, beside their Play, which it never touches, for seconds of real time from when its game is up (default 120, at most 600), and two more minutes after each call to it.; size (array of integer): With draw: the window's size in pixels, [width, height].; input (object): Input the run plays from its first frame: what flockbay_game_input takes (steps, with until, walk_to and drive_to; sample; signals), answered once the run ends.; profile (boolean): Profile the whole run with Godot's own profiler and answer, after the output, the longest frames each with its process, physics and script time and the functions that took it, and every script function's self time and calls.; check ("forward"): Check the controls instead of playing input.; check_action (string): With check: the input action that moves the player forward, when it is not move_forward.; check_group (string): With check: the group the player node is in, when it is not "player". |
The running game
These read and drive the game while it runs, in the Game screen or in a headless run, and change nothing on disk. flockbay_godot_status says what is open.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_godot_status | What you can reach in Godot | None |
flockbay_game_ui | The running game's UI controls | under (string): Only the Controls under this node, such as HUD or /root/Main/Menu.; at_point (object): Where a left mouse press would go, by Godot's own routing: embedded windows (popups, dialogs) first, then the highest CanvasLayer layer and the last in the tree, mouse_filter (Stop takes it, Pass hands it to the parent too, Ignore never), clip_contents and _has_point; z_index plays no part.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_tree | The running game's scene tree | node (string): Branch to list: a path from the current scene ("Player") or from the root ("/root/Main").; depth (integer): Levels below the branch.; max_nodes (integer): Most nodes to list.; offset (integer): Start the listing at this node, counted in tree order from 0, as an earlier answer named.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_get | Read a node in the running game | node (string, required): Path from the current scene ("Player") or from the root ("/root/Main/Player").; properties (array of string): Property names to read.; sample (object): Read the properties on every physics tick (or hz times a second) for a few seconds, after the game's own _physics_process for that tick, and answer one row per reading: for anything faster than one call apart, such as a meter filling in half a second or an overlap that lasts one tick.; until (object): Wait until this holds, then read: {node, property, op, value, timeout_ms}, or {node, signal} for a signal's first emission.; signals (array of object): Signals to watch while a sample reads or an until waits, such as [{"node": "Goal", "signal": "body_entered"}]: every emission comes back with its game tick, game time and arguments, so a signal that fires for one frame is never missed.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_set | Change a node in the running game | node (string, required): Path from the current scene ("Player") or from the root ("/root/Main/Player").; properties (object, required): Property names and values.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_call | Call a method in the running game | node (string, required): Path from the current scene ("Player") or from the root ("/root/Main/Player").; method (string, required): The method's name, such as "can_see_body".; args (array of any): Arguments in the method's order.; wait_seconds (number): How long to wait for a method that awaits, in seconds.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_eval | Evaluate GDScript in the running game | expression (string): One GDScript expression, such as "Engine.get_frames_drawn()".; code (string): The body of func run(node), several lines, such as "var hit = node.get_world_3d().direct_space_state.intersect_ray(PhysicsRayQueryParameters3D.create(Vector3(0, 10, 0), Vector3(0, -10, 0)))\nreturn hit".; node (string): The node the code is given as node: a path from the current scene or from the root.; wait_seconds (number): How long to wait for code that awaits, in seconds.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_stats | The running game's performance monitors | seconds (number): Sample every frame for this many real seconds, at most 600, and answer each monitor's minimum, peak and average over them, and the frame times.; series (boolean): With seconds, also write every frame of the span to .flockbay/stats/<time>.json, one row a frame: game seconds, tick, frame ms, root viewport render CPU and GPU ms, primitives and draw calls.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_profile | Profile the running game's frames and script functions | seconds (number): How many real seconds to profile from now, at most 120.; functions (integer): How many functions to name over the span, most self time first.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_editor_screenshot | Picture of the editor's view | view ("auto" | "2d" | "3d"): Which view.; camera (object): Picture the open scene through a camera of this tool's own, such as {"frame": "Level/House", "yaw": 45, "pitch": -30} or {"position": [0, 8, 12], "look_at": [0, 0, 0]}; in 2D {"center": [0, 0], "zoom": 2}.; max_size (integer): Longest side of the picture in pixels. |
flockbay_game_input | Play input into the running game | steps (array of object, required); wait_after_ms (integer): How long to let the game run after the last input, in real ms.; wait_after_ticks (integer): The same in physics ticks, for a timeline timed in ticks.; screenshot (boolean): Return a picture of the game at the end.; max_size (integer): Longest side of the picture in pixels.; sample (object): Read a node's properties on every physics tick (or hz times a second) while the input plays, on the same clock as the steps: a row at ms 300 was read 300 ms after the timeline started, the clock at_ms counts on.; signals (array of object): Signals to watch while the input plays, from its first step to the end of its wait, such as [{"node": "Goal", "signal": "body_entered"}]: every emission comes back with its game tick, game time and arguments (a node by its path), however briefly the state it marks lasts.; verify (boolean or object): verify on every press of the timeline (each click, drag, key and action); a step's own verify, false included, wins.; stats (boolean or object): Time every frame from the first step to the end of the wait, as flockbay_game_stats does over a span, so a hitch lines up with the input that caused it: p50, p95 and p99 frame time, the worst, and the ten longest with the game time and tick each began at.; audio (boolean or object): Record the Master bus from the first step to the end of the wait and measure it, as flockbay_game_audio does over a span, so a sound lines up with the input that made it: peak, RMS and loudness, whether it clipped, and each sound that began with its time from the first step, length, peak and where its energy sits.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_screenshot | Picture of the running game | format ("jpeg" | "png"): jpeg (default): small, for how the game looks.; region (object): Only this part of the frame, in the frame's pixels (the size the game renders at, which every picture's reply names), at full resolution: to look closely at one prop, texture or edge without moving the game's camera.; max_size (integer): Scale the picture down so its longest side is at most this many pixels.; when (object): Wait for the first frame on which a condition holds, and picture that frame: {node, property, equals} for a value, or {node, property, op, value} for a threshold, such as {"node": "HUD/Health", "property": "value", "op": "<", "value": 30}.; get (array of object): Nodes to read on the frame the picture is of, such as [{"node": "HUD/Clock", "properties": ["text"]}], so the values and the picture are one moment: read as that frame is drawn, after its _process, timers and tweens.; node (string): Picture this node close instead of the whole frame: a path from the current scene ("Barry") or from the root.; margin (number): With node: the share of the picture left empty on each side of its bounds, 0 to 0.45.; yaw (number): With node, in 3D: the view's heading in degrees, as a Camera3D's rotation_degrees.y (0 looks toward -Z, 90 toward -X).; pitch (number): With node, in 3D: degrees the view looks up or down, as a Camera3D's rotation_degrees.x (-90 looks straight down).; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_time | Pause, slow or speed up the running game's time | paused (boolean): true to freeze the game on its current frame, false to resume it.; scale (number): How fast game time runs: 1 is normal, 0.1 a tenth of the speed, 2 twice as fast.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_step | Step the running game by physics ticks | ticks (integer): Physics ticks to run.; screenshot (boolean): Return a picture of the frame it stops on.; max_size (integer): Longest side of the picture in pixels.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
flockbay_game_audio | Record and measure the running game's sound | seconds (number, required): How long to record, in real seconds, at most 120.; save (boolean): Also keep the recording as a 16-bit WAV under .flockbay/audio/; the answer gives the path.; run (integer): A background run's id, from flockbay_run_headless with draw: true: ask that run's game instead of the Play's. |
Scenes and nodes
These work through the Godot editor open on the game: each change is one step of its undo history, and the scene is saved after it.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_scene_open | Open a scene | scene (string, required): res:// path of the .tscn file. |
flockbay_scene_create | Create a scene | path (string, required): res:// path for the new .tscn file, such as res://scenes/level_1.tscn.; root_type (string, required): Class of the root node, such as Node2D, Node3D, Control or CharacterBody2D.; root_name (string): Name of the root node. |
flockbay_scene_save | Save a scene | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string): res:// path to save as. |
flockbay_scene_tree | Read the scene tree | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; node (string): Path of the branch to list.; depth (integer): How many levels below the branch to list.; max_nodes (integer): Most nodes to list. |
flockbay_undo | Undo in the editor | redo (boolean): Redo instead of undo. |
flockbay_node_add | Add a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; parent (string): Path of the parent node.; type (string): Node class, such as CharacterBody2D, Sprite2D, Camera3D, or a class_name from the project.; instance (string): res:// path of a scene (.tscn, .glb, ...) to place as an instance, instead of type.; name (string): Node name.; script (string): res:// path of a script to attach.; properties (object): Property names and values.; index (integer): Position among the parent's children. |
flockbay_node_delete | Delete a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string, required): The node to delete: a path from the scene root, such as "Player/Sprite2D". |
flockbay_node_rename | Rename a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string, required): The node to rename: a path from the scene root, such as "Player/Sprite2D".; name (string, required): The new name. |
flockbay_node_move | Move a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string, required): The node to move: a path from the scene root, such as "Player/Sprite2D".; parent (string): Path of the new parent.; index (integer): Position among the new siblings.; keep_global_transform (boolean): Keep the node where it is in the world. |
flockbay_node_duplicate | Duplicate a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string, required): The node to copy: a path from the scene root, such as "Player/Sprite2D".; name (string): Name for the copy.; parent (string): Path of the parent for the copy. |
flockbay_node_get | Read a node | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string): Path of the node.; properties (array of string): Property names to read, such as ["position", "shape:size"].; all (boolean): Read every property shown in the Inspector. |
flockbay_node_set | Set node properties | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; path (string, required): The node to change: a path from the scene root, such as "Player/Sprite2D".; properties (object, required): Property names and values. |
Scripts, resources and signals
Writing a script returns Godot’s own parse or compile error with its line, and checking scripts also builds the game’s C#.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_script_read | Read a script | path (string, required): res:// path of the file. |
flockbay_script_write | Write a script | path (string, required): res:// path of the file, such as res://scripts/player.gd.; content (string): The whole file.; edits (array of object): Replacements applied in order to the current file. |
flockbay_script_errors | Check scripts for errors | path (string): res:// path of a script, a folder, or a scene or resource to check by the scripts it uses.; include_addons (boolean): Also check scripts under res://addons. |
flockbay_editor_run | Run an EditorScript in the editor | path (string, required): res:// path of the .gd file: @tool on its first line, extends EditorScript, its work in func _run(). |
flockbay_csharp_add | Add C# to the game | None |
flockbay_script_attach | Attach a script | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; node (string, required): The node: a path from the scene root, such as "Player/Sprite2D".; script (string, required): res:// path of the script. |
flockbay_resource_create | Create a resource file | path (string, required): res:// path for the file, such as res://materials/grass.tres.; type (string, required): Resource class, such as StandardMaterial3D or CapsuleShape3D.; properties (object): Property names and values.; overwrite (boolean): Replace an existing file at the path. |
flockbay_resource_read | Read a resource | path (string): res:// path of a resource file.; scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; node (string): Path of the node holding the resource.; property (string): The node's property holding it, such as "mesh" or "shape". |
flockbay_resource_set | Change a resource file | path (string, required): res:// path of the resource file.; properties (object, required): Property names and values. |
flockbay_signals | List a node's signals | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; node (string): Path of the node. |
flockbay_signal_connect | Connect a signal | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; from (string, required): The node that emits the signal: a path from the scene root, such as "Player/Sprite2D".; signal (string, required): Signal name, such as body_entered, pressed or timeout.; to (string, required): The node whose method is called: a path from the scene root, such as "Player/Sprite2D".; method (string, required): Method name on the target, such as _on_coin_body_entered.; binds (array of any): Extra values passed to the method after the signal's own arguments.; deferred (boolean): Call the method at the end of the frame.; one_shot (boolean): Disconnect after the first call. |
flockbay_signal_disconnect | Disconnect a signal | scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; from (string, required): The node that emits the signal: a path from the scene root, such as "Player/Sprite2D".; signal (string, required): Signal name, such as body_entered, pressed or timeout.; to (string, required): The node whose method is called: a path from the scene root, such as "Player/Sprite2D".; method (string, required): Method name on the target, such as _on_coin_body_entered. |
Project, files and the class reference
Project settings and input actions are written by the app, not the editor. The class reference is read from the Godot the game runs on.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_project_info | Project overview | None |
flockbay_project_files | List project files | dir (string): Folder to list, such as res://scenes.; extensions (array of string): Only these extensions, such as ["tscn", "gd"].; type (string): Only this resource type or its subclasses, such as Texture2D, AudioStream or PackedScene.; include_addons (boolean): Include res://addons. |
flockbay_project_settings | Read project settings | keys (array of string): Setting names, such as ["application/run/main_scene"].; prefix (string): Every setting project.godot names that starts with this. |
flockbay_set_project_settings | Change project settings | settings (object, required): Setting names and values, such as {"display/window/size/viewport_width": 1280}. |
flockbay_set_input_action | Set an input action | name (string, required): Action name, such as move_left or jump.; events (array of string): Keys and buttons: key names such as "A", "Space", "Left", "Shift", "Ctrl⌘+S"; "Mouse Left", "Mouse Wheel Up"; "Joypad Button 0" (Godot's numbering: 0 is the bottom face button, 9 and 10 the left and right shoulder buttons); "Joypad Axis 0-" for left stick left.; deadzone (number): Joypad deadzone.; remove (boolean): Remove the action instead. |
flockbay_class | Godot's class reference | name (string): A class, such as CharacterBody3D, or one of the game's class_name scripts.; member (string): One method, property, signal, constant or enum of it, such as move_and_slide.; query (string): Part of a class or member name to search for, such as raycast. |
flockbay_model_read | Read a model file | path (string, required): res:// path of the model, such as res://characters/hero.glb. |
flockbay_file_move | Move or rename a file | from (string, required): res:// path of the file or folder, such as res://player.gd.; to (string, required): Its new res:// path, such as res://actors/player.gd, or a folder ending in / to move it into, such as res://actors/. |
flockbay_file_delete | Delete a file | path (string, required): res:// path of the file or folder, such as res://old/enemy.gd. |
flockbay_import_settings | Read or change import settings | path (string, required): res:// path of the asset, not its .import, such as res://art/hero.png.; options (object): Options and their new values, such as {"compress/mode": 2, "process/fix_alpha_border": false}. |
flockbay_reimport | Reimport assets | paths (array of string): res:// paths of assets to import again, such as ["res://models/hero.glb"]. |
Version control
Git in the game’s folder, as the Version control panel uses it. A restore is a new commit; history is never rewritten.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_vcs_status | Version control status | None |
flockbay_vcs_commit | Commit | message (string, required): The commit message: a short subject line in the developer's own words for what they asked, then optional detail after a blank line.; authorName (string): Only when a reply asked for a name and email: the name the developer gave for their commits.; authorEmail (string): Only when a reply asked for a name and email: the email the developer gave for their commits. |
flockbay_vcs_history | Version control history | limit (integer): How many commits, 1 to 50. |
flockbay_vcs_restore | Restore to a commit | sha (string, required): The commit's sha or short hash from flockbay_vcs_history.; authorName (string): Only when a reply asked for a name and email: the name the developer gave for their commits.; authorEmail (string): Only when a reply asked for a name and email: the email the developer gave for their commits. |
Plugins
Plugins that fit the game, from the Godot Asset Store. Installing one stays your press, in Plugins.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_plugin_search | Find Godot plugins that fit this game | query (string, required): What the plugin does, in the Store's words: "dialogue", "state machine", "camera".; tag (string): A Store tag slug to narrow by, such as "2d", "3d", "ui" or "tool". |
flockbay_plugin_switch | Switch an installed plugin on or off | plugin (string, required): Its name, Store slug or folder (res://addons/<name>/).; on (boolean, required): true to switch it on, false to switch it off. |
Assets: the library and generation
The 3D model and picture tools are listed once a key for them is connected in Connectors.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_asset_search | Search the library | None |
flockbay_asset_inspect | Inspect one search result | None |
flockbay_asset_import | Bring an inspected result into the game | None |
flockbay_concept_sheet | Make one concept sheet of a new asset before it is built | name (string): The asset: letters, digits and _, starting with a letter.; brief (string, required): What the thing is and is for: its shape and parts, materials and colours, and its age and wear as far as the game's look shows wear.; referenceImagePath (string): A picture you attached. |
flockbay_generate_3d_model | Make one 3D model on your Tripo key | None |
flockbay_generate_image | Make one picture on Flockbay's image key, charged to the account's usage, or on your own OpenRouter key when they connected one | None |
flockbay_generate_sound | Make one sound effect, or with loop true one seamless ambience loop | name (string): The file name, what the sound is: coin_pickup, footstep_gravel, rain_loop.; brief (string, required): The sound itself, in the style the game's look calls for: its source and material, how it starts and decays, near or far ("a single footstep on wet gravel, close", "a chiptune coin blip, two rising notes").; intendedUse (string, required): What plays it, and when: "the player picks up a coin", "ambience in the forest level".; durationSeconds (number): Its length, 0.5 to 30 seconds.; loop (boolean): True for a seamless loop: rain, wind, a room tone, an engine hum, a crackling fire. |
flockbay_generate_music | Make one instrumental music track that loops seamlessly | name (string): The file name: title_theme, forest_level, boss_fight.; brief (string, required): The music: genre, mood, instruments and tempo, in the style the game calls for.; intendedUse (string, required): Where it plays: "title screen", "the forest level", "the boss fight".; durationSeconds (number, required): The loop's length, 10 to 180 seconds. |
flockbay_generate_voice_lines | Make a character's spoken lines, up to 8 a call | character (string, required): Who speaks, as the game names them: Blacksmith, Captain Vale, Narrator.; voice (object): What the voice is, for a character the game has not voiced yet.; recast (boolean): True only when you asked for a new voice for a character the game has already voiced.; intendedUse (string, required): Where these lines play: "the blacksmith greets the player", "the tutorial", "enemy barks in combat".; lines (array of object, required) |
flockbay_sprite_sheet_read | Read a sprite sheet | sheets (array of object, required): One or more sheets, read in this order: their cells are numbered across all of them, the first sheet's first.; pockets ("auto" | "all" | "none"): Pockets of the background's colours the art closes in (between an arm and the body, or a white eye).; format ("jpeg" | "png"): jpeg (default): small. |
flockbay_sprite_sheet_import | Import sprite sheets | sheets (array of object, required): One or more sheets, read in this order: their cells are numbered across all of them, the first sheet's first.; animations (array of object, required): Every animation the SpriteFrames will have, and nothing else: the ones it had are removed.; output (string, required): res:// path of the SpriteFrames file, such as res://characters/player/player_frames.tres.; node (string): The AnimatedSprite2D (or AnimatedSprite3D, Sprite2D, Sprite3D) to draw the new frames: a path from the scene root, such as "Player/Sprite2D".; scene (string): res:// path of the scene to work in; it is opened in the editor if needed.; align ("bottom" | "center" | "cell"): Where each frame's art sits.; frame_height (integer): Scale every frame to this height in pixels, keeping its shape: by whole pixels when the scale is a whole number or its inverse, Lanczos otherwise.; pockets ("auto" | "all" | "none"): Pockets of the background's colours the art closes in (between an arm and the body, or a white eye).; overwrite (boolean): Replace a PNG already at the frames' path that this SpriteFrames does not use.; format ("jpeg" | "png"): jpeg (default): small. |
3D models and Blender
Models built from a spec on your computer, and Blender run in the background. Blender downloads the first time a tool needs it.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_build_model | Build a 3D model | spec (object): The model spec: name, triangles, materials and parts.; path (string): Instead of spec: the res://assets/Models/<name>/<name>.model.json of a model already in the game, to rebuild it after that file was edited. |
flockbay_model_guide | Guide to building a 3D model | None |
flockbay_blender_run | Model in Blender | name (string): The asset: its scene is res://assets/Models/<name>/source/<name>.blend, made empty (metres, Z up) on first use.; file (string): A .blend of the developer's anywhere in this game (res://...), opened instead of an asset's own scene and saved in place after the call, Blender keeping the version before as <file>.blend1.; script (string): The asset's build script, a Python file in this game: res://assets/Models/<name>/source/<name>.py.; code (string): Python run in the asset's scene, with bpy, bmesh, mathutils and math imported, after the script when both are given.; save (boolean): true: keep code as a script and run it from there: the asset's build script (res://assets/Models/<name>/source/<name>.py), or the .py under res://assets/Models/ that script names (the game's helpers, res://assets/Models/blender_helpers.py), replacing it.; import (string): A .glb, .gltf, .fbx, .obj or .blend in this game (res://...) to bring into the scene before the script and the code run.; timeoutSeconds (number): How long the work in Blender may take, in seconds: 120 when left out, 900 at most (a large bake). |
flockbay_blender_look | Look at the model in Blender | name (string): The asset: its scene is res://assets/Models/<name>/source/<name>.blend, made empty (metres, Z up) on first use.; file (string): A .blend of the developer's anywhere in this game (res://...), opened instead of an asset's own scene and saved in place after the call, Blender keeping the version before as <file>.blend1.; views (array of "front" | "back" | "side" | "right" | "left" | "top" | "bottom" | "three_quarter"): Views to render: front, side, three_quarter and top when left out (three_quarter for a clip).; wire (boolean): Draw the mesh wire over the shading.; clip (object): Render frames across one NLA track, one row per view, instead of a still.; size (integer): Edge of one tile in pixels: 512 when left out.; reference (string): A picture in this game (res://..., PNG or JPG), such as the approved concept sheet in the asset's source/ folder, shown as the top row of the contact sheet, above the renders.; timeoutSeconds (number): How long the work in Blender may take, in seconds: 120 when left out, 900 at most (a large bake). |
flockbay_blender_land | Put the Blender model in the game | name (string, required): The asset: its scene is res://assets/Models/<name>/source/<name>.blend, made empty (metres, Z up) on first use.; as (string): The model's name in the game, its folder and file name: the asset's name when left out.; timeoutSeconds (number): How long the work in Blender may take, in seconds: 120 when left out, 900 at most (a large bake). |
flockbay_build_in_background | Build the model in the background | name (string, required): The asset: its scene is res://assets/Models/<name>/source/<name>.blend, made empty (metres, Z up) on first use.; brief (string, required): What the model's own chat builds, as a message to it: the model and what it is for, the approved concept sheet's res:// path, the stand-in's res:// path (its .glb), the name it lands under, and what to keep from the game's look. |
flockbay_blender_guide | Guide to modelling in Blender | None |
Guides and agents
Flockbay’s guides and the briefs of its agents, such as the Playtester, for your agent to read before it works.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_guide | Read a Flockbay guide | name (string, required): The guide to read, such as godot_craft. |
flockbay_agent_brief | Read a Flockbay agent's brief | name (string, required): The agent, such as Playtester. |
Playtests
What came back from the people who played this game’s playtest links.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_playtest_reports | Read the game's playtest reports | report (string): A report's id from the list, such as rpt_1791425524516_0042: that report in full.; session (string): A session's id from the list, such as pts_6f0c...: its errors, grouped.; error (string): With session: an error's signature exactly as the session lists it.; build (string): One playtest link's build id (play_...), to list only its sessions and reports.; since (string): An ISO date or time, such as 2026-10-07: the list keeps only what came after it. |
flockbay_playtest_replay | Replay a tester's session | report (string): A report's id from flockbay_playtest_reports: replayed to the moment the tester reported.; session (string): With error or tick: the session the error or the press is in.; error (string): With session: an error's signature exactly as flockbay_playtest_reports lists it.; tick (integer): With session: a dead click's, rage click's, thrashed cursor's or link's tick exactly as flockbay_playtest_reports lists it: replayed to the tick before it.; creator_asked (boolean): true only when your own message asks you to replay the tester's session. |
Video studio
Devlogs, shorts, trailers and ad cuts, rendered on your computer. Listed when Video studio is on for your account.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_devlog_guide | Guide to making a devlog | None |
flockbay_devlog_voice | Voice the devlog's script | lines (array of string, required): The script's lines, in order.; voice (string): The voice's id, fbv_...; leave out for the first in the catalogue.; ownVoice (string): The creator's own ElevenLabs voice ID, when they gave one, instead of voice.; first (integer): The number of the first take, to re-voice from that line on. |
flockbay_devlog_music | Make the devlog's music bed | prompt (string): The music: genre, mood, instruments, and its tempo as "100 BPM", which the grid is checked against.; seconds (number): How long the bed runs.; name (string): The file's name, e.g.; path (string): A bed already on this computer (one made earlier, or your own music file): its grid is measured, and no music is made.; bpm (number): With path: the tempo the music is in, when it is known. |
flockbay_devlog_capture | Film a take of the game | ride (string, required): The take's name; its file is rides/<ride>.mp4.; seconds (number, required): How long the movie runs, in seconds: at most 5400 frames, so 180 at 30 fps and 90 at 60.; fps (integer): The movie's frames a second, such as 60 for a smooth clip.; scene (string): res:// path of the scene the ride runs in place of the main scene, such as res://levels/two.tscn.; stills (array of number): Game seconds whose frames are kept whole as PNGs beside the movie, such as [5, 60]; the answer gives their paths.; input (object): A timeline played from the ride's first frame, as flockbay_game_input takes it: steps with walk_to, drive_to, until, actions and keys, sample and signals.; aspect (string): The frame as width:height.; steps (array of array of number or string): Timed actions: [seconds, action] or [seconds, action, hold seconds], with the game's own input actions.; driver (object): A driver's settings for this game, as the guide gives them.; drive (object): This ride's drive: how fast, what to try.; stage (array of object): Staging for the shot, done in the copy: moments, each at a game second or after the moment held, setting properties, calling methods and easing properties.; when (object): The moment the take waits for: read every frame from game second from to to, the game playing eight times faster until it holds and at its own speed after.; setup (string): GDScript with func run(scene), run once in the copy before the first frame, the game's autoloads in scope by name: it builds a state through the game's own functions (the late game a player reaches after hours) for the take to play on from, with when to wait until it comes alive.; dry (boolean): Play the take at the filming's own fixed step without writing a movie: what it shows is what gets filmed.; seed (integer): A whole number given to Godot's seed() before any autoload's _ready and the main scene, so a dry run and the filming of the same ride roll the same numbers, such as 7.; replay (string): A recording flockbay_play kept with record: the ride plays the person's events on their ticks, with the recording's seed unless you name one, in place of steps or a driver. |
flockbay_devlog_frames | Frame sheet and measurements of a ride | clip (string, required): The ride's file, as flockbay_devlog_capture returned it, or a video in the game as res://path.; from (number): Seconds into the ride to start at.; to (number): Seconds into the ride to stop at.; every (number): Seconds between frames on the sheet.; crop (string): A cell of the 4x4 grid, such as C2: the sheet shows that part of the frame at full size, as many times as fit spread over the span (or every seconds apart), in place of whole frames. |
flockbay_devlog_cut | Submit the devlog's cut | cut (object, required): The cut, in the guide's format.; draft (boolean): true to check the cut before its voice and music are made: every rule but those that need a take or a bed not made yet. |
flockbay_devlog_render | Render the devlog | thumbnailShot (integer): The shot the thumbnail is taken from, at its middle. |
flockbay_shorts_guide | Guide to making shorts | None |
flockbay_shorts_cut | Submit the shorts' cut | cut (object, required): The cut, in the Shorts guide's format.; draft (boolean): true to check the cut before its voice and music are made: every rule but those that need a take or a bed not made yet. |
flockbay_shorts_render | Render the shorts | None |
flockbay_trailer_guide | Guide to making a trailer | None |
flockbay_trailer_cut | Submit the trailer's cut | cut (object, required): The cut, in the trailer guide's format.; draft (boolean): true to check the cut before its voice and music are made: every rule but those that need a take or a bed not made yet. |
flockbay_trailer_render | Render the trailer | thumbnailShot (integer): The shot the thumbnail is taken from, at its middle. |
flockbay_video_thumbnail | Set the thumbnail | pick (integer, required): The candidate's number on the review sheet. |
flockbay_ad_cuts_guide | Guide to making ad cuts | None |
flockbay_ad_cuts_cut | Submit the ad cuts' cut | cut (object, required): The cut, in the ad cuts guide's format.; draft (boolean): true to check the cut before its voice and music are made: every rule but those that need a take or a bed not made yet. |
flockbay_ad_cuts_render | Render the ad cuts | None |
Steam page
The game’s Steam page in Flockbay’s window, drafted field by field. Listed when Steam page drafting is on for your account.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_steam_guide | Guide to drafting the Steam page | None |
flockbay_steam_draft_get | Read the Steam page | None |
flockbay_steam_frame | Keep a frame for the Steam art | when (object): Wait for the first frame on which a condition holds, and picture that frame: {node, property, equals} for a value, or {node, property, op, value} for a threshold, such as {"node": "HUD/Health", "property": "value", "op": "<", "value": 30}.; hide (array of string): Nodes of the game hidden for this picture and shown again after it, such as ["HUD/Toasts", "HUD/Alerts"]: a pop-up, a warning, a tutorial hint or the HUD itself. |
flockbay_steam_screenshot | Take a Steam screenshot | when (object): Wait for the first frame on which a condition holds, and picture that frame: {node, property, equals} for a value, or {node, property, op, value} for a threshold, such as {"node": "HUD/Health", "property": "value", "op": "<", "value": 30}.; hide (array of string): Nodes of the game hidden for this picture and shown again after it, such as ["HUD/Toasts", "HUD/Alerts"]: a pop-up, a warning, a tutorial hint or the HUD itself.; add (boolean): false keeps the screenshot as a frame and does not add it to the page.; frame (string): Add this kept frame (its file name, as a reply named it) instead of taking a new picture. |
flockbay_steam_trailer | Put the trailer on the Steam page | path (string): A video file, as flockbay_trailer_render returned it. |
flockbay_steam_art | Make the Steam art from a frame | frame (string): A frame flockbay_steam_frame or flockbay_steam_screenshot kept, by its file name or path.; focus (object): Where the subject is in the frame, 0 to 1 across and down.; title (string): The title set on the art. |
flockbay_steam_draft_set | Write one field of the Steam page | field ("name" | "developer" | "genre" | "shortDescription" | "tags" | "price" | "features" | "languages" | "longDescription" | "systemRequirements" | "contentRating" | "aiDisclosure" | "legal", required): The field to write.; value (string or array of string or object or array of object or null, required): The field's new value, in the shape the field takes. |
Steam numbers
The game’s public Steam numbers, read once a day.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_steam_numbers_get | Read the game's Steam numbers | None |
flockbay_steam_store_page_link | Link the game's Steam store page | store (string, required): The store page address, like https://store.steampowered.com/app/1234560/Your_Game/, or the app id. |
Website
The game’s website in its website/ folder. Publishing stays your press. Listed when the website is on for your account.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_website_guide | Guide to building the game's website | None |
flockbay_website_assets | List or copy the game's material for its website | copy (array of string): Ids from the listing to copy into website/assets/. |
flockbay_website_capture | Look at the website | width ("desktop" | "phone"): desktop (1440 px, the default) or phone (390 px). |
flockbay_website_check | Check the website | None |
Social posts
Drafts in the Social posts queue, for you to approve. Listed when Social posts are on for your account.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_publishing_guide | Guide to planning posts | None |
flockbay_publishing_queue_get | Read the Social posts queue | None |
flockbay_publishing_post_draft | Draft a post | video (string, required): Full path of an MP4, MOV or WebM on this PC, such as a video Video studio made.; kind (string, required): What the video is: short, devlog or clip.; title (string): The title; YouTube shows it, at most 100 characters.; caption (string, required): The caption every platform gets unless captions names its own.; platforms (array of "tiktok" | "youtube" | "instagram" | "x", required): The platforms to post to.; captions (object): A caption per platform, where it differs.; modes (object): The choice a platform asks for.; time (string): When it should go out, ISO 8601 with its offset.; timezone (string): The creator's IANA timezone, such as America/Toronto. |
Ads
Ad campaigns drafted on your own ad accounts. Launch stays your press. Listed when Ads are on for your account.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_ads_guide | Guide to drafting ads | None |
flockbay_ads_get | Read the ads | None |
flockbay_ads_targeting_search | Search ad targeting | accountId (string, required): The connection's id from flockbay_ads_get.; dimension ("interest" | "behavior" | "community" | "conversationKeyword" | "geo", required): What to search.; q (string, required): The name to search for, such as roguelikes or Toronto.; countryCode (string): Two-letter country code to scope a place search. |
flockbay_ads_campaign_draft | Draft an ad | campaignId (string): A draft to change, from flockbay_ads_get.; network ("meta" | "google" | "tiktok" | "reddit"): The ad platform.; accountId (string): The connection's id from flockbay_ads_get.; adAccountId (string): The ad account it runs on, from that connection's ad accounts.; name (string): The campaign's name, as you sees it in their Ads Manager.; goal (string): The objective: traffic, awareness, video_views or engagement, as the ad platform takes it.; budget (object); startsAt (string): ISO 8601 with its offset; omit to start at launch.; endsAt (string): ISO 8601 with its offset; a lifetime budget needs one.; targeting (object); headline (string): The headline: the hook, not the game's name.; body (string): The primary text.; callToAction (string): The call to action, such as LEARN_MORE, PLAY_GAME, DOWNLOAD or SHOP_NOW.; link (string): The destination URL: the Steam store page, the web build or the itch.io page.; video (string): Full path of an MP4, MOV or WebM on this PC (a Video studio cut), or a web address.; image (string): Full path of a PNG, JPEG or WebP on this PC, or a web address.; thumbnail (string): A picture for a video ad's first frame; Reddit asks for one.; aiGenerated (boolean): True when the ad's narration, music, art or video was generated.; label (string): The creative's name as you sees it, such as Ad cut A.; variants (array of object): Only when you asks for variants in their own words: up to four more creatives in this campaign, each its own ad under the one budget (Meta, TikTok, Google; Reddit runs one ad per campaign).; google (object): Google Search: keywords, 3 to 15 headlines and 2 to 4 descriptions.; postId (string): A published Social post to boost instead of a new ad. |
Market research
Comparable Steam games, their estimated sales range and the hit rate for a set of tags.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_market_comps | Find comparable Steam games | tags (array of string): Steam tags, most defining first, copied exactly from Steam's tag list (call with no tags to get the list): "Farming Sim", "Roguelike Deckbuilder".; terms (array of string): Words a store page for this game would use that the tags do not cover: its setting, hook and core verbs.; line (string): The idea in one sentence. |
flockbay_market_game | Read one Steam game's market facts | appId (integer, required): The game's Steam app id, from its store link or flockbay_market_comps. |
flockbay_market_odds | Read the hit rate for Steam tags | tags (array of string, required): Steam tags, most defining first, copied exactly from Steam's tag list (call with no tags to get the list): "Farming Sim", "Roguelike Deckbuilder". |
Growth plan
The game’s growth plan, kept on your computer.
| Tool | What it does | Arguments |
|---|---|---|
flockbay_growth_guide | Read the growth plan guide | None |
flockbay_growth_plan_get | Read the game's growth plan | None |
flockbay_growth_plan_save | Save the game's growth plan | goal (string, required): The goal in your words, like "7,000 wishlists before Next Fest in February".; metric (string, required): What is counted: wishlists, players, followers, or what you named.; target (number or null): The number to reach, when the goal has one.; by (string or null): The goal's date, YYYY-MM-DD.; summary (string): One or two lines: the pace now against the pace the goal needs.; steps (array of object, required) |
flockbay_growth_step_done | Mark a growth plan step done | stepId (string, required): The step's id, from flockbay_growth_plan_get.; done (boolean): False to mark it not done. |