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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the addition of a node and does not disclose whether the scene file is modified on disk, whether saving is required, how existing nodes are affected, or any side effects beyond the add action.

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

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

The single-sentence description is concise and free of fluff, which is structurally positive. However, it is so minimal that it under-specifies critical contextual details, so brevity comes at the cost of usefulness.

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

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

For a tool with 6 parameters, no output schema, no annotations, and many sibling tools, the description is far too thin. It fails to explain where the node is added, how parentNodePath is used, whether this is a persistent file edit or runtime operation, or how it relates to game_spawn_node and modify_scene_node.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema and the description adds no additional semantic value. The baseline of 3 applies because the description does not compensate with extra context such as default parent behavior or how properties are applied.

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

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

The description states a specific verb ('Add') and a resource ('a node') with a target context ('an existing scene'), making the core operation clear. It is not merely a tautology, though it could more explicitly distinguish itself from runtime spawning or scene-file editing operations.

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

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

There is no guidance on when to use this tool versus alternatives such as game_spawn_node, game_instantiate_scene, or modify_scene_node. The description implies design-time scene editing but never states exclusions or conditions, leaving the agent to guess when this tool is appropriate.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals that the operation runs headless and implies a mutation, but it does not state that the scene file is modified, whether an existing script attachment is replaced, or whether the change is persistent. For a mutating tool this is a significant gap.

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

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

A single front-loaded sentence with no filler; 'Attach a GDScript to a scene node' immediately conveys the operation and '(headless)' adds the key execution mode. The brevity is appropriate for a tool whose parameters are fully documented in the schema.

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

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

For a four-parameter tool with full schema coverage the basic call is well specified, and 'headless' provides useful execution context. However, the lack of side-effect disclosure—what gets written, whether the operation can overwrite—and the absence of an output schema leaves the agent without a complete mental model.

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

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

Schema description coverage is 100%, so all four parameters are already documented with meaningful descriptions. The tool description adds no additional parameter semantics, and the baseline of 3 applies because the schema does the necessary work.

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

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

States a specific verb and resource: attaching a GDScript to a scene node. The 'headless' qualifier and the verb distinguish it from sibling tools like create_script and modify_scene_node, so an agent can tell it apart.

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

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

No guidance on when to use this tool vs alternatives such as create_script or modify_scene_node, and no mention of prerequisites like the script already existing or the scene being open. The only hint is 'headless', which implies non-interactive use rather than a clear selection rule.

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

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

The description does not disclose behavioral traits such as whether existing files are overwritten, if permissions are required, or side effects. With no annotations provided, the description carries the full burden for safety information but fails to address key behaviors.

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

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

The description is a single sentence with no filler words. It is front-loaded and efficient, earning its place.

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

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

For a file creation tool, the description is minimal. It does not explain what happens on conflict, whether a template is used, or require the .csproj context. The schema covers parameter details, but overall completeness is average.

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

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

All 7 parameters have descriptions in the schema (100% coverage), so the description adds no additional meaning. The baseline of 3 is appropriate as the schema already handles parameter semantics.

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

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

The description clearly states the tool creates a C# script file in a Godot .NET project, using a specific verb and resource. It distinguishes itself from sibling tools like 'create_script' which is likely for GDScript, making its purpose unambiguous.

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

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

The description gives a general context (C# script for Godot .NET) but does not explicitly state when to use this tool vs alternatives like 'create_script' or 'attach_script'. It lacks guidance on prerequisites or when not to use it.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only states the creation action and does not reveal what happens if the directory already exists, whether parent directories are created automatically, or whether the operation is reversible. For a mutation operation, this is a notable gap.

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

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

The description is a single, front-loaded sentence with no filler or redundant restatement. It is appropriately brief for a simple tool, though the brevity trades away behavioral context that would have made it more useful.

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

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

The core invocation details are present through the schema, and the description gives the tool's domain. However, with no annotations and no output schema, the description leaves open questions about idempotence, recursive directory creation, and success/failure reporting. It is minimally usable but not fully self-contained.

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

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

Schema description coverage is 100%, so the baseline applies. The description does not add format or semantic details beyond the schema, but the schema already documents projectPath and directoryPath as a project path and a relative directory path. No additional parameter elaboration is critical.

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

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

The description states a specific action and object: creating a directory within a Godot project. The resource type 'directory' makes the tool distinguishable from file, scene, or resource creation siblings, though it does not explicitly name any alternative. It is clear but relies on the reader to infer the separation from related creation tools.

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

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

There is no guidance on when to use this tool instead of related siblings like create_resource, create_scene, or write_file, and no mention of preconditions or exclusions. The only contextual hint is 'inside a Godot project,' which is already implied by the tool domain. An agent is left to infer usage from the name.

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

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

With no annotations, the description must disclose behavior. It only says 'from scratch' but fails to mention side effects (e.g., directory creation, file overwriting), permissions, or error conditions. This is insufficient for safe invocation.

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

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

The description is extremely concise—one short sentence with no wasted words. It is front-loaded with the core action and resource, making it easy to parse quickly.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description provides adequate purpose but lacks details on return values, prerequisites, and potential side effects. It is minimally viable but not fully complete.

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

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

The input schema already has 100% coverage with descriptions for all three parameters. The description adds no additional semantic value beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Create'), the resource ('new Godot project'), and the scope ('from scratch'), effectively distinguishing it from sibling tools like create_scene or create_resource which deal with sub-components.

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

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

No explicit guidance on when to use this tool versus alternatives. For example, it does not mention that for creating a scene, one should use create_scene instead. The purpose is implied but no exclusions or context are provided.

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

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

With no annotations, the description carries the full burden, but only states that a .tres file is created. It does not disclose whether existing files are overwritten, whether directories are created, what happens with invalid resource types, or what the function returns.

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

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

One short sentence with no filler, and the key distinction (.tres resource file) is front-loaded. Every word earns its place.

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

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

The schema covers all four parameters adequately, so an agent can construct valid arguments. However, with no annotations or output schema, the description leaves out behavior (overwrite semantics, errors, return values) and usage context, making it only minimally complete for a file-creation tool.

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

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

Schema description coverage is 100%: projectPath, resourceType, resourcePath, and properties all have descriptions. The tool description adds no parameter-level semantics, so the baseline of 3 applies.

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

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

The description states a specific action and object: 'Create a .tres resource file (headless)'. It clearly identifies the resource type (.tres) and distinguishes this from sibling tools like create_scene, create_script, or save_scene without needing to open their schemas.

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

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

No guidance on when to use this tool vs alternatives such as manage_resource, create_scene, or save_scene. The phrase 'headless' hints at a CI/automation context but no explicit when/when-not or alternative routing is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the write nature of the operation but says nothing about whether an existing file at scenePath is overwritten, whether the .tscn extension is appended automatically, what root node is created when rootNodeType is omitted, or whether the project must already exist. For a file-writing tool this is a significant risk-surface gap.

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

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

The single sentence is waste-free and front-loads the purpose with no filler. However, for a write tool with 3 parameters, no annotations, and no output schema, one sentence is under-specification rather than appropriately sized — genuinely useful detail is absent.

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

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

This is a moderate-complexity tool (file creation, optional third parameter, no output schema) covered only by a single sentence. The description never addresses what the tool returns, whether existing files are overwritten, how the scene path extension is handled, or what happens when rootNodeType is omitted. An agent knows what the tool does but not how to invoke it safely in edge cases.

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

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

Schema description coverage is 100%, with all three parameters (projectPath, scenePath, rootNodeType) already documented in the schema. The description adds nothing about parameters beyond naming the operation, so the schema does the heavy lifting and the baseline 3 applies.

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

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

The description states a specific verb ('create') and resource ('Godot scene file'), and the word 'new' signals this is distinct from save_scene. However, it does not explicitly name or contrast sibling tools like save_scene, add_node, or modify_scene_node, leaving the boundary implicit rather than stated.

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

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

No guidance is given on when to use this tool versus save_scene (saving an existing scene), add_node (adding a node to a live scene), or modify_scene_node (editing an existing scene). There are no preconditions, exclusions, or routing hints — an agent must infer usage entirely from the tool name and one-line description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the primary action. It does not disclose whether an existing script is overwritten, whether directories are created, whether the project must be open, or what the command returns. For a file-creating mutation, these are material side effects an agent should know about.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to the primary purpose.

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

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

The tool has six parameters but only two required, and the schema describes all of them; the action is conceptually simple. However, with no annotations and no output schema, the description leaves important invocation details unsaid, such as overwrite behavior and template semantics, so it is adequate but not complete.

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

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

Schema description coverage is 100%, so the parameter semantics are already well documented. The description adds only the template context; it does not add meaning to source, extends, methods, or className beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description names a specific verb and resource: create a GDScript file, and adds the 'from a template' qualifier, so an agent can tell it apart from generic write_file or create_scene. It does not explicitly distinguish it from attach_script, which could also be script-related, so it stops short of full sibling differentiation.

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

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

The purpose statement implies the usage context: when a GDScript file needs to be generated from a template. There is no explicit guidance about when not to use it or which sibling, such as attach_script or write_file, should be used instead, so the guidance is only implied.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It reveals the destructive nature implicitly through the word 'Delete' but does not clarify whether deletion is permanent, what happens if the file does not exist, or whether directory deletion is supported.

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

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

The description is a single efficient sentence with no filler words or redundant details. It front-loads the core action and resource, earning its place fully.

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

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

The tool is simple with only two required parameters and a well-covered schema, but it is destructive and has no annotations or output schema. The description leaves out important operational details like reversibility, missing-file handling, and whether only files (not directories) are deleted, making it minimally adequate but incomplete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds only the 'Godot project' context and does not provide additional meaning about path handling, validation, or side effects beyond the schema.

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

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

The description uses a specific verb ('Delete') and resource ('a file from a Godot project'), clearly distinguishing it from sibling tools like write_file, read_file, and rename_file. The scope is immediately understandable and not a tautology.

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

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

There is no guidance on when to use this tool versus alternatives, nor mention of caution for destructive operations. The description states the action but does not help an agent decide between delete_file and related file-management siblings like rename_file or write_file.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a scene is exported into a MeshLibrary resource, but does not mention side effects such as file overwriting, whether the scene is modified, whether directories are created, or what happens on failure.

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

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

The description is a single concise sentence that directly conveys the tool's purpose. It contains no filler or redundant phrasing and is easy to parse quickly.

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

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

With no annotations and no output schema, the description is too sparse to be considered complete. It does not explain expected return values, default behavior when meshItemNames is omitted (though the schema does), overwrite behavior, or any constraints on the scene or output paths.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including scenePath, outputPath, projectPath, and meshItemNames. The description adds no extra parameter meaning beyond what the schema provides, which fits the baseline of 3.

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

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

The description states a specific action ('Export') on a specific resource (a scene) with a clear output type (MeshLibrary resource). It is easily distinguished from sibling tools like export_project and create_resource even without opening the schema.

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

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

The description gives no guidance on when to use this tool versus alternatives such as export_project, create_resource, or manage_resource. There is no mention of prerequisites, when not to use it, or how it compares to similar tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Export' implies producing a build artifact, but the description doesn't disclose blocking behavior, whether outputPath is overwritten, error handling, or whether the editor/Godot binary must be running. For a tool with side effects (file creation), this is a significant gap.

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

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

A single seven-word sentence with zero wasted words and the core action front-loaded. It is efficient and appropriately minimal given the schema covers parameter details, though it forgoes the opportunity to add brief usage context without bloat.

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

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

With no annotations and no output schema, the description is the sole source of behavioral context, yet it omits prerequisites (a valid preset must exist), side effects (file overwrite at outputPath), and invocation expectations. For a build/export operation that produces a file artifact, the agent is left to guess at critical behavior.

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

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

Schema description coverage is 100%, so all four parameters (projectPath, presetName, outputPath, debug) are documented in the schema, including the debug default. The description's 'using a preset' loosely maps to presetName but adds no meaning beyond the schema. Baseline 3 applies since the schema does the heavy lifting.

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

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

The description states a specific verb ('Export'), a clear resource ('Godot project'), and the mechanism ('using a preset'). It is readily distinguishable from siblings like export_mesh_library (different resource) and manage_export_presets (manages presets rather than performing exports), though it doesn't explicitly name alternatives.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention that an export preset must already exist (e.g., created via manage_export_presets), that run_project is for executing rather than building, or any prerequisites or exclusions. An agent must infer all usage context.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It only says 'Create', which implies mutation but does not explain side effects, required parent hierarchy, effect-specific constraints, or what happens to the scene after the call.

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

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

The description is one short, direct sentence with no wasted words. It is efficient and front-loaded, though it could include a bit more context without becoming bloated.

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

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

For a creation tool with no annotations and no output schema, the description is too sparse. It does not explain the effect semantics, how the created node attaches to the parent path, or how parameters like size and intensity map to each effect type.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds little beyond naming the effect types; it does not clarify how size or intensity behave differently per effect type.

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

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

The description states a specific verb, 'Create', and names the exact resources it handles: ReflectionProbe, Decal, or FogVolume. This clearly distinguishes it from the many sibling tools that target other node types or operations.

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

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

The description implies usage: use this tool when you want to create one of the three listed 3D effect types. However, it gives no explicit guidance about alternatives or when not to use this tool, leaving comparison to siblings like game_spawn_node or add_node unaddressed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the immediate action without explaining whether this mutates the scene tree, whether an existing collision shape is replaced or additional shapes are stacked, whether the change is persistent, or what happens if the parent node is invalid.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the operation, and it is appropriately short for a straightforward mutation tool.

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

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

For a tool with 6 parameters, a nested object, no annotations, and no output schema, the description is too thin. It does not explain how shapeParams relate to shapeType, whether required parameters are sufficient in all cases, or what the agent should expect after the call.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description adds no parameter-level meaning beyond the schema, and the nested shapeParams object—whose contents likely vary by shapeType—is not elaborated in the tool description.

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

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

The description uses a specific verb ('Add') and resource ('collision shape to a physics body node'), making the core operation clear. However, it does not explicitly differentiate itself from sibling tools like game_physics_body, game_physics_2d, or game_shape_2d, so the distinction is implied rather than stated.

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

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

No guidance is given about when to use this tool versus alternatives such as modify_scene_node, game_physics_body, or game_physics_2d. There is also no mention of prerequisites, such as the parentPath needing to reference a valid physics body or area node before adding a collision shape.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only lists operation categories without disclosing side effects, whether queueing modifies playback state, what get_info returns, how speed interacts with ongoing playback, or whether stop resets state. For a control tool with mutating actions, this is insufficient.

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

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

The description is extremely compact with no filler words, and it front-loads the key resource and operation categories. However, it resembles a label more than a structured explanation, so it does not fully earn a top score.

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

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

This is a multi-action tool with no output schema and no annotations, and the description does not explain action semantics, return values, preconditions, or how it relates to overlapping siblings like game_play_animation. An agent would need to inspect the schema and experiment to understand expected behavior, which is a significant completeness gap.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters and their basic roles. The description adds no extra meaning beyond the schema; it merely echoes the action types. This matches the baseline for high schema coverage.

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

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

The description 'AnimationPlayer seek/queue/speed/info control' clearly identifies the target resource (AnimationPlayer) and the operations it covers (seek, queue, speed, info). It is specific enough to convey what the tool is about, though it is a noun phrase rather than a verb-driven statement and doesn't explicitly differentiate it from sibling tools like game_play_animation.

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

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

There is no guidance on when to use this tool versus alternatives such as game_play_animation or game_animation_tree. The action list in the schema implies some usage, but the description itself provides no context, conditions, or exclusions, leaving the agent to infer the right selection.

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

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

With no annotations present, the description must carry the full burden of behavioral disclosure, and it only hints at operations like state travel and parameter manipulation. It does not clarify that travel mutates the state machine state or that set_param changes animation parameters, nor does it mention read-only actions like get_state and get_params. This is minimal transparency for a tool that can both read and mutate.

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

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

The description is extremely short and contains no wasted words, but it is more of a fragment than a properly structured description. It front-loads the core concept but does not include a verb or complete sentence, making it feel under-specified rather than elegantly concise. A more balanced single sentence would convey the same information more effectively.

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

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

Given the tool's complexity — 5 parameters, multiple action modes, no output schema, and no annotations — the description is far too sparse. It does not explain how actions relate to parameters, what the return values are, or what side effects occur. The description is only minimally sufficient to hint at the tool's purpose, leaving an agent to infer most of the calling contract from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including the action options (travel, set_param, get_state, get_params) and parameter-specific fields. The description adds no extra meaning beyond what the schema provides, which matches the baseline of 3 for high coverage. It does not clarify relationships between actions and parameters, but the schema already covers that reasonably well.

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

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

The description names a specific resource (AnimationTree state machine) and indicates the operation areas (travel and parameters). It is distinct from sibling tools like game_play_animation and game_animation_control because it targets AnimationTree specifically. However, it is a noun phrase rather than a full verb+resource statement, so it could be clearer about what the tool actually does.

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

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

The description provides no guidance on when to use this tool versus alternatives such as game_play_animation, game_animation_control, or game_create_animation. There is no mention of prerequisites, intended scenarios, or situations where another tool would be more appropriate. Usage is only implied by the tool name and the word 'AnimationTree'.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only names the action and does not explain the effect of calling with no parameters, whether changes are persistent, or whether values are applied immediately. The all-optional parameter list makes this ambiguity more significant.

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

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

The description is a single compact sentence that front-loads the action and resource. Every word contributes to the meaning, with no filler or repetition.

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

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

For a simple setter this is mostly adequate: the schema covers all parameters, and no output schema is needed. However, with all parameters optional, the description does not clarify what happens when no arguments are provided, nor does it address likely edge cases around muting, soloing, or resetting volume.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and the Master bus default. The description adds no new parameter-level meaning beyond naming the supported operations, which keeps it at the baseline.

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

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

The description states a specific action ('Set volume, mute, or solo') and a specific resource ('audio bus'), which clearly conveys what the tool does. It is distinguishable from nearby siblings like game_audio_play and game_audio_bus_layout by the resource and action, though it does not explicitly name alternatives.

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

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

There is no guidance about when to use this tool versus game_audio_play, game_audio_bus_layout, or game_audio_effect. No prerequisites, exclusions, or alternative conditions are provided; the usage context must be inferred entirely from the verb 'Set' and the resource.

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

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

No annotations exist, and the description gives minimal behavioral context (e.g., it doesn't state whether operations are destructive, require permissions, or have side effects on mixing). The word 'create/remove' implies mutability but lacks detail.

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

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

The description is a single concise sentence with no redundancy. It could be slightly expanded to cover all actions, but it is not verbose.

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

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

Given moderate complexity (multiple actions, no output schema), the description is minimally sufficient but does not explain the interaction between parameters (e.g., when 'sendTo' is needed) or return behavior.

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

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

Input schema coverage is 100% and parameters are described, so schema already provides meaning. The description adds little beyond the schema's own descriptions (e.g., action values are listed in schema's description field). Thus baseline 3 is appropriate.

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

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

The description clearly identifies the tool as managing audio buses and routing, which aligns with its resource name and distinguishes it from sibling tools like game_audio_play or game_audio_effect. However, it omits some actions (e.g., 'list') and could be more precise about the full range of operations.

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

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

No guidance is provided on when to use this tool versus alternatives such as game_audio_bus (which might focus on single bus settings) or game_audio_effect. Without context, an agent may misuse it.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only states the actions without explaining side effects, state changes, or dependencies. For example, it does not clarify that 'add' appends or requires a bus, or that 'configure' needs an index. This is insufficient for a tool with multiple actions.

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

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

The description is very concise (one short phrase) and front-loaded with the core purpose. However, it lacks any structure or additional details that would improve clarity without increasing length.

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

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

Given no output schema and moderate complexity (6 parameters, nested objects), the description is incomplete. It does not explain return values, error states, or typical usage patterns, leaving the agent to infer from parameter names alone.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond the parameter descriptions in the schema. It does not clarify parameter relationships or usage order.

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

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

The description clearly states the verb ('Add/remove/configure') and the resource ('audio bus effects'), distinguishing it from sibling tools like 'game_audio_bus' which manages buses themselves. However, it omits the 'list' action from the schema, slightly reducing specificity.

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

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

No guidance is provided on when to use this tool versus alternatives, when to use each action (add vs remove vs configure), or prerequisites like needing an existing audio bus. The implied usage is minimal.

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

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

With no annotations at all, the description must carry the full behavioral disclosure burden, but it only states high-level actions. It does not explain what happens on invalid paths, whether volume/pitch modifications persist, how 'fromPosition' interacts with play, or whether loading a stream resets other playback state.

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

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

The description is a single short sentence that is front-loaded with the core verb and resource, containing no fluff. It is concise but arguably too terse given the tool's seven parameters and missing usage context.

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

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

For a tool with seven parameters, no annotations, and no output schema, this description is incomplete. It lacks side-effect disclosure, parameter interaction guidance, error behavior, and usage context, leaving substantial gaps for the agent to fill.

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

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

Schema description coverage is 100%, so the parameter meanings are already documented. The description adds minimal semantic value beyond naming the operation, and it slightly misaligns by not mentioning the 'resume' action listed in the schema. Baseline 3 is appropriate.

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

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

The description clearly identifies the resource type (AudioStreamPlayer node) and the core operations (play, stop, pause), which distinguishes it from audio bus or effect tools. However, it omits the 'resume' action and the broader control features like volume, pitch, bus, and stream replacement, so it understates the tool's full scope.

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

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

The description provides no guidance on when to use this tool versus alternatives like game_audio_bus, game_audio_effect, or game_get_audio. There are no stated conditions, exclusions, or sibling comparisons, so the agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full behavioral disclosure burden, but it only says 'Configure' and gives no detail on side effects, whether get_info returns data, failure behavior, or whether configuration is applied to an existing node. The tool actually supports a get_info mode, which the description does not reveal.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and names the target resource immediately, though it could have used the spare sentence to mention the get_info action.

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

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

Given that this tool has two distinct actions, six parameters, no output schema, and no annotations, a one-line description is insufficient. The agent is not told what get_info returns, what each action does, or what behavioral consequences configuration has on the audio player. The schema covers parameter names but not enough context for correct invocation.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds little beyond labeling the parameters as 'spatial properties', but it does not need to compensate for missing schema descriptions. It still does not clarify the difference between the configure and get_info actions.

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

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

The description names a specific resource (AudioStreamPlayer3D) and a specific operation (Configure spatial properties), which clearly distinguishes it from sibling audio tools like game_audio_play and game_audio_bus. However, it omits the get_info action that the schema exposes, so it under-describes the tool's full purpose.

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

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

There is no guidance about when to use this tool versus alternatives such as game_audio_play, game_audio_bus, or game_audio_effect. The description implies 'spatial audio configuration' but never states when that is appropriate or when it is not.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions timeout and return args, but omits what happens on timeout (error vs empty result), whether the call blocks, whether the signal must already be connected to the node, and whether awaiting consumes the signal. For a potentially blocking operation, this is a significant gap.

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

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

Eight words that pack in the action, the timeout modifier, and the return behavior — efficient and front-loaded with zero filler. It borders on under-specification but earns credit for density.

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

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

With no annotations and no output schema, the description is the only behavioral context, yet it omits timeout failure behavior and return structure. For an await operation, the agent cannot tell what happens when the signal never fires or what format the returned args take.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description's 'return args' hints at the signal payload but adds no meaning beyond what the schema already documents for timeout, nodePath, and signalName.

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

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

States a specific verb ('await'), a resource ('signal'), and key modifiers (timeout, return args). The action is distinguishable from signal siblings like game_connect_signal, game_disconnect_signal, and game_emit_signal, though it doesn't explicitly differentiate itself from the similarly named game_wait.

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

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

No guidance on when to use this tool versus alternatives such as game_wait (time-based waiting) or the signal management tools. No exclusions, prerequisites, or alternative conditions are named; the usage context is only implied by the action verb.

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

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

The description reveals that the tool can both read and mutate bone poses, which is useful, but it does not disclose side effects, persistence behavior, or what happens when setting pose data. With no annotations provided, the description carries the full burden and only partially covers it.

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

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

The description is a single concise sentence with no filler. It front-loads the action ('Get or set') and the target resource, making it scannable and information-dense.

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

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

With seven parameters, no annotations, and no output schema, an agent needs more context to invoke this tool correctly—such as how to choose between boneName and boneIndex, which parameters are required for set versus get, and what list/get/set return. The current description leaves too much for the agent to infer.

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

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

Schema description coverage is 100%, so every parameter already has a semantic description. The tool description adds general context about bone poses but does not add meaning beyond the schema, which matches the baseline for fully covered parameters.

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

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

The description states a specific verb pair ('Get or set') and a precise resource ('bone poses on a Skeleton3D node'), making the tool's function immediately clear. It also distinguishes itself from related sibling tools like game_skeleton_ik because it targets pose values rather than IK solving.

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

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

The description provides no guidance on when to use this tool versus alternatives such as game_get_property, game_set_property, or game_skeleton_ik. There is no mention of prerequisites, when get/set/list is appropriate, or how this tool relates to other bone or skeleton tools.

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

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

No annotations are present, so the description must carry the full burden of behavioral disclosure. It does not warn that invoking an arbitrary method can mutate game state, fail at runtime, or produce side effects depending on the method called.

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

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

One tight sentence with no filler, and the core action and target are front-loaded. Every word earns its place.

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

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

For an arbitrary method-invocation tool with no output schema and no annotations, the description omits key operational details such as whether the method's return value is returned and what failure modes exist. This makes the tool riskier to invoke blindly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description's mention of optional arguments adds no meaning beyond the existing args property.

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

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

States a specific action ('Call a method') applied to a concrete resource ('any node in the running game') and mentions optional arguments. This clearly distinguishes it from sibling property get/set tools and arbitrary expression evaluation tools.

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

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

No guidance is given on when to use this tool versus alternatives like game_eval, game_set_property, or other node-specific tools, and no exclusions are provided. Usage is only implied by the action itself.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Configure' without explaining that the action parameter supports get and set, what side effects occur, or whether reads and writes are both covered. The agent gets almost no behavior detail beyond the tool's name.

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

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

The description is a single, front-loaded sentence with no redundant wording. It is concise and readable, though its brevity means it sacrifices useful context about the action parameter and usage nuances.

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

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

For a tool with 7 parameters, no annotations, and no output schema, this description is too minimal. It omits how the action parameter works, whether parameters can be combined, any defaults or side effects, and how it fits among the many camera-related sibling tools.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds only a high-level grouping of DOF, exposure, and auto-exposure, which maps to the schema but does not add meaningful semantics beyond it.

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

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

The description names a specific verb ('Configure') and a specific resource ('camera') with clear attribute areas (DOF, exposure, auto-exposure). It distinguishes the tool's focus from siblings like game_set_camera, though it does not explicitly differentiate itself or mention the dual get/set capability.

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

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

The description implies this tool is for adjusting camera DOF, exposure, and auto-exposure settings, which gives an agent a reasonable usage context. However, it provides no explicit when-to-use guidance, no exclusions, and no mention of alternatives or how it relates to game_set_camera or camera-related tools.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states 'create/configure' but does not mention that this is a mutation operation that modifies the scene tree, requires specific permissions, or any side effects.

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

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

The description is a single sentence with no redundancy. It is concise but could be more informative without increasing length significantly.

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

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

With 8 parameters, nested objects, and no output schema, the description is too sparse. It does not explain how actions relate to parameters (e.g., which parameters are needed for each action) or what the tool returns. Significant gaps remain.

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

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

Schema coverage is 100% with descriptions for all 8 parameters. The description adds minimal meaning beyond the schema, just grouping the operations. A baseline of 3 is appropriate.

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

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

The description specifies creating/configuring CanvasLayer and CanvasModulate, which are distinct resources not covered by sibling tools. However, it does not explain what these nodes do, slightly reducing clarity.

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

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

No guidance on when to use this tool versus alternatives like game_canvas_draw or other node creation tools. The description provides no context for appropriate usage.

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

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

No annotations exist, so description must bear full burden. It does not disclose side effects (e.g., clearing screen with 'clear' action), coordinate system, or that it draws on a parent canvas node identified by parentPath. Parameter descriptions in schema help but overall behavioral context is missing.

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

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

Single sentence efficiently captures core purpose and lists actions. It is front-loaded. Could benefit from a bit more context without being verbose, but currently very concise.

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

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

Given 14 parameters and 6 actions, no output schema, and no annotations, the description is too sparse. It does not explain the overall workflow (e.g., need for parentPath, drawing behavior per action) or how parameters interact. Schema descriptions provide partial remedy, but overall completeness is low.

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

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

Schema coverage is 100% and parameter descriptions are clear. Description adds no additional semantics beyond listing actions; it does not clarify parameter relationships (e.g., from/to for line, points for polygon). Baseline 3 is appropriate.

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

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

Description '2D drawing: line/rect/circle/polygon/text/clear' lists specific actions, clearly indicating the tool is for drawing shapes and text on a canvas. It distinguishes from sibling tools like game_canvas (which likely manages canvas nodes) and game_debug_draw (debug visualization) by enumerating primitives.

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

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

No guidance on when to use this tool versus alternatives such as game_canvas or game_debug_draw. The description does not mention prerequisites (e.g., needing a canvas node) or context for each action.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It states that the scene changes but does not disclose important runtime effects such as whether the current scene is unloaded, whether game state is lost, or whether the change is instant and reversible. For a mutating runtime operation, this is a notable transparency gap.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning: the action, the object, and the runtime context are all present, and nothing needs to be trimmed or expanded for readability.

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

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

This is a simple tool with one parameter and no output schema, so the description covers the basic purpose and parameter semantics adequately. However, the absence of any behavioral detail about runtime side effects and the lack of guidance relative to similarly named scene tools make it only minimally complete for reliable agent selection.

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

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

The input schema fully documents scenePath with a type and a clear example, and all one parameter is covered, so the baseline is 3. The description does not add extra semantic detail beyond the schema, but none is critically needed for this simple parameter.

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

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

The description uses a specific verb ('Switch') and a precise resource ('scene file in the running game'), making the tool's function immediately understandable. It is also sufficiently distinct from siblings like set_main_scene, save_scene, and game_instantiate_scene because it emphasizes the runtime context and the act of changing the current scene.

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

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

The phrase 'in the running game' implies when to use this tool: during a live game session when the current scene should be replaced. However, it does not explicitly contrast with related sibling tools such as game_instantiate_scene or set_main_scene, leaving some room for an agent to confuse scene switching with scene instantiation or project-level configuration.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. The word 'Click' transparently states the core action, but the description does not disclose coordinate space, whether it synthesizes press/release events, or what return/error behavior to expect. It is minimally adequate but leaves gaps.

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

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

The description is a single, direct sentence with no filler. The key scoping information ('running Godot game window') is front-loaded, and every word earns its place.

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

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

For a simple three-parameter input tool with no annotations and no output schema, the description plus schema is minimally callable. However, it leaves out the coordinate system, any mention of the return value, and details about the synthesized click event, so it is complete enough to attempt a call but not fully informative.

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

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

Schema description coverage is 100%, so x, y, and button are already documented in the schema. The description adds only the context that the click position is in the game window, which is useful but does not meaningfully extend parameter semantics beyond the schema.

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

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

The description uses a specific verb ('Click') and a specific resource ('position in the running Godot game window'), clearly stating what the tool does. It is easily distinguishable from sibling tools like game_mouse_move or game_mouse_drag, even without naming them.

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

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

The description implies the tool is for clicking inside a running Godot game window, which gives some context. However, it does not explicitly say when to prefer this over alternatives such as game_mouse_move, game_mouse_drag, or game_key_press, nor does it give exclusion criteria.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only says 'connect' and does not mention whether the connection is runtime-only, how duplicates are handled, whether prior connections are replaced, or what errors can occur. This is a significant transparency gap for a mutating runtime operation.

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

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

The description is one focused sentence that immediately states the verb, subject, and scope. There is no filler or redundant wording.

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

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

For a 4-parameter mutation tool with no output schema and no annotations, the description is minimally adequate but incomplete. It does not clarify the lifetime of the connection, side effects, or failure behavior, and it gives no usage context relative to the many related signal tools. Still, the schema fully covers parameters, so it is not seriously underspecified.

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

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

Schema description coverage is 100%, so baseline 3 is appropriate. The description adds the high-level relationship between source and target nodes, but all per-parameter meaning is already present in the schema and the description does not significantly extend it.

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

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

The description states a specific action ('Connect'), a precise resource ('a signal from one node to a method on another node'), and the environment ('in the running game'). It is clearly distinguishable from siblings like game_emit_signal, game_disconnect_signal, and game_await_signal based on the wording alone.

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

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

There is no guidance about when to use this tool versus alternatives such as game_disconnect_signal, game_emit_signal, or game_await_signal. The description only defines the operation but does not explain conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that an animation is created and does not explain whether existing animations with the same name are overwritten, what side effects occur on the AnimationPlayer, or what the resulting animation object contains.

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

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

The description is a single sentence that starts with the action verb and contains no filler. It is appropriately concise, though it is also quite sparse for a six-parameter tool.

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

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

With no annotations and no output schema, the description must provide more context than it does. It does not explain how tracks and keyframes are structured, whether the animation is added to an existing library, or how the operation behaves on the AnimationPlayer. The complexity of the tool's parameters is not matched by the description's content.

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

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

Schema description coverage is 100%, so all six parameters already have individual descriptions. The phrase 'tracks and keyframes' adds a small hint about the tracks array, but it does not substantially extend or clarify the schema's parameter documentation.

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

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

The description uses a specific verb-resource pair ('Create an animation') and adds the key content ('with tracks and keyframes'), making the tool's purpose clear. It does not explicitly differentiate from siblings like game_play_animation or game_tween_property, but 'create' is a distinct action.

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

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

There is no guidance on when to use this tool versus closely related siblings such as game_play_animation, game_tween_property, or game_animation_control. The intended usage is only implied by the verb 'create,' with no mention of prerequisites like an existing AnimationPlayer or common alternatives.

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

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

There are no annotations, so the description carries the full burden of disclosing behavioral traits. It only states the basic operation and omits important context such as scene mutation, required node paths, joint type constraints, or whether the operation can be undone.

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

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

The description is a single, direct sentence with no filler, and it is front-loaded with the key action and target. However, it may be too terse for a tool with eight parameters, leaving room for additional useful context without adding bloat.

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

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

For a tool with eight parameters, no annotations, and no output schema, this description is thin. It does not explain return values, prerequisites, joint type behavior, or how the operation affects the scene, so an agent lacks enough context to use the tool confidently beyond the parameter list.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal semantic value by indicating the joint connects two bodies, which weakly maps to nodeAPath and nodeBPath, but it does not meaningfully elaborate beyond the schema.

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

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

The description uses a specific verb ('Create') and identifies the resource ('physics joint') and the target objects ('between two bodies'). It is clear at a high level, though it does not explicitly distinguish itself from related physics/sibling tools.

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

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

No guidance is given about when to use this tool versus alternatives like game_physics_body, game_add_collision, or other joint-related operations. Prerequisites such as the bodies existing in the scene are not mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, yet it only says 'Create a Timer node.' It does not disclose that this is a scene-tree mutation (adding a node under parentPath), whether it replaces an existing node with the same name, whether the created timer is active immediately, or what the tool returns on success. For a write operation, this is a significant transparency gap.

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

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

The description is a single short sentence that leads with the action and object, making it easy to scan. The only mild waste is 'with configuration,' which is largely implied by the existence of parameters, but the overall brevity is appropriate.

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

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

For a creation tool with no annotations, no output schema, and five parameters, the description is too thin. It fails to mention the side effect (adding the node to the scene tree), the target under parentPath, or what happens after creation. An agent cannot fully infer the tool's impact on the scene without additional investigation.

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

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

Schema description coverage is 100%, so every parameter (name, oneShot, waitTime, autostart, parentPath) is already documented with its meaning and default in the input schema. The description's 'with configuration' adds no parameter-level detail beyond the schema, but per the baseline rule for high coverage, the schema carries the semantic load adequately.

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

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

The description states a specific verb ('Create') and a concrete resource ('Timer node'), which is sufficient to identify the tool's function and distinguish it from the many sibling tools that operate on other node types (e.g., game_create_animation, game_spawn_node). The phrase 'with configuration' is vague but the schema names the configurable properties. It stops short of 5 because it does not clarify where the node is created or how it differs from generic scene-creation siblings.

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

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

The description offers no guidance on when to use this tool versus alternatives such as game_spawn_node, game_instantiate_scene, or add_node, all of which could plausibly create a Timer node. There are no exclusions, prerequisites, or context cues (e.g., 'use when adding a scene-tree timer') to help an agent select between siblings.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. 'Create/configure' implies mutation, but the description never states whether configure modifies nodes in place, whether boolean operations rebuild the CSG tree, what constraints apply, or what side effects occur. For a geometry-mutating tool this is a meaningful transparency gap.

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

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

A single sentence, verb first, with zero filler — very economical. It is concise without being a tautology. It loses a point because the brevity sacrifices mode/type organization that a short clause could have provided (e.g., naming box/sphere/cylinder/combiner).

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

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

For a 10-parameter tool with two actions, five CSG types, no annotations, and no output schema, this description is thin. It does not explain the create-vs-configure workflow, which parameters apply to which csgType, how the combiner and boolean operations interact, or what success looks like. An agent would need substantial inference to call this correctly.

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

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

Schema coverage is 100%, so per the baseline rule the description need not repeat parameter details. The description's only parameter-level contribution is hinting that 'boolean operations' map to the operation field. It adds no cross-parameter insight (e.g., size applies to box, radius to sphere/cylinder, nodePath for configure), which leaves value on the table but does not drop below baseline.

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

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

The description states a specific verb-resource pair ('Create/configure CSG nodes') and adds a distinguishing modifier ('boolean operations'). This separates it from generic siblings like game_spawn_node or game_procedural_mesh. However, it stops short of naming the supported shape types or the combiner node, so an agent must open the schema to fully pin down scope.

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

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

There is no guidance on when to use this tool versus alternatives, and no conditions selecting 'create' vs 'configure'. It gives no prerequisites, no exclusions, and no mention of how it relates to siblings like game_spawn_node or game_remove_node. The agent is left to infer usage from the schema alone.

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

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

No annotations are provided, so the description carries the burden of disclosing behavioral traits. It only says 'draw' and does not disclose that debug draws are typically temporary overlays, how duration/persistence works, or that 'clear' removes previous draws. It is not misleading, but it under-discloses behavior.

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

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

The description is a single, compact sentence that front-loads the action, resource, and dimensionality. Every word earns its place and there is no filler or redundancy.

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

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

With 8 parameters, no annotations, and no output schema, the one-sentence description is too thin. It does not explain the conditional groupings (from/to for lines, center+radius for spheres, center+size for boxes) or the 'clear' action. The schema documents individual parameters well, but an agent still has to infer multi-action semantics from parameter names.

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

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

Schema description coverage is 100%, and each parameter already has a meaningful comment such as 'Line start', 'Box size', and 'Sphere/box center'. The description adds no new parameter semantics beyond grouping line/sphere/box concepts, which the schema already exposes through the action parameter. The baseline of 3 is appropriate.

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

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

The description states a specific verb ('Draw'), resource ('debug lines, spheres, or boxes'), and scope ('in 3D'). This distinguishes it from 2D drawing tools like game_canvas_draw and from mesh/scene creation tools. The primary purpose is unambiguous.

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

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

The word 'debug' implies diagnostic visualization and '3D' hints at the relevant sibling space, but there is no explicit when-to-use guidance, no mention of alternatives, and no cleanup guidance via action='clear'. An agent must infer usage context from the name and schema rather than being told.

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

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

No annotations exist, so the description carries full behavioral burden. The verb 'disconnect' implies mutation, but the description does not disclose what happens if the connection does not exist, whether the change is reversible via game_connect_signal, whether it affects only the live session, or what failure modes are possible. This is a significant gap for a state-mutating tool.

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

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

A single 8-word sentence with the verb front-loaded and zero filler. It is appropriately sized for a simple operation, though slightly terse given the absence of annotations.

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

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

With no annotations and no output schema, this 4-required-parameter mutation tool should provide more context: error behavior for nonexistent connections, reversibility, and relationship to sibling signal tools. The description leaves these gaps unfilled, making it insufficiently complete for an agent to confidently invoke.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (nodePath, signalName, targetPath, method). The description adds no parameter-level meaning beyond the schema, which matches the baseline of 3 for high schema coverage.

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

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

The description uses a specific verb ('disconnect'), a clear resource ('signal connection'), and a scoping qualifier ('in the running game') that distinguishes this from editor-time signal editing. Its semantics inherently separate it from siblings like game_connect_signal, game_emit_signal, game_list_signals, and game_await_signal, though it does not name them explicitly.

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

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

The phrase 'in the running game' implies this is for runtime signal disconnection rather than static scene editing, which provides some selection context against manage_scene_signals and the game_* family. However, there is no explicit when-to-use guidance, no exclusions, and no mention of the natural pairing with game_connect_signal.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It states that a signal is emitted and that arguments may be passed, but it does not disclose that connected handlers will execute as side effects, that the node and signal must already exist, or what happens on invalid input. For a runtime-triggering tool with no annotation safety hints, this is under-disclosed.

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

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

The description is a single front-loaded sentence with no filler. Every phrase—'emit', 'signal', 'node', 'running game', and 'optionally with arguments'—earns its place and contributes to actionable understanding.

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

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

For a simple 3-parameter tool, the description plus schema provides enough to make a plausible call, but it omits realistic preconditions such as requiring an existing node and a valid signal name, as well as the fact that emission can trigger arbitrary game code. There is no output schema, yet the description still does not explain expected success or failure behavior, leaving a moderate completeness gap.

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

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

The input schema already describes all three parameters clearly, so the description does not need to restate them. The phrase 'optionally with arguments' reinforces the optional args parameter, but no additional meaning is added about nodePath format, signalName validity, or argument ordering and types. Baseline 3 applies due to high schema coverage.

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

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

The description states a precise action ('emit'), a specific target ('a signal on a node'), and the execution context ('in the running game'), plus optional arguments. This clearly distinguishes it from sibling tools like game_connect_signal, game_await_signal, and game_list_signals.

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

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

The verb 'emit' and the phrase 'running game' imply runtime triggering rather than scene-editing or signal setup. However, the description gives no explicit guidance on when to use this tool versus alternatives such as game_call_method or game_connect_signal, and it offers no 'when not to use' caveats.

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

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

With no annotations, the description carries the full burden, but 'Get or set...' only discloses that the tool has read and write modes. It does not reveal that 'set' is the default action, what 'get' returns, whether partial updates merge or reset unmentioned settings, or any error/validation behavior.

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

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

A single front-loaded sentence with no filler; it wastes nothing. It is efficient but so terse that it sacrifices context that a 19-parameter tool needs, though that tradeoff belongs more to completeness than to structure.

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

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

For a tool with 19 parameters, no output schema, and no annotations, the description is too thin. It omits the default action behavior, return shape for 'get', how settings are applied when only a subset is provided, and relationship to the running game environment. An agent has enough to guess the tool's domain but not enough to call it confidently.

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

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

The input schema covers all 19 parameters with individual descriptions, so the baseline is 3. The tool description adds no parameter-level meaning, and it does not compensate for missing ranges, units, or mode-specific interactions, but it does not need to reiterate the schema.

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

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

The description uses a clear verb ('Get or set') and names a concrete resource ('environment and post-processing settings'), which the input schema confirms (fog, bloom, SSAO, tonemapping, backgrounds). It is not vague, but it does not differentiate from closely related siblings like game_render_settings or game_3d_effects, so it falls just short of a 5.

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

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

There is no when-to-use guidance, no mention of alternatives, and no exclusions. An agent must infer from the name and schema when game_environment is appropriate versus game_render_settings, game_3d_effects, game_world_settings, or game_sky. The sentence states capability but not selection criteria.

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

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

With no annotations, the description carries full disclosure burden. It identifies the execution environment and return convention, but it never warns that arbitrary GDScript can mutate live game state irreversibly, nor does it describe error behavior, execution limits, or result serialization.

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

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

Two short sentences, zero filler. The core operation is front-loaded, and the return-value convention is stated directly. Every word earns its place.

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

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

For an arbitrary code-execution tool with no annotations and no output schema, the description is minimal but incomplete. It omits side-effect caution, error handling, and what returned values look like, even though the single-parameter schema is fully covered.

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

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

The input schema already documents the single `code` parameter at 100% coverage, so the baseline is 3. The description largely repeats the schema text ('Use "return" for values') and adds no new parameter-level meaning.

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

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

The description states a specific verb-resource pair: 'Execute GDScript in the running game.' This clearly identifies what the tool does and sets it apart from the many narrower game_* sibling tools. It does not explicitly name or contrast sibling alternatives, but the arbitrary-code-execution nature is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives like game_call_method, game_script, or game_get_property. The only usage note, 'Use "return" for values,' addresses how to format code, not when this tool should be selected.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the core purpose. It does not mention whether the search is recursive, whether it includes hidden nodes, what the return format is, or that it starts from the rootPath (default "/root"). These are meaningful behavioral traits an agent would need to predict the tool's behavior.

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

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

The description is concise and front-loaded, delivering the key action and target in a single clear sentence. It contains no filler, though it could add a bit more useful detail without becoming bloated.

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

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

For a simple two-parameter tool, the description plus schema is mostly sufficient to make a call. However, there is no output schema and the description does not clarify return shape or traversal behavior, which leaves some ambiguity for an agent selecting and interpreting results.

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

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

Schema description coverage is 100%, so the schema already documents both parameters: className and rootPath. The description adds little beyond naming the class-type search focus, which is the baseline expectation. It does not need to compensate for missing schema information.

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

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

The description clearly states the operation ('Find all nodes') and the resource ('of a specific class type in the running game'), making the tool's purpose immediately understandable. It is distinguishable from siblings like game_get_nodes_in_group because it searches by class rather than group, though it does not explicitly call out that distinction.

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

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

The description implies when to use the tool: whenever a caller needs every node of a given class in the running scene tree. However, it provides no explicit guidance about alternatives, such as game_get_nodes_in_group for groups or game_get_scene_tree for a broader view, so the agent must infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Send gamepad button or axis input event' and does not explain whether this injects an artificial engine event, requires a connected gamepad, has side effects on the running game, or returns any confirmation.

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

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

The description is a single, compact sentence that contains the essential verb and resource without any filler. It is front-loaded and easy to scan.

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

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

The schema fully covers the four parameters, and the tool is a simple single-purpose event sender, but with no annotations and no output schema the description leaves open questions about return values, prerequisites, and whether the event is simulated at engine level. It is minimally adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already documents all parameter meanings: type values, index purpose, value ranges, and the optional device index. The description adds no parameter information beyond what the schema provides.

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

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

The description clearly states a specific verb ('Send'), a resource ('gamepad button or axis input event'), and distinguishes this tool from sibling input tools like game_click, game_key_press, game_mouse_move, and game_touch. An agent can immediately identify that this is for gamepad-specific input.

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

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

The description implies usage for gamepad input events through the phrase 'gamepad button or axis input event', but it does not explicitly state when to use it versus alternatives or mention any exclusions. No routing to sibling tools like game_key_press or game_touch is provided.

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