Skip to main content
Glama

Node Manage

node_manage

Manipulate Godot node trees: delete, duplicate, rename, reorder, reparent nodes, manage groups, read hierarchy, and toggle editable children on instanced scenes.

Instructions

Node tree manipulation (delete, duplicate, rename, reorder, reparent, groups, hierarchy reads).

Resource forms (prefer for active-session reads): godot://node/{path}/properties, godot://node/{path}/children, godot://node/{path}/groups

Ops: • get_children(path) Direct children of a node (name, type, path each). • get_groups(path) Group names the node belongs to. • delete(path, scene_file="") Remove the node. Cannot delete scene root. Undoable. • duplicate(path, name="", scene_file="") Deep-copy a node + children as a sibling. Cannot duplicate scene root. • rename(path, new_name, scene_file="") Rename a node. Sibling-name collision and "/" / ":" / "@" rules apply. • move(path, index, scene_file="") Reorder among siblings. Index 0 = first. • reparent(path, new_parent, scene_file="") Move under a new parent. Children preserved. Cannot move into descendants. • set_editable_children(path, editable, scene_file="") Explicitly enable/disable Editable Children on an instanced scene root. Undoable when changed. Ancestors are never enabled implicitly. Disabling refuses saved child overrides, nested editable instances, attachments or signals that would be lost on save. Revert those first. • add_to_group(path, group, scene_file="") Add the node to a group. • remove_from_group(path, group, scene_file="") Remove the node from a group.

All write ops accept the optional scene_file guard — if non-empty, the mutation fails with EDITED_SCENE_MISMATCH when the editor's current scene doesn't match.

Writes inside non-editable scene instances are rejected before mutation. Use set_editable_children explicitly or edit the source scene. Deleting, renaming, reparenting, or reordering instance-owned nodes requires editing the source scene even when Editable Children is enabled.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "op": "<op>"
    },
    "name": "node_manage"
  }
}

Input Schema

NameRequiredDescriptionDefault
opYes
paramsNo
session_idNo

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv4.4.1
    • changedInput schema / properties / op / enum
      Previous value: -[
      -  "add_to_group",
      -  "delete",
      -  "duplicate",
      -  "get_children",
      -  "get_groups",
      -  "move",
      -  "remove_from_group",
      -  "rename",
      -  "reparent"
      -]New value: +[
      +  "add_to_group",
      +  "delete",
      +  "duplicate",
      +  "get_children",
      +  "get_groups",
      +  "move",
      +  "remove_from_group",
      +  "rename",
      +  "reparent",
      +  "set_editable_children"
      +]
  2. First observedv2.9.1

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses undoability, deletion restrictions, deep-copy duplication, rename collision rules, reparent descendant restrictions, explicit Editable Children semantics and refusal conditions, and the scene_file EDITED_SCENE_MISMATCH guard. It also explains that writes inside non-editable instances are rejected and that instance-owned structural edits require source-scene editing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Despite its length, the description is structured and front-loaded: purpose first, then resource forms, then per-op behavior, then shared guards and restrictions. Every section adds operational value for a ten-op dispatcher, and there is little to no redundant repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is complex and lacks annotations and meaningful schema descriptions, but the description supplies the operation list, per-op parameter meaning, mutation constraints, guard behavior, and call shape. An output schema exists, so return-format documentation is not required, and the description is complete enough for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description compensates by documenting each operation's parameters and semantics: path, scene_file, name/new_name, index, new_parent, editable, and group. It also explains the canonical {"op": ..., "params": {...}} shape and notes that flat op parameters are a compatibility alias, which is essential beyond the untyped params object in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific resource and verb set: node tree manipulation with explicit operations for delete, duplicate, rename, reorder, reparent, groups, and hierarchy reads. The enumerated ops make it clear this is the dispatcher for node-tree mutations and hierarchy/group reads, distinct from property, creation, or search-oriented siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is clear per operation, including constraints such as not deleting or duplicating the scene root, not moving into descendants, and editing the source scene for instance-owned nodes. It also recommends resource forms for active-session reads. It does not explicitly route agents to sibling tools such as node_get_properties, node_find, node_create, or node_set_property, so a small sibling-routing gap remains.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.