Bragproof

← Reports

@npgamedev/godot-mcp-server

Starts with no setup1.1.2npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 3 tools tried
Contacts while installing and starting: nothing

36tools listed
0hosts contacted
0files written
0.2 sto start
96dependencies

What it contacted

Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.

Starting it

npx -y @npgamedev/godot-mcp-server@1.1.2

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

3 tools that take no input and look read-only were called once with nothing. 0 returned a result.

scene_get_treeNo usable answer tool reported an error: {"success":false,"error":"WebSocket error: connect ECONNREFUSED 127.0.0.1:6550","code":"CONNECT_FAILED","hint":"Could not connect to the
project_get_settingsNo usable answer tool reported an error: {"success":false,"error":"WebSocket error: connect ECONNREFUSED 127.0.0.1:6550","code":"CONNECT_FAILED","hint":"Could not connect to the
debugger_get_logNo usable answer tool reported an error: {"success":false,"error":"no runtime_port in registry — start the game in the editor (F5) with a debug build","code":"GAME_NOT_RUNNING",

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

1 tool with commands in capitals or very long text
  • Very long description in discover_tools: 3000 characters or more

Common and usually harmless: it is how many makers stress how a tool should be used.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

scene_get_tree max_depth, include_properties
Return the current edited scene's node tree as nested JSON { name, class, path, children }. Paths use "." for root — pass them directly to other editor commands.
scene_create_node class_name, parent_path, node_name, layout_mode, unique_name, properties
Create a node of class_name under parent. Supports engine + user-defined class_name classes. Idempotent: 'returned' on collision, 'created' on fresh.

Example: class_name: "CharacterBody2D", parent_path: ".", node_name: "Player"
scene_delete_node node_path
Delete the node at path (NodePath). Refuses to delete the edited scene root.
scene_create file_path, root_type, root_name, if_exists
Create .tscn at file_path. Root name = filename stem at '.'. root_type default Node. Idempotent: created|returned|replaced. if_exists: return|fail|replace. Use scene_open afterward to edit.
node_get_property node_path, property
Read a property from the node at path. Returns { value } (engine types are dict-wrapped).
31 more tools
node_set_property node_path, property, value, make_unique, batch
Set a property on a node in the EDITOR scene tree (saved to .tscn files). Does NOT affect the running game — for runtime property changes during playtesting, use runtime_set_property.

Node paths are relative to the edited scene root: "." is root, "./Player" is a direct child, "./Player/Sprite2D" for deeper nodes.

Engine types: {type:'Vector2',x,y}. Inline sub-resources: {type:'NewResource',class:'CircleShape2D',properties:{radius:50}}. External resources (textures, audio, tilesets, materials): {type:'Resource', path:'res://path/to/file.tres'}. Packed arrays: {type:'PackedVector2Array', values:[{type:'Vector2',x:0,y:0}, ...]}. Collision layers: {type:'LayerMask', layers:[1,4,6]} (by number) or {type:'LayerMask', layers:['player','walls']} (by name from layer_names_set); optional category defaults to '2d_physics'. All supported type tags: Vector2, Vector3, Vector4, Vector2i, Vector3i, Color, Rect2, Rect2i, Transform2D, Transform3D, NodePath, Resource, NewResource, PackedVector2Array, PackedVector3Array, PackedColorArray, LayerMask. Unknown type tags are rejected with an error listing supported types.

Anchor presets: setting anchors_preset alone may not auto-apply underlying values. For reliable layout, set anchor_left/top/right/bottom and offset_left/top/right/bottom explicitly.

Batch mode: pass batch:[{node_path, property, value, make_unique?}, ...] to set multiple properties at once.
node_get_property_list node_path, mask, visibility
Introspect node properties. mask: common (default), all, groups, script. 'script' returns all script variables with public/private label; use visibility param to filter.
node_set_script node_path, script_path
Attach a script (.gd/.cs) to a node. On Godot 4.2.2+, a .gd changed on disk since it was loaded is reloaded first, for every node running it. Returns @export properties. Empty script_path detaches.
control_set_layout node_path, preset, resize_mode, margins
Set anchor preset + optional margins on a Control node in one call. Uses set_anchors_and_offsets_preset(). Returns final_rect.
node_call_method node_path, method_name, args
Call method with args on an edited-scene node (editor-only; for runtime nodes use execute_code).
script_read file_path, start_line, end_line
Read a script file (res:// only). Returns the file content as text in an <untrusted> envelope. Read large scripts in successive line windows via start_line/end_line (1-indexed, inclusive). Paged: returned, total_lines, has_more. When has_more, page via next_start_line until has_more is false. 
script_write file_path, content
Write .gd/.cs/.gdshader/.gdshaderinc at file_path (res:// only, creates or overwrites). For .gd files, returns inline diagnostics (valid: bool, diagnostics: [...]) — check valid before proceeding. Not idempotent. Use script.delete to remove; resource.create for .tres; scene.create for .tscn.
script_edit file_path, old_string, new_string, replace_all, edits
Surgically replace a span in an existing .gd/.cs/.gdshader/.gdshaderinc file (res:// only) — the MCP analogue of the native Edit tool. old_string must match the file byte-for-byte (whitespace and indentation included); no regex, no fuzzy match. old_string not found -> NOT_FOUND; matches more than once without replace_all -> NOT_UNIQUE. new_string:'' deletes the span. replace_all replaces every occurrence and returns replacements:N. edits applies several edits in order in one call, writing nothing if any fails. Prefer this over rewriting the whole file with script_write for a small change — it keeps the editor undo entry, reindexing, and inline diagnostics. For .gd files, returns inline diagnostics (valid: bool, diagnostics: [...]) — check valid before proceeding.
script_check file_path
Offline GDScript validation — pass/fail + diagnostics. A class_name clash always carries its line (1-based); a compile error only on 4.5+. Columns are lsp_diagnostics' domain. Works headless.
editor_save_scene file_path
Save the current edited scene. Optional file_path triggers save-as.
scene_open file_path
Open a scene (.tscn / .scn) as the active edited scene. res:// only; NOT_FOUND if the file doesn't exist.
project_get_settings prefix
List ProjectSettings keys + values. Optional prefix filter. Keys matching /password|token|secret|key/i are dropped (MVP filter).
editor_get_console limit, level_filter, since_id, source, text_filter, is_regex, clear_buffer
Tail editor Output. source='buffer' (default): live editor console on 4.5+, game-log tail on 4.2-4.4. source='file': the newest log — the game's, or the editor's own when launched with --log-file (4.3+; not 4.4 on Windows). level_filter, since_id, text_filter (is_regex=true for regex). Carries returned/total_lines/has_more + next_id — page via since_id. Primary post-crash diagnostic tool — reads runtime errors even after game_stop.
project_set_setting setting, value
Write a ProjectSettings key and persist via ProjectSettings.save. Refuses mcp_toolkit/*, mcp/*, and editor/* prefixes. Returns previous_value. Update (no status).
folder_create path
Create directory at res:// path (recursive — parents auto-created). Idempotent: status created on fresh, returned if pre-existing.
game_start scene_path, wait_for_runtime, runtime_poll, if_running
Start playtest. Blocks until runtime is ready by default; wait_for_runtime:false launches without blocking. scene_path:'main'|'current'(default)|res://path. if_running:'return' for idempotent mode.
game_stop
Stop the currently-playing scene (idempotent — returns was_running:false if nothing was running). No params.
runtime_screenshot save_path, image_response_mode, image_detail, force_foreground_game
Capture the running game window. Requires an active playtest (game_start). Use editor_screenshot for the editor viewport. image_response_mode 'disk' saves the PNG and returns only its path.
debugger_get_log limit, source, text_filter, is_regex
Game output log. Works during gameplay AND after crash (auto-serves cached output). print()/push_* from a running game are captured here on every version (4.2-4.7) — the 'read my own prints to validate a flow' path. Compile errors will NOT appear here (the game must run); use script_check (one file) or lsp_project_diagnostics (whole project). source='buffer'|'file'. limit=200. text_filter + is_regex for search. +returned/total_lines/has_more (capped tail). Right after game_stop the first call may return GAME_NOT_RUNNING while the session registry settles — retry once (the cache serves the next call).
input_simulate events, summary
Inject input into the running game. events: single {event_type, event_data?, delay_before_ms?, delay_after_ms?} for one action, or an array for a sequence of actions (prefer a single call with multiple events over separate calls). Types: key|mouse_button|mouse_motion|action|click|click_node|send_text. click is a composite: press + 50ms delay + release via push_input (no OS focus/warp; parallel-safe). click_node takes {node_path} — calls grab_focus + emits pressed on BaseButtons (no coordinate guessing). send_text types a string into the focused text field (or the event_data.node_path-targeted Control) by synthesizing per-character key events via push_input, firing the real text_changed/text_submitted signals that setting .text skips. send_text event_data: text (required), node_path? (a Control to focus first), submit? (append Enter); it returns focus_target, focus_source, text_changed, text_after (secret fields redacted), chars_sent, and a hint.

Mouse coordinate modes:
- position: {x, y} — raw viewport/screen coordinates (default). Use for UI elements (buttons, menus).
- world_position: {x, y} — game-world coordinates, auto-translated via canvas transform (accounts for camera offset and zoom). Use for clicking at specific in-game locations.

Mouse events route through push_input (position + global_position) for CanvasLayer/GUI hit-testing — no OS focus/warp, parallel-safe. Returns per-event diagnostics.
runtime_get_script_vars node_path, visibility
Get script variables (names, values, public/private) for a live game node. Complements runtime_get_node_state (engine props only). visibility param filters.
execute_code code, scope_path, channel
DANGER: evaluates a GDScript expression. Expression-only — no var/return/if/for statements, no = assignment.

channel: 'runtime' (default) runs in the running game, 'editor' runs in the editor process.

To set properties: get_node('/root/Main/Player').set('speed', 400)
To call methods: get_node('/root/Main/Player').call('take_damage', 25)
To read values: get_node('/root/Main/Player').position

Prefer runtime_set_property for single property changes (safer, no expression syntax). Use execute_code for complex multi-step operations or method calls with specific arguments. If C# project, managed methods are callable at runtime (channel:'runtime').

LIMITATION: Expression cannot access engine singletons (EditorInterface, Engine, OS, Input) or call load()/preload(). Property chaining on method return values (get_node('X').position) may fail due to Variant type erasure — use scope_path to bind the node as self, or use .get('property') instead (get_node('X').get('position') works reliably).
signal_list node_path, include_connections
List signals on a node. include_connections=true adds targets ({target_path, method_name, flags}). flags & 2 = CONNECT_PERSIST (saved in .tscn).
signal_manage action, node_path, signal_name, target_path, method_name
Connect or disconnect a signal (editor-time, CONNECT_PERSIST — saved in .tscn, survives save/load). Idempotent connect (status 'returned' on collision).
node_manage action, node_path, new_name, new_parent_path, keep_global_transform, new_index, parent_path, properties
Structural node operations on the edited scene tree.

action: rename — requires new_name.
action: reparent — requires new_parent_path, optional keep_global_transform (default true).
action: reorder — requires new_index (0-based sibling index).
action: duplicate — optional new_name, parent_path, properties (overrides like {position:{x,y}}).
node_groups action, node_path, group, persistent, entries
Manage node group membership. Groups are the idiomatic Godot way to tag and query game objects (e.g. 'coins', 'enemies').

Single mode: node_path + group (node_path required for add/remove/list). Batch mode: entries array of {node_path, group} carries per-item paths, and the top-level node_path/group are ignored.

action: add — requires group. action: remove — requires group. action: list — returns all groups (single only).
autoload_manage action, name, script_path, enabled
Manage project autoload singletons (GameManager, AudioManager, etc.). Writes to project.godot; takes effect on next game launch.

action: register — requires name + script_path. action: unregister — requires name. action: list — returns all.
scene_query class_filter, group_filter, name_pattern, property_filters, root_path, max_depth, include_properties, offset, limit
Search scene tree with filters (class, group, name glob, property conditions). Returns matching nodes. Faster than scene_get_tree + manual filtering. Paged: returned, total_matches, has_more. When has_more, page via next_offset until has_more is false. Stable only if the source is unchanged between calls. Results are returned in deterministic depth-first order; nodes echoes offset/limit. limit is 1-200 (default 50, clamped above 200). If the tree changes between paged reads (nodes added, removed, or reordered) results may skip or repeat — re-query from offset 0.
scene_spatial_map detail, class, subtree, region, radius, center, max_nodes
Spatial layout of the current scene: per-node world position, bounds (2D Rect2 / 3D AABB), size, plus computed overlaps/gaps/containment. Call before placing or moving nodes to find clear space. Paged: returned, total_nodes, has_more. Cursor-less — narrow with subtree/class/region/radius or raise max_nodes for more. 
discover_tools request, activate, include_schemas, reset
Find and activate tool groups by name or domain keyword. Activate only the groups needed for your current task (up to ~5) — loading many groups at once floods the tool list and degrades response quality. No params → full catalog. reset: true → deactivate ALL groups; reset: ['group_a'] → deactivate only group_a. Groups: runtime_advanced [available] — Inspect live node state, set node properties, and control AnimationPlayer during playtests; signals [available] — Emit signals on scene nodes at editor-time or runtime; animation_authoring [available] — Inspect and author keyframes, edit tracks, and configure AnimationTree state machines; input_map [available] — List, create, and edit input actions and their key/controller bindings; resource_io [available] — Load and write Godot resources (.tres/.res) programmatically; asset_ops [available] — List assets, query dependencies, and import binary files into the project; placeholders [available] — Generate placeholder/prototype assets procedurally — textures (shapes, patterns, labels) and sound effects (tones, noise). No art or network needed.; cleanup [available] — Delete files, scripts, scenes, resources, and folders; close open scenes; user_data [available] — Read, write, delete, and list user:// save files; scene_advanced [available] — Diff scenes and batch-instantiate nodes from packed scenes; editor_advanced [available] — Capture editor screenshots, refresh the filesystem, and wait for idle; tilemap [available] — Read and paint cells on TileMap/TileMapLayer nodes — cell queries, bulk fills, and region operations; tileset [available] — Create TileSet resources, add atlas sources, configure layers, and manage tile alternatives; tileset_edit [available] — Edit per-tile properties: physics, terrain, navigation, visuals, and custom data; theme [available] — Edit UI theme overrides: styleboxes, fonts, colors, and constants; layer_naming [available] — Get and set physics, render, and navigation layer names; path_editing [available] — Edit Path2D curves and generate collision shapes from sprite textures; 3d_tools [available] — Create 3D primitives, lights, cameras, and environment setups; procedural [available] — Edit gradients, curves, and FastNoiseLite resources for procedural generation; scene_inheritance [available] — Create inherited scenes (variants) from base scenes; audio [available] — List and configure audio buses, effects, and volume settings; spriteframes [available] — List, create, and edit SpriteFrames animations and import from spritesheets; particles [available] — Create and configure GPU particle systems for visual effects; navigation [available] — Set up navigation regions, meshes, and obstacle avoidance; lsp_code_analysis [available] — GDScript diagnostics, symbols, hover info, and a project-wide compile check via the language server; lsp_code_navigation [available] — Code completion, go-to-definition, and find references via the language server; debugger [available] — Inspect debugger sta
extensions_refresh
Force a filesystem rescan and re-discover extension scripts. Call after creating, modifying, or deleting extension files from outside the Godot editor. Returns the updated list of extension commands.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Install facts

LicenseMIT
Needsnode >=22
Sourcegithub.com/NPGameDev/godot-mcp-server
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-B/hUVU/AjoB2NoE2JuOkGuCfFUbHzrMDvACIUOipLAUMkiZ7Rk0UNjm83g4HE/ZjBf8SU55W9uHUhUlqm0takQ==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/@npgamedev/godot-mcp-server.svg)](https://bragproof.smaverk.com/r/%40npgamedev/godot-mcp-server)

New version out? Ask for a fresh report.