Skip to main content
Glama

set_node_properties

Idempotent

Apply one or more property updates to nodes in a Godot scene, with type validation and a single save at the end. Pass res:// paths or typed dicts for object properties.

Instructions

Set one or more node properties on a scene in one Godot process. Always-array: pass a single-element updates array for one-off edits. {x,y} / {x,y,z} / {r,g,b,a} auto-convert to Vector2 / Vector3 / Color. Values are checked against the property's declared type and error instead of silently storing that type's zero value. Object-typed properties (e.g. CollisionShape2D.shape) take a res:// path, a typed dict {type: ClassName, ...props} that constructs a Resource inline, or null to clear. Full value rules: the Property Values section of docs/tools.md. abortOnError stops on first failure (default false continues). Saves once at the end. Returns: results[] with one entry per update in input order (success or error). Errors while a Godot runtime session is active on this project; stop_project (or detach_project) clears it.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
updatesYesProperty updates to apply
scenePathYesScene file path relative to the project
projectPathYesPath to the Godot project directory
abortOnErrorNoStop processing on first error (default: false)

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultsNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv3.1.1

TDQS

A4.6/5.0
Behavior5/5

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

With only idempotentHint=true in annotations, the description carries real weight: it discloses type-checking behavior (errors instead of silently storing the zero value), auto-conversion of {x,y}/{r,g,b,a} literals, object-typed property handling via res:// path or typed dict, abortOnError continuing semantics, and 'Saves once at the end.' This is exactly the beyond-annotations context an agent needs for a mutation tool.

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

Conciseness4/5

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

Dense but front-loaded and every sentence carries information (array convention, conversion rules, type checking, abort behavior, session precondition). The pointer to 'the Property Values section of docs/tools.md' is a reasonable offload rather than a wall of text. Slightly information-dense, but nothing is wasted.

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?

An output schema exists, yet the description still notes the results[] shape and per-update ordering, and it covers the mutation's save semantics and the runtime-session error condition. For a batched write tool this is complete enough to call correctly.

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

Parameters4/5

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

Schema coverage is 100%, so baseline is 3, but the description adds genuine meaning: how `value` is interpreted (auto-convert, type-checked, object-clearing via null) and abortOnError's default behavior. It adds more than the schema's one-line field descriptions.

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?

Specific verb+resource: 'Set one or more node properties on a scene in one Godot process.' The write verb 'set' clearly contrasts with the read-only sibling get_node_properties, so an agent can route without opening either schema. Scope (one process, batched updates) is stated up front.

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?

Gives concrete invocation guidance ('Always-array: pass a single-element updates array for one-off edits') and an operational precondition (errors while a runtime session is active; stop_project/detach_project clears it). It stops short of naming alternatives like batch_scene_operations or add_node, so it lacks explicit when-not guidance.

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