Instantiate a bundled (or project) template into res:// in one call — copies its files and, if the template declares a main_scene, sets and opens it. Generic: a template can be a game starter, a UI screen, a settings menu, a test harness. Project templates under res://.beckett/templates/ override bundled ones. Call with no 'template' to list what's available.

Attach a script (res:// path) to a node in the open scene (undoable).

Run several tool calls in one request, in order. steps = [{tool, args}]. Stops at the first failure (stop_on_error, default true). When a step fails, scene edits made by the batch are rolled back via the editor undo history (rollback, default true) — file/resource writes are not. Use to collapse multi-step authoring (create node → set props → attach script) into one atomic call.

Compile-check a C#/.NET Godot project with dotnet build, returning structured diagnostics (errors/warnings with file:line:col + CS-code). Isolated build (scratch output) — never touches the editor's loaded assembly, so it's safe while the editor is open. Auto-detects the .csproj if omitted. Needs the .NET SDK (already installed for any C# Godot project). First build restores packages (slower); incremental ~1-3s. Use after editing .cs — the GDScript compile-gate (write_script) does NOT cover C#.

Invoke a method on a resolved object. args = a positional array. Returns the result as JSON.

Connect a node's signal to a method on another node, persisted into the scene (undoable). from/to = node path/name in the open scene.

Create a node of the given class and add it to the open scene (undoable). parent = a node path/name (default: scene root).

Create a Resource of the given class and save it to a res:// path (.tres). Optional 'properties' dict sets initial values.

Remove a node from the open scene (undoable).

List a class's properties and methods (with signatures) so you know exactly what to set_property / call_method. The discovery key for full domain coverage.

Dump a live object's properties as JSON. target = a res:// path, a node name/path in the open scene, or a class name (falls back to describe_class).

Disconnect a previously connected signal (undoable).

Duplicate a node (with its children) under the same parent (undoable). Optional 'name' for the copy.

Search classes by name substring — engine classes AND your project's own types (GDScript class_name + C# [GlobalClass]). Optional 'base' restricts to subclasses (e.g. base=Node2D). The discovery entry point — pair with describe_class.

Search methods by name substring, optionally restricted to a class (incl. inherited). Any result is invokable via call_method.

Find LIVE nodes in the RUNNING game by type and/or name; returns their paths to feed into runtime_call/runtime_get_property/runtime_set_property. 'class' matches native classes AND custom class_name scripts (is_class alone misses custom nodes — they read as @Node@NN). name=substring on the node name. path=scope root (default scene root). recursive=true. max=cap (default 100).

Read the RUNNING game's captured output off the runtime channel (real-time, no file logging): runtime SCRIPT errors WITH stack traces, push_error/push_warning, and print(). This is the play->see-error->fix signal — the blind spot logs_read (file-based) can't reliably cover. level=error (default: errors+script+shader) | warning (adds warnings) | all (adds print/stderr). limit=newest N (default 100), filter=substring, clear=true empties the buffer after reading.

Return the running Godot engine version info.

Profiling: read Performance monitors (fps, frame time, memory, object/node counts, draw calls, video mem, physics). target=game (default when a play session is connected) samples the RUNNING game; target=editor samples the editor.

Report whether a scene is playing and whether the runtime channel to the game is connected.

Read a ProjectSettings value by its property path (e.g. application/run/main_scene). Pass it as 'setting' ('name' is also accepted).

Project overview: file/script/scene/resource counts, total GDScript lines, autoloads, main scene, input-action count, Godot version. Read-only static scan.

Dump the live scene tree of the RUNNING game (runtime counterpart of get_scene_tree). SCOPE IT to stay under token limits — a full game tree blows the budget. path=subtree root (name, relative, or absolute /root/...); depth=levels (-1=all); max_nodes (default 250); max_children per node (default 50); collapse=true groups runs of identical leaf siblings (e.g. '8x CPUParticles2D'). Returns {tree, node_count, truncated?}.

Return the node tree of the scene currently open in the editor (name/class/script, nested).

Instantiate a packed scene (res://*.tscn) as a child in the open scene (undoable).

List entries (dirs + files) of a res:// directory.

List a node's signals and their current connections (target node + method).

Tail Godot's log FILE (the editor session and any played game log here). For the RUNNING game's errors/stack traces/prints in REAL TIME, prefer game_logs (runtime channel, no file needed) — this file reader is a fallback and needs file logging enabled (off by default; the result tells you how). Optional: level='error'|'warning', 'filter' substring, 'lines' (default 200), 'path' to override.

Sample a node's property in the running game over several frames (detect movement/changes). Returns the sample series.

Reorder a node within its parent to a new child index (undoable).

Open a scene by res:// path in the editor (makes it the edited scene).

Play a scene in the editor. 'scene' (res://) plays a specific scene; current=true plays the open scene; otherwise the project's main scene. Then wait_until condition=play_started, and logs_read for errors.

Read a text file by res:// (or user://) path.

Read a script/text file from res://.

Rename a node in the open scene (undoable).

Move a node under a new parent in the open scene (undoable).

Read a property of a node in the RUNNING game. Address by path (node path/name) OR a live selector: class (native or custom class_name) / name / text [+ nth, default 0]. The selector resolves fresh each call — no need to re-fetch volatile @Node@NN paths. Returns the value plus the 'resolved' path that matched.

Save the scene currently open in the editor. Pass 'path' (res://) to save-as.

Capture an image the agent can see (inline PNG). target=game (default) screenshots the RUNNING game via the runtime channel; target=editor captures the 2D editor viewport. region=[x,y,w,h] in pixels crops to that rect (clamped) to save tokens — screenshot full once to learn the size, then crop.

Surgically edit an existing res:// file without rewriting it whole. edits = an ordered array; each item is {find, replace[, all]} (find must match EXACTLY once unless all:true), {append: text}, or {prepend: text}. Atomic + safe: nothing is written if any anchor is missing/ambiguous or (for .gd) the result fails to compile. Prefer this over write_script for small changes.

Search file contents under res:// for a substring (or regex with regex=true). Returns file:line matches.

Set a ProjectSettings value and persist project.godot. The property path goes in 'setting' ('name' is also accepted); e.g. set application/run/main_scene to res://main.tscn.

Set a property on a resolved object (undoable). value is coerced to the property's type (vectors accept "x y z" or [x,y,z]).

Assign a resource to a node's property (undoable). Use 'resource' (res:// path to load) OR 'class' (mint a new inline sub-resource of that class). e.g. set Sprite2D.texture from a path, or a fresh RectangleShape2D on CollisionShape2D.shape.

Stop the running play session.

Parse/compile GDScript WITHOUT writing it. Pass 'content' (source) or 'path' (res://). Returns whether it compiles — use before write_script to catch hallucinated APIs.

Block until a node appears in the RUNNING game (by path/name) or timeout. Use after play_scene to sync before driving.

Wait for a condition. Blocks the editor at most ~1.5 s per call — longer would stall the editor's own game-launch pipeline and background jobs (they need main-thread frames). If not met yet it answers 'not yet': just call it again. condition = play_started | play_stopped | game_connected | seconds:N | file_exists:res://path.

Write a text file under res:// (or user://), path-traversal guarded. Refreshes the editor filesystem.

Write a GDScript (or other text, e.g. .cs) file under res://. GDScript is validated first by default — refuses code that doesn't compile; non-.gd files (C#, config…) are written as-is (use build_csharp to compile-check C#). Set validate=false to force.