Allows exporting Godot projects to the Android platform.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@godot-mcp-bridge create a new 2D scene with a sprite and attach a movement script"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Free, open-source (MIT) MCP server + Godot 4 editor addon that lets AI assistants (Claude Code, etc.) drive the Godot editor and running games: create scenes, edit scripts, simulate input, screenshot gameplay, run test scenarios — 174 tools.
Verified end to end against a real Godot 4.6 editor: a full playable 2D game (scenes, scripts, input map, physics, HUD) was built through these tools alone, then played to completion with simulated input. Sibling project: aseprite-mcp-bridge.
Claude / MCP client ── stdio ── godot-mcp-bridge (Node, LISTENS on ws://127.0.0.1:6505-6509)
▲
│ WebSocket JSON-RPC 2.0 — the addon DIALS OUT
Godot editor addon (GDScript)
│ file IPC in the game's user:// dir
running game (3 injected autoloads)The bridge listens; the addon dials in and redials every 3s. Start order never matters, and either side can restart without breaking the other. Ports 6505-6509 mean up to 5 Claude sessions can talk to one editor at once.
Related MCP server: Gear
Two one-time steps. After that there is nothing to launch by hand — ever.
git clone https://github.com/rezaahmadn/godot-mcp-bridge.git
cd godot-mcp-bridge
npm install && npm run buildClaude Code, available in every directory:
claude mcp add --scope user godot -- node /absolute/path/to/godot-mcp-bridge/dist/index.jsOr add it to a project's .mcp.json by hand:
{ "mcpServers": { "godot": { "type": "stdio", "command": "node",
"args": ["/absolute/path/to/godot-mcp-bridge/dist/index.js"] } } }mkdir -p /path/to/YourGame/addons
cp -R addons/godot_mcp_bridge /path/to/YourGame/addons/ # or symlink itThen in Godot: Project → Project Settings → Plugins → enable "Godot MCP Bridge". The bottom panel shows the connection status. The plugin registers three autoloads it needs to inspect a running game; it removes them again when you disable it.
Open Godot. Open Claude Code. That's it. No command to type, no server to start.
Claude Code spawns the bridge itself (stdio) when a session starts; the addon in your project dials it as soon as the editor is running. If Godot is not open, the tools simply answer [-32003] Godot editor not connected instead of hanging.
To confirm it is live: claude mcp list should show godot: ✔ Connected (that only means the bridge process is healthy — the editor connection shows in Godot's MCP Bridge bottom panel).
Env var | Default | Purpose |
| — | pin one exact port instead of scanning |
|
| first port of the scan range |
|
| how many ports to try |
|
| bind address (localhost only by design) |
|
| default per-request timeout |
174 across 25 categories: project, resource, scene, scene_3d, node, script, shader, editor, input, input_map, test, runtime, animation, animation_tree, tilemap, navigation, theme, audio, physics, particles, batch, analysis, profiling, export, android. Full inventory in SPEC.md §6.
Gotchas worth knowing:
Project settings use their full key — application/run/main_scene, not run/main_scene. A wrong key silently creates a new custom setting that Godot ignores.
Compound values travel as strings: "Vector2(64, 32)", "#ff0000".
execute_editor_script refuses filesystem-writing APIs unless you pass allow_unsafe_editor_io: true.
Symptom | Cause |
| Godot isn't running, or the plugin isn't enabled in this project |
Tools work but game tools say "Game is not running" | the game crashed on launch — check Godot's Output panel, or run the project directly |
Nothing connects | another Godot editor is already holding the ports; close stray editors |
npm run typecheck && npm test # transport + contract tests
npm run dev # run the bridge from sourceBuilt spec-first: SPEC.md is the master contract and specs/ holds self-contained work packages, each implemented and reviewed in parallel.
MIT — see LICENSE. Clean-room implementation: the tool surface is API-compatible with a commercial product; all code is original.
Append a track to an animation, targeting a node property path relative to the AnimationPlayer root node (e.g. Sprite2D:position)
Inputs: animation (required), node_path (required), track_path (required), track_type, +1 more.
Add an audio bus to the AudioServer; changes live audio state; save the bus layout manually to persist
Inputs: name (required), mute, send, solo, +2 more.
Add an audio effect to a bus's effect chain; changes live audio state; save the bus layout manually to persist
Inputs: bus (required), effect_type (required), params, at_position.
Add an AudioStreamPlayer, AudioStreamPlayer2D or AudioStreamPlayer3D under a parent node in the edited scene
Inputs: name (required), node_path (required), bus, type, +7 more.
Register a scene or script as an autoload singleton and save project settings
Inputs: name (required), path (required).
Create or reconfigure a GridMap with a MeshLibrary and paint cells; painted cells are not undoable
Inputs: name, cells, position, cell_size, +3 more.
Add a MeshInstance3D using a primitive mesh_type or a mesh loaded from mesh_file; rotation is in degrees
Inputs: name, scale, position, rotation, +4 more.
Add a node of a ClassDB class or project class_name script under a parent in the edited scene
Inputs: type (required), name, properties, parent_path.
Add a RayCast2D/3D child whose target_position is in the raycast's local space (pixels in 2D, metres in 3D)
Inputs: node_path (required), name, enabled, target_x, +7 more.
Create a Resource subclass instance and assign it to a node property
Inputs: property (required), node_path (required), resource_type (required), resource_properties.
Instance a packed scene as a child node of the currently edited scene
Inputs: scene_path (required), name, parent_path.
Add a state (animation, blend tree or nested state machine) to an AnimationTree state machine at a graph position
Inputs: node_path (required), state_name (required), animation, position_x, +3 more.
Add a transition between two states (Start/End accepted) with switch mode, advance mode and an optional advance expression that needs advance_expression_base_node set on the AnimationTree
Inputs: to_state (required), node_path (required), from_state (required), xfade_time, +4 more.
Report node count, max depth, per-class histogram, attached scripts and complexity warnings for a scene file or the edited scene
Inputs: path.
Map every connected signal in the currently edited scene, grouped by emitter node with target and method
Inputs: no named parameters.
Apply a tuned particle preset (node params plus a fresh material) sized for the node's 2D or 3D dimension
Inputs: preset (required), node_path (required).
Assert a property of a node in the running game against an expected value using the given operator
Inputs: property (required), node_path (required), expected, operator.
Assert that text is visible in any Control element of the running game
Inputs: text (required), partial, case_sensitive.
Wrap a shader in a new ShaderMaterial and assign it to a node in the edited scene
Inputs: node_path (required), shader_path (required).
Attach an existing script resource to a node in the edited scene
Inputs: node_path (required), script_path (required).
Add several nodes to the edited scene in one undoable action; a later entry may parent onto a node created by an earlier one
Inputs: nodes (required).
Read properties of several live nodes in one round trip; missing nodes report inline instead of failing
Inputs: nodes (required).
Set one property on every node of a given engine class in the edited scene, in a single undoable action
Inputs: type (required), value (required), property (required).
Capture a burst of viewport frames from the running game as base64 PNGs, spaced by frame_interval frames
Inputs: count, frame_interval, half_resolution.
Clear the editor scene tree selection
Inputs: no named parameters.
Push old content out of view in the editor Output panel by printing blank lines (cosmetic only, nothing is deleted)
Inputs: no named parameters.
Press the first visible button in the running game whose text matches, programmatically rather than via the mouse
Inputs: text (required), partial.
Compare two PNG images (res:// or user:// path, or raw base64) pixel by pixel and return the change count plus a red-highlighted diff image
Inputs: image_a (required), image_b (required), threshold.
Connect a node signal to a method on a target node, persisted into the scene file
Inputs: method_name (required), signal_name (required), source_path (required), target_path (required).
Create an empty Animation in an AnimationPlayer's default library with a length in seconds and a loop mode (0 none, 1 linear, 2 pingpong)
Inputs: name (required), node_path (required), length, loop_mode.
Add an active AnimationTree with a state machine root under a parent node and wire it to an AnimationPlayer
Inputs: node_path (required), name, anim_player.
Add a GPUParticles2D/3D node with a fresh ParticleProcessMaterial under parent_path
Inputs: parent_path (required), name, is_3d, amount, +5 more.
Create a resource of the given class, apply properties and save it to disk
Inputs: path (required), type (required), overwrite, properties.
Create a new scene file on disk with the given root node type, without opening it in the editor
Inputs: path (required), root_name, root_type.
Create a .gd or .cs script file, generating a GDScript template when content is empty
Inputs: path (required), force, content, extends, +1 more.
Create a shader file, generating a template for the given shader_type when content is empty
Inputs: path (required), force, content, shader_type.
Create a Theme resource and save it to a res:// path
Inputs: path (required), default_font_size.
Set one property on every node of a given engine class across all scene files on disk; previews by default, requires force=true to write
Inputs: type (required), value (required), property (required), force, +3 more.
Delete a node from the edited scene (the scene root cannot be deleted)
Inputs: node_path (required).
Delete a scene file from disk together with its .import sidecar
Inputs: path (required).
Export the APK then adb-install and launch it on a device (blocks the editor while running)
Inputs: debug, launch, preset_name, skip_export, +2 more.
Detect cycles among scenes by parsing ext_resource scene references textually and return each cycle path
Inputs: path, include_addons.
Disconnect a node signal from a method on a target node
Inputs: method_name (required), signal_name (required), source_path (required), target_path (required).
Duplicate a node with its children under the same parent in the edited scene
Inputs: node_path (required), name.
Set properties on an existing resource file and save it back to disk
Inputs: path (required), properties (required).
Edit a script file using exactly one mode: replacements list, content+start_line line-range replace, content alone full replace, or insert_at_line+text
Inputs: path (required), text, force, content, +4 more.
Edit a shader file using exactly one mode: content for a full replace, or a replacements list of literal search/replace items
Inputs: path (required), force, content, replacements.
Run GDScript in the editor process as the body of run(); call _mcp_print(v) to emit output and return a value to send it back; file and resource write APIs are refused unless allow_unsafe_editor_io is true
Inputs: code (required), allow_unsafe_editor_io.
Run GDScript inside the running game process; code runs as the body of run(root: Node), use print() for output, no top-level func definitions and no await
Inputs: code (required).
Build the headless CLI command to export a preset (returns the command string, does not run the export)
Inputs: debug, preset_name, preset_index.
List Node2D/Node3D nodes within a radius in world units of a position or node, nearest first
Inputs: position (required), radius, max_results, type_filter, +1 more.
Search all project scene, script, resource and shader files for a substring and return matching files with up to 5 line numbers each
Inputs: pattern (required).
Find live nodes in the running game whose attached script path contains the given substring
Inputs: script (required), properties.
Find nodes in the edited scene whose engine class matches a type, inheritance-aware — script class_name values do not match
Inputs: type (required), recursive.
Find every node in the edited scene that belongs to a group
Inputs: group (required).
Grep project scene, script, resource and config files for a case-sensitive substring and return file, 1-based line number and text
Inputs: query (required), path, include_addons.
List every signal connection in the edited scene as flat source, signal, target and method rows, optionally filtered by signal name or source path substring
Inputs: node_path, signal_name.
List visible Control nodes in the running game with their text, global rect and center point in screen pixels
Inputs: type_filter.
List resource files under a path that no scene, script or config file text-references — advisory only, uid:// and dynamic references are false positives, never auto-delete
Inputs: path, include_addons.
Get an Android export preset's name, index, export path and package unique name
Inputs: preset_name, preset_index.
Get one animation's length, loop mode, step and every track with its keyframe times, values and easings
Inputs: animation (required), node_path (required).
Dump an AnimationTree's root graph recursively: state machine states and transitions, blend tree nodes and connections
Inputs: node_path (required).
List every AudioServer bus with its volume, routing, flags and effect chain
Inputs: no named parameters.
List every audio stream player under a node in the edited scene with its stream, bus and volume
Inputs: node_path (required).
Read an autoload singleton at /root/ in the running game
Inputs: name (required), properties.
Report physics layers, body simulation properties, collision shapes, polygons and raycasts on a node and optionally its whole subtree
Inputs: node_path (required), include_children.
Get the 3D editor viewport camera global position, rotation in degrees, fov and clip planes
Inputs: no named parameters.
Collect recent editor errors and warnings from the editor log file, script editor compile markers and the debugger Errors tab
Inputs: max_lines.
Get a compact performance digest of the editor process (not a running game): fps, frame time in ms, draw calls, node and orphan counts, memory in MB
Inputs: no named parameters.
Capture a PNG screenshot of the Godot editor window; empty save_path returns base64, otherwise the image is written to disk
Inputs: save_path.
List the nodes currently selected in the editor scene tree
Inputs: top_only.
Get export environment info: Godot executable, project path and export templates directory
Inputs: no named parameters.
List the project filesystem as a nested tree of directories and files
Inputs: path, filter, max_depth.
Read live property values of a node in the running game
Inputs: node_path (required), properties.
Dump the live scene tree of the running game from the tree root, including autoloads
Inputs: max_depth, named_only, type_filter, script_filter.
Capture a PNG screenshot of the running game's viewport; empty save_path returns base64, otherwise the image is written to disk
Inputs: save_path.
List InputMap actions with their deadzone and bound events, optionally including builtin ui_* actions
Inputs: filter, include_builtin.
List the groups a node belongs to
Inputs: node_path (required).
List a node's editor-visible properties, optionally filtered by name prefix
Inputs: node_path (required), category.
List the scripts currently open in the Godot script editor
Inputs: no named parameters.
Tail the editor's log file (user://logs/godot.log), keeping only lines containing a case-sensitive substring filter
Inputs: filter, max_lines.
Read a GPUParticles node's emission settings, process material properties and color gradient stops
Inputs: node_path (required).
Dump raw Performance monitors of the editor process (not a running game); time_* in seconds except time_fps, memory and VRAM in bytes, optionally filtered by key prefix
Inputs: category.
Read collision_layer and collision_mask of a node, decoded bit by bit with the project's physics layer names
Inputs: node_path (required).
Get Godot project name, engine version, main scene, viewport size, renderer and autoloads
Inputs: no named parameters.
Read one project setting by key, or dump all settings matching a section prefix
Inputs: key, section.
Summarize the project: file counts by extension, GDScript line count, scene and resource counts, autoloads and plugins
Inputs: path, include_addons.
Render an image or texture resource to a base64 PNG, downscaled so its longest side is at most max_size pixels
Inputs: path (required), max_size.
List the resources a scene or resource file depends on, with path, uid and type
Inputs: path (required).
List every node's exported script variables in a scene file, with current values, Variant types and hints
Inputs: path (required).
Read the raw .tscn text of a scene file on disk
Inputs: path (required).
Get the node tree of the currently edited scene as nested name/type/path/script records
Inputs: max_depth.
List every shader uniform and its current value on a node's ShaderMaterial
Inputs: node_path (required).
List every signal declared by a node in the open scene with its argument types and current connections
Inputs: node_path (required).
Summarize every assertion recorded this plugin session and optionally clear the collected results
Inputs: clear.
Read a Control's assigned theme plus every theme override it carries: colors, constants, font sizes and styleboxes
Inputs: node_path (required).
List Android devices visible to adb with serial, state, product and model
Inputs: no named parameters.
List the animations in an AnimationPlayer's default library with length, loop mode and track count
Inputs: node_path (required).
List the export presets in export_presets.cfg with platform, runnable and path
Inputs: no named parameters.
List .gd/.cs/.gdshader files under a project path with their class_name or extends
Inputs: path, recursive.
Sample properties of a live node over several frames to observe how they change over time
Inputs: node_path (required), properties (required), frame_count, frame_interval.
Reparent a node to a new parent in the edited scene
Inputs: node_path (required), new_parent_path (required).
Walk the 3D player toward a target node or world position and wait for arrival within arrival_radius, or timeout
Inputs: target (required), run, timeout, camera_path, +3 more.
Open an existing scene file in the editor and make it the edited scene
Inputs: path (required).
Run the project: mode 'main', 'current', or a res:// scene path to play that scene
Inputs: mode.
Resolve a res:// project path to its uid:// identifier
Inputs: path (required).
Load a resource file and return its class and editor-visible properties
Inputs: path (required).
Read the full text of a script or shader file from the project
Inputs: path (required).
Read the full source code of a shader file
Inputs: path (required).
Reload the Godot MCP Bridge plugin; the WebSocket connection drops briefly and auto-reconnects
Inputs: no named parameters.
Trigger a rescan of the project filesystem in the editor
Inputs: no named parameters.
Remove an animation from an AnimationPlayer's default library
Inputs: name (required), node_path (required).
Remove an autoload singleton by name and save project settings
Inputs: name (required).
Remove a state from an AnimationTree state machine (Godot also drops transitions touching it; undo does not restore them)
Inputs: node_path (required), state_name (required), state_machine_path.
Remove the transition between two states of an AnimationTree state machine
Inputs: to_state (required), node_path (required), from_state (required), state_machine_path.
Rename a node in the edited scene
Inputs: new_name (required), node_path (required).
Replay recorded input events into the running game, honoring their time_ms timeline scaled by speed
Inputs: events (required), speed.
Hammer the running game with random input actions for a duration in seconds and report crashes and new log errors
Inputs: actions, duration.
Run an ordered input/wait/assert/screenshot scenario against the running game, optionally launching a scene first
Inputs: steps (required), scene_path.
Save the currently edited scene, optionally to a new res:// path (save-as); refuses to overwrite a scene open in another inactive tab
Inputs: path.
Search project file names by case-insensitive substring or glob pattern
Inputs: query (required), path, file_type, max_results.
Grep project file contents and return matching file, 1-based line number and text
Inputs: query (required), path, regex, file_type, +1 more.
Select nodes in the editor scene tree and optionally show them in the Inspector
Inputs: mode, focus, inspect, node_path, +3 more.
Apply a Control layout anchor preset to a Control node
Inputs: preset (required), node_path (required), keep_offsets.
Insert or replace a keyframe at a time in seconds on an animation track, with an easing transition curve
Inputs: value (required), animation (required), node_path (required), time, +2 more.
Update an audio bus's volume, flags, send target or name; changes live audio state; save the bus layout manually to persist
Inputs: name (required), mute, send, solo, +3 more.
Enable or disable automatic dismissal of blocking modal dialogs in the editor
Inputs: enabled.
Add or replace a node inside a blend tree state and optionally wire its output into another node's input port
Inputs: node_path (required), bt_node_name (required), bt_node_type (required), blend_tree_state (required), +6 more.
Move the 3D editor viewport camera in world space; look_at is applied after rotation_degrees and overrides it
Inputs: fov, look_at, position, rotation_degrees.
Set one property on a live node in the running game and return its old and new value
Inputs: value (required), property (required), node_path (required).
Create or replace an InputMap action's bindings in project settings and in the live editor InputMap
Inputs: action (required), events (required), deadzone.
Set a fresh StandardMaterial3D as a MeshInstance3D surface override — omitted params reset to class defaults, replacing any previous override
Inputs: node_path (required), emission, metallic, cull_mode, +11 more.
Set a node's full group membership, adding and removing to match the desired set
Inputs: groups (required), node_path (required).
Build a color ramp from ordered offset/color stops and assign it to the particle material
Inputs: stops (required), node_path (required).
Set ParticleProcessMaterial properties on a GPUParticles node; spread is in degrees and velocities are pixels/s in 2D, metres/s in 3D
Inputs: node_path (required), color, spread, gravity, +18 more.
Set collision_layer and/or collision_mask on a collision object, area or raycast, as a bitmask int or a list of layer numbers 1-32
Inputs: node_path (required), collision_mask, collision_layer.
Set one project setting and save project.godot
Inputs: key (required), value (required).
Set one shader uniform on a node's existing ShaderMaterial
Inputs: param (required), node_path (required), value.
Add a theme color override on a Control; color travels as #rrggbb[aa] or Color(r, g, b, a)
Inputs: name (required), color (required), node_path (required).
Add a theme constant override on a Control, such as separation or margin_left
Inputs: name (required), node_path (required), value.
Add a theme font size override on a Control, in pixels
Inputs: name (required), node_path (required), size.
Add a StyleBoxFlat theme override on a Control, setting only the supplied background, border, corner radius and padding in pixels
Inputs: name (required), node_path (required), padding, bg_color, +3 more.
Set an AnimationTree parameter such as a condition or blend amount, auto-prefixing parameters/ when missing
Inputs: value (required), node_path (required), parameter (required).
Create or reconfigure a Camera3D; fov, rotation are in degrees and look_at is a world-space target; reconfiguring an existing node is not undoable
Inputs: far, fov, name, near, +10 more.
Add a CollisionShape2D/3D child holding a built shape resource to a physics body or Area; 2D sizes are in pixels, 3D in metres
Inputs: shape (required), node_path (required), ax, ay, +11 more.
Configure a Control's layout: anchor preset, minimum size, size flags, grow directions, container margins and separation
Inputs: node_path (required), grow_h, grow_v, margins, +5 more.
Create or reconfigure a WorldEnvironment with sky, ambient, tonemap, fog, glow, SSAO, SSR and SDFGI settings; reconfiguring an existing node is not undoable
Inputs: sky, name, node_path, glow_bloom, +24 more.
Add a 3D light from a light_type or a preset (sun, indoor, dramatic); rotation and spot_angle are in degrees
Inputs: name, color, range, energy, +9 more.
Configure simulation properties of an existing CharacterBody2D/3D or RigidBody2D/3D; angles are in degrees and only provided params are written
Inputs: node_path (required), mass, freeze, max_slides, +13 more.
Press or release a named InputMap action in the running game (dropped if no game is running)
Inputs: action (required), pressed, strength.
Send a keyboard event to the running game by key name such as W, SPACE, ESCAPE or F1 (dropped if no game is running)
Inputs: keycode (required), alt, ctrl, shift, +1 more.
Click a mouse button at viewport pixel x,y in the running game, auto-releasing so UI buttons fire (dropped if no game is running)
Inputs: x, y, button, pressed, +2 more.
Move the mouse to viewport pixel x,y in the running game with an optional motion delta and held-button mask (dropped if no game is running)
Inputs: x, y, unhandled, relative_x, +2 more.
Send an ordered batch of input events to the running game, one event every frame_delay frames (dropped if no game is running)
Inputs: events (required), frame_delay.
Start recording player input events in the running game; mouse motion is recorded unfiltered and can be voluminous
Inputs: no named parameters.
Stop input recording in the running game and return the recorded event list
Inputs: no named parameters.
Stop the running game and clean up the bridge IPC temp files in its user dir
Inputs: no named parameters.
Clear a TileMapLayer, or one layer of a legacy TileMap when layer is given and every layer when it is omitted
Inputs: node_path (required), layer.
Fill the inclusive grid rectangle between corners x1,y1 and x2,y2 with one tile (corners in any order)
Inputs: node_path (required), x1, x2, y1, +6 more.
Read the tile at grid x,y of a TileMapLayer or legacy TileMap layer, reporting its source, atlas coords and alternative
Inputs: node_path (required), x, y, layer.
Get the layers, used cell counts, TileSet sources and tile size in pixels of a TileMapLayer or legacy TileMap
Inputs: node_path (required).
List the used cells of a TileMapLayer or legacy TileMap layer as grid x,y with source_id, capped at max_count
Inputs: node_path (required), layer, max_count.
Place one tile in a TileMapLayer or legacy TileMap at grid x,y
Inputs: node_path (required), x, y, layer, +4 more.
Resolve a uid:// identifier to its res:// project path
Inputs: uid (required).
Set one property on a node; compound values travel as constructor strings like Vector2(100, 200) or #ff0000
Inputs: value (required), property (required), node_path (required).
Compile-check a GDScript file without attaching it, returning validity as data
Inputs: path (required).
Poll the running game until a node exists at the given path or the timeout in seconds elapses
Inputs: node_path (required), timeout, poll_frames.
Record every signal emitted by the given live nodes for a duration in milliseconds
Inputs: node_paths (required), duration_ms, signal_filter.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 174 tools
Several tools overlap heavily: find_node_references, find_script_references, and search_in_files all grep project files for substrings, and move_to/navigate_to both walk the player character. Multiple property-reading tools (get_node_properties, get_game_node_properties, batch_get_properties, monitor_properties) add further ambiguity, making misselection likely despite detailed descriptions.
All 174 tool names follow a strict lowercase snake_case verb_noun pattern (e.g., add_node, get_scene_tree, set_shader_param, find_unused_resources). There is no camelCase, no mixed conventions, and the pattern is highly predictable across the entire set.
At 174 tools, this is an extreme count that far exceeds even a generous interpretation of the domain's scope. The sheer number overwhelms agents and violates the typical 3-15 tool guideline, even for a game-engine bridge.
The tool set covers a wide range of Godot workflows (scene editing, animation, audio, physics, UI, navigation, particles, testing, export), but notable lifecycle gaps exist: no delete_resource, no remove_audio_bus, no rename_animation or duplicate_animation. Arbitrary code execution via execute_editor_script can patch some gaps, but the surface is not fully complete for its stated purpose.
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
MCP server for building and testing AI agents with multi-model experimentation and insights.
