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

With no annotations, the description fully discloses important behaviors: it creates in the default library, auto-creates AnimationPlayer if the path doesn't resolve (with parent requirement), and explains the root_node-relative track path handling. These are critical side effects and context not inferable from the schema.

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 tight, well-structured paragraph. It opens with the primary action, then the follow-up steps, and then crucial path semantics. No redundant or vague sentences exist.

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 and an output schema, the description covers the main workflow, prerequisites (parent exists), and side effects. It does not explicitly describe failure behavior for existing clips when overwrite is false, but the overall context is sufficient for an agent to select and invoke the 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the default library context, the auto-creation behavior tied to player_path, and the root_node relative path handling, which are not detailed in the parameter descriptions.

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 verb (Create), object (Animation clip), and context (inside an AnimationPlayer's default library). It differentiates from sibling tools like animation_manage by specifying that this creates the clip, not the tracks, and even directs users to proper follow-up 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 provides strong usage context by stating that after creating the clip, tracks are added via animation_manage ops. It also notes the auto-creation behavior for non-existent paths, though it could be more explicit about when not to use this tool compared to others.

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 disclosure burden, and it does this well: it notes that delete is undoable, play/stop are editor previews not saved with the scene, set_autoplay with an empty name clears, validate returns broken_count plus per-track issues, and list returns specific fields. It also explains the target_path resolution behavior for presets, which materially changes observable 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 long, but every line carries specification value: concise per-operation signatures, parameter syntax rules, and the canonical message shape. The first sentence summarizes scope, and the bullet structure makes many operations scannable without repeated boilerplate.

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 multi-operation tool with a generic schema, the description covers most operations in detail and even includes return summaries for list and validate. However, it omits seven operations that appear in the schema enum, including sprite-related operations and scaffolding operations, so an agent cannot correctly invoke those without additional information. This is a clear gap for a tool this complex.

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 0%, so the description must compensate, and it largely does: each operation includes a signature with defaults and concise parameter format notes, including track_path syntax, keyframe object shape, interpolation values, tween specs, and preset arguments. It is not a 5 because several operations in the schema enum (e.g., create_spritesheet_track, preset_bounce, scaffold_state_machine) are entirely absent from the description, leaving their parameters undefined.

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 opens with 'AnimationPlayer authoring' and enumerates a detailed set of operations, so an agent can identify the tool's domain and core resource. However, it does not explicitly differentiate itself from the sibling tool 'animation_create', leaving some ambiguity about which animation tool should be chosen for a given task.

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 clearly states the scope ('AnimationPlayer authoring') and provides a canonical call shape, but it never explicitly states when to prefer this tool over sibling tools like animation_create, nor does it list exclusions. This is clear context without alternative guidance, matching the 4 level.

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 disclosure burden. It does state the core behavior of each operation and the canonical call shape, including the compatibility alias for flat parameters. But it does not disclose side effects, prerequisites, error conditions, or distinguish mutating operations from the read-only get_tree_info beyond the verb itself.

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 compact and well structured. It front-loads the domain, then presents each operation in a scannable bullet list with signatures and brief explanations. The canonical call shape note is useful and not redundant, and there is 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 multi-operation tool, the description covers the main requirements: available operations, their parameters, and the invocation shape. An output schema exists and can cover return values, which the description need not duplicate. Missing end-to-end examples or failure behavior are minor gaps given the otherwise clear operation-level documentation.

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 is opaque at 0% parameter description coverage, so the description must compensate. It does so by listing each operation's parameters inline with defaults and enough context to understand their purpose, such as parent_path, anim_player_path, auto_advance, and position. Some details remain unspecified, such as exact tree_path notation or position coordinate format, but the description adds substantial meaning beyond the bare parameter names.

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's domain: AnimationTree state machine and blend tree managementsell. It enumerates five concrete operations with verbs like 'scaffold', 'add', and 'inspect', so an agent can see exactly what actions are available. It differentiates from sibling tools by resource type (AnimationTree), though it does not explicitly name or contrast 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?

Usage is implied through the operation list: each bullet explains what that sub-operation does/dss, so an agent can infer when to call scaffold_state_machine vs scaffold_blend_tree etc. However, there is no explicit guidance about when to use this tool instead of sibling tools like animation_manage or fsm_manage, and no exclusions or alternative routes are stated.

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 transparency burden. It discloses that no scene instance is created, that 'all' does not include inheritors, and that pagination works per section. It does not mention potential errors or permissions, but for a read-only inspection tool the disclosed behavior is substantial.

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 well-structured with resource form, ops, and call-shape sections, and every sentence adds value. It is somewhat lengthy due to detailed parameter explanations, but this is justified given the schema gap. It avoids repetition and stays organized.

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 an output schema, and the description provides complete operational context: purpose, usage, parameter details, pagination behavior, and call format. It leaves little ambiguity for an agent to select and invoke the tool correctly, even among many siblings.

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 0%, so the description must fully explain parameters. It does so extensively: sections can be a comma-separated string or list, defaults to ['properties'] only, 'all' excludes inheritors, and offset/limit apply per section. The op signature and call shape are also explained, fully compensating for the generic 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 clearly states the tool inspects Godot API documentation-shaped metadata from the ClassDB, with specific examples like 'what properties does X have' and method signatures. It distinguishes itself from runtime node inspection by noting it works 'without creating a scene instance', making it distinct from sibling tools like node_get_properties.

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 clear context on when to use the tool, such as 'prefer for active-session reads' and details the resource form. It explains section selection and pagination but does not explicitly name alternative tools or exclusion scenarios, so it falls short of a full 5.

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. It does disclose the core behavior of each operation (add, configure, remove, list) and the canonical call shape, but it does not mention side effects, reversibility, failure behavior, or the impact of operations like remove on the audio bus.

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 well-structured with a clear title, bulleted operation signatures, and the canonical call shape. It is appropriately sized for a multi-operation tool, front-loaded with the resource, and contains no filler.

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?

An output schema exists, so return values do not need explanation. However, with no annotations and a generic params schema, the description still leaves gaps around properties, effect_class enumeration, at_position semantics, and session_id usage. It is decent but not fully self-sufficient.

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 schema is generic and has 0% coverage, so the description is the only parameter documentation. It provides parameter names and defaults for each op, which is helpful, but leaves key details unexplained: the structure of properties, valid effect_class values, and the meaning of at_position=-1.

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 identifies the specific resource (AudioServer DSP bus effects) and enumerates four distinct operations with one-line definitions. It clearly distinguishes this tool from broader siblings like audio_manage by focusing on bus-effect management.

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 explicit guidance about when to use this tool versus alternatives such as audio_manage. The ops list implies use cases, but the description does not state prerequisites, exclusions, or when another tool would be more 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?

With no annotations, the description carries the full burden. It mentions that play and stop are 'Not undoable' and that generate_procedural_sfx writes to res://, which is good. But it doesn't disclose side effects like bus_add_effect potentially changing the audio routing, or scaffold_buses requiring audio driver setup, or the impact of player_set_stream on playback state. The description is incomplete for a mutation-heavy 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?

The description is long but well-structured: it uses a bulleted list with a consistent pattern (op name, parameters, one-line behavior), making it skimmable. It front-loads the resource overview, then lists ops in a natural grouping (player ops, list, generation, scaffolding, bus ops). The final paragraph on canonical call shape adds necessary format context. Slight verbosity but no fluff.

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 (16 ops, free-form parameters), the description covers the essential semantics for each op, including parameter defaults and enums. The output schema exists, so return values are accounted for. However, it lacks details on error handling, permissions, and the exact structure of 'params' (which is free-form). Also, it doesn't explain the relationship between 'op' and 'params' for each op beyond the inline lists. Overall, adequate but with gaps for 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?

The schema has only three parameters (op, params, session_id) with a free-form 'params' object (additionalProperties true), and 0% schema description coverage. The description compensates by enumerating each op's parameters in the text (e.g., player_create(parent_path, name=..., type=...), including defaults and value enums. This adds significant meaning beyond the schema, so a 3 is warranted; it's helpful but not exhaustive (e.g., the 'params' object structure is not formally defined).

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 is a broad dispatch table for audio operations, listing many verbs (play, stop, list, etc.) with one-line summaries. It clearly states the resource (audio nodes, buses, streams) and the operations available, and it is distinguishable from sibling tools by its scope (audio-focused). However, it lacks a single cohesive purpose statement; instead, it's an op-dispatch, which is clear enough for an agent.

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 usage hints for individual ops (e.g., player_set_playback says 'Pass only fields to change', play says 'Start real editor preview playback'), but it does not explicitly say when to use this tool vs siblings like audio_effect_manage (which likely handles effects). It implies usage through the op list but lacks explicit exclusions or alternative recommendations.

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. It discloses that autoloads are persisted to project.godot, that remove does not delete the underlying file, and that scaffold_game_manager creates a production-ready singleton. It does not mention side effects like overwriting existing files or requiring a project reload, but the disclosed persistence and non-deletion details are meaningful.

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 well-structured with a brief intro, a bulleted op list, and a canonical call shape note. It is slightly long but every section earns its place; the op list is essential and the call-shape note prevents invocation errors.

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 moderate complexity and the presence of an output schema, the description covers the key behaviors, parameters, and persistence side effects. It could add explicit notes on error cases or whether add overwrites an existing autoload, but the current content is sufficient for correct invocation in most 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 0%, so the description must compensate. It does so by documenting each op's parameters (name, path, singleton, script_path, max_lives) and their meanings. It does not provide full type details for every parameter, but the op-by-op breakdown gives an agent enough to construct valid calls.

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 that this tool manages Godot autoloads (global singletons), and enumerates the four operations (list, add, remove, scaffold_game_manager) with their specific effects. It distinguishes itself from the many sibling *_manage tools by naming its exact resource (autoloads) and the canonical call shape.

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 explains what autoloads are and when this tool is relevant, and the op list implicitly tells the agent which operation to choose. It does not explicitly state when to prefer a sibling tool (e.g., project_manage or script_manage) over this one, but the resource-specific scope and op names provide clear 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?

With no annotations provided, the description carries the full burden, and it does so thoroughly. It discloses sequential execution, first-error stopping, atomic rollback via undo history, preview-mode behavior with before/after node lists, the scope of rollback support, and scene-root-relative path conventions. This gives the agent accurate expectations about side effects and failure 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 long but information-dense and front-loaded with the core behavior. It loses a point because it repeats 'stops at the first error' after already stating it in the first sentence, and it references 'the example below' without actually providing an example in the visible text.

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 complex composite tool with no annotations, the description covers the command contract, execution semantics, failure rollback, preview path, path convention, and key constraints. The presence of an output schema relieves it from detailing return values, so nothing essential is missing for an agent to invoke it 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?

Although schema coverage is 75%, the description adds meaning well beyond the schema: it specifies the exact item shape (`{"command": ..., "params": ...}`), which plugin commands are expected, the semantics of preview=True and undo, and path conventions. This materially helps agents construct valid 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 opens with a specific action: 'Execute a list of editor sub-commands in order, stopping on first error.' It clearly distinguishes itself from the sibling MCP tools by instructing agents to use underlying plugin command names, not MCP tool names, and frames its purpose as composing multi-step edits into one call.

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?

It explicitly states when to use the tool: 'Use this to compose multi-step edits (create node + set property + attach script) into a single tool call.' It also gives concrete constraints like batch_execute not being allowed as a sub-command and preview mode restrictions. It stops short of naming alternative individual tools, but the use case guidance is clear.

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 behavioral disclosure burden. It does this well by stating the effect of each operation: 'Configure', 'Apply an impulse', 'Set collision layers and masks', 'Scaffold ... with collision shape', and 'Inspect'. It also discloses 2D/3D support. It stops short of detailing prerequisites, failure modes, or side effects on existing settings, so it is strong but not maximal.

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 tight bulleted list of five operations with signatures and one-line semantics. Every line carries essential information, and the purpose statement is front-loaded. 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?

Given the tool bundles five distinct operations alert, the description covers each operation's purpose and parameters, and an output schema exists so return-value documentation is unnecessary. The main remaining gap is the absence of error conditions, node prerequisites, and behavior when called on unsupported node types, but the core invocation context is 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 0%, so the description must compensate entirely for parameter meaning. It does: each operation lists its parameters with defaults (e.g., 'impulse=[0,0]', 'parent_path=""'), and 'configure_body' even names accepted property keys like mass, gravity_scale, and damping. The canonical call shape also clarifies how op and params are structured.

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 opens with 'Physics Body & Collision Management (2D and 3D)' and enumerates five specific operations, each with a verb and resource (e.g., 'apply_impulse', 'set_collision_layer_mask', 'scaffold_character_body'). This clearly communicates what the tool does and differentiates it from sibling tools like physics_manage or joint_manage.

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 operation list gives clear context about what the tool can do, and the header implies this is the tool for physics body and collision management. However, it does not explicitly state when to prefer this tool over alternatives or provide exclusions, leaving the agent to infer routing from sibling tool names.

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 does well: it discloses that make_current=True unmarks previously current cameras of the same class in one undo, that configure is class-aware, that scaffold_follow_2d adds an add_trauma() method to the camera, and that follow_2d reparents the camera under the target. It also notes the canonical call shape and compatibility alias. It doesn't disclose error behavior or permission requirements, but for a camera authoring tool the key side effects are well covered.

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 long but well-structured: a one-line summary followed by a bulleted op list with compact signatures and inline notes. Every op earns its place, and the canonical call shape note is useful. It is not maximally concise, but the density of information justifies the 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 the tool's complexity (9 ops, many parameters, no annotations, no schema-level parameter docs), the description is remarkably complete. It covers all ops, parameter semantics, side effects, and the call shape. It doesn't describe return values in detail, but an output schema exists, so that burden is partially lifted. Minor gaps: no explicit error/edge-case behavior and no mention of what happens when a camera_path is invalid, but these are not critical for an agent selecting and invoking the 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 0%, so the description must compensate for the schema's lack of parameter documentation. It does so extensively: each op lists its parameters with types, defaults, and semantics (e.g., drag_margins: {left,top,right,bottom} fractions [0,1], limits with optional edges, overrides merge over preset values). The only gap is that the schema's params object is a free-form anyOf, so the description's per-op parameter lists are the sole documentation, and they are detailed enough to be actionable.

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 opens with a specific verb and resource ('Camera2D / Camera3D authoring') and then enumerates nine distinct operations with concrete effects (create, configure, set_limits_2d, set_damping_2d, follow_2d, scaffold_follow_2d, get, list, apply_preset). This clearly distinguishes the tool from sibling tools like node_manage or viewport_manage by scoping it to camera-specific authoring.

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 explicit usage guidance: it states that transforms (position, rotation, scale, transform, global_*) live on the Node and should be set via node_set_property, not here. It also explains when to use get with an empty path (resolves to active camera) and when to use list. The op-by-op breakdown effectively tells an agent when to use each operation and what the alternatives are.

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 behavioral burden and does explain what gets created: CharacterBody2D/3D, collision shapes, cameras, and controller script features. However, it does not disclose side effects such as whether files/nodes are written, whether existing files are overwritten, or whether an open scene is required.

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 organized as a title, two op bullets with signature and behavior, genre notes, and a canonical call shape. Each sentence adds value, and the most important selection information is front-loaded.

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 two-op scaffolding tool with zero schema-level descriptions, the inline docs are nearly complete: signatures, defaults, genres, and call convention are all present. Minor gaps remain around parent_path/script_path semantics and filesystem/scene side effects, but the output schema can cover return values.

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 0%, but the description fully compensates by giving complete signatures with defaults for every op parameter, plus enum-like genre choices. The input schema only exposes op/params/session_id, so this inline documentation is essential and well-provided.

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 opens with a specific resource ('2D and 3D Character Controller Scaffolding') and enumerates two concrete operations, scaffold_2d and scaffold_3d, each with a clear verb and output. This distinguishes it from the many generic *_manage 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?

Genre mappings ('platformer' vs 'topdown', 'first_person' vs 'third_person') give concrete selection criteria within the tool. It doesn't explicitly say when to choose this over node_create/script_attach, but the 'Instantly scaffold a complete ...' framing implies it as a higher-level alternative.

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. It explicitly states that the tool 'Writes / removes client config files' and details each op's effect, including the destructive nature of 'remove'. It also hints at error states via the 'error' status in status(). It does not mention permissions or backup behavior, but the core side effects are transparent.

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 well-structured with a concise intro, a bulleted Ops list, and a clear canonical call shape. Every sentence adds meaningful information, with no redundancy or filler. The use of code formatting and list structure makes it 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?

Given the tool's moderate complexity, the description covers the essential behavior: supported clients, ops, call shape, and compatibility. An output schema exists, so the lack of return-value details is not a gap. The description is sufficient for an agent to correctly select and invoke the 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?

The schema has 0% description coverage, so the description must compensate. It effectively explains the 'op' enum via the Ops list, describes the 'params' object shape (including that 'client' is an id from status()), and clarifies the flat-parameters compatibility alias and top-level 'session_id'. This is strong parameter semantics despite no schema descriptions.

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 ('Configure') and resource ('AI clients... Godot AI MCP server'), and enumerates supported clients. The 'Ops' section further clarifies the distinct actions (status, configure, remove), making it easily distinguishable from sibling tools like editor_manage or scene_manage.

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 clearly indicates that the tool is for managing client config files and provides usage context for each op (status, configure, remove). It does not explicitly name alternatives or exclusions, but the purpose is so specific that usage intent is unambiguous. The canonical call shape and compatibility alias are also helpful guidance.

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 supplied, the description carries the behavioral disclosure burden; it does identify the operations as status/get/test interactions and documents the canonical call shape plus the flat-parameter compatibility alias. It does not mention side effects, authentication needs, or failure behavior, so transparency is only partial.

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 well-structured: a short title line, three scannable bullets, and a final call-shape note, with no filler or repetition. Formatting and backticks make the canonical call shape immediately visible.

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 three-op dispatcher with an output schema available, the description is largely adequate: it gives the operation inventory, intended use of each op, and the exact call envelope. The main gaps are usage boundaries and session_id semantics, but the specialized scope keeps the tool recognizable and callable.

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 schema has 0% description coverage, and the description partially compensates by naming the op values, showing a host default for get_action_schema_url, and clarifying that op/session_id remain top-level. However, the purpose of session_id and the expected contents of params per op are left unexplained, and the host argument shown in the description is not reflected as a top-level property in 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 opens with a concrete domain ('Cloud Bridge and ChatGPT Tunnel Management') and enumerates three specific operations with one-line explanations, so an agent immediately knows this tool is for cloud connectivity and tunnel/REST gateway status. It is easily distinguishable from the many *_manage siblings because no other sibling covers cloud tunnel or ChatGPT gateway setup.

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?

Each bullet implies a distinct use case: check status, get schema URL/setup instructions, or test connectivity. However, there are no explicit conditions, prerequisites, or statements about when not to use this tool versus alternatives such as network_manage or session_manage.

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 disclosure. It does disclose per-operation behavior: creating a shader template file, inspecting device capabilities, and compiling/dispatching a compute pipeline with read-back. It does not discuss failure modes, overwrite behavior, or resource cleanup, but the core effects of each op are clear.

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 front-loaded with the domain, then a compact bullet list of operations, followed by a single necessary call-shape note. Every line earns its place, with no filler or tautology.

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 dispatcher-style tool with three operations and no annotations, the description covers invocation shape, operation names, and per-op behavior; an output schema exists so return-value details need not be repeated. It still omits prerequisites and precise input_buffer semantics, but is reasonably complete for selecting and invoking the 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 0%, and the description compensates by providing op-specific parameter names, defaults, and brief purpose (e.g., shader_path, code, input_buffer, x/y/z_groups). It leaves exact buffer element types and input_buffer format implicit, but adds meaning that the generic params object cannot.

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 identifies a specific domain ('GPU Compute Shaders, RenderingDevice Uniform Buffers, and GPU Pipeline Execution') and lists three operations with clear verbs: create_shader, get_device_info, and run_compute. It does not explicitly differentiate from sibling tools like shader_manage or rendering_manage, but the resource scope is unmistakable.

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 header and operation list imply this tool is for GPU compute and RenderingDevice workflows, and the canonical call shape explains how to invoke it. However, there is no explicit 'use this instead of X' guidance or exclusions relative to the many shader/rendering sibling tools, so routing is left mostly to inference.

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 behavioral burden. It describes the primary effect of each operation, including that config_write writes a section/key/value into an INI file and json_generate serializes data. However, it does not disclose side effects like overwriting behavior, failure modes, or permission requirements.

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 compact and well-organized: a one-line domain summary, a bulleted list of operations with signatures, and a final call-shape contract. Every section earns its place, with 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?

For a multi-operation tool with an opaque generic schema, the description provides the complete catalog of operations, their parameter signatures, and the canonical call shape. The presence of an output schema covers return-value details. Minor gaps remain around expression syntax and whether writes overwrite existing values, but the description is sufficient for selection and 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 0%, but the description compensates by enumerating every operation's parameters with names, defaults, and brief semantic context, e.g., file_path, section, key, value and expression_string with input_names/input_values. It lacks detailed type/format specs, but the signatures add significant meaning beyond the generic op/params/session_id 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 opens with a domain summary ('ConfigFile, JSON, and Expression Utilities') and then lists five specific operations, each with a clear verb and resource: read/write INI ConfigFile, parse/generate JSON, and evaluate expressions. This makes the tool's purpose specific and distinguishes it from the many *_manage sibling tools by 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 op list provides clear routing between the five operations: use config_read/config_write for INI, json_parse/json_generate for JSON, and expression_eval for expressions. It does not explicitly state when not to use this tool or compare against siblings, but the internal usage context is strong.

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 behavioral burden. It discloses some side effects, such as optionally saving an RSA key or certificate, and clarifies the canonical call shape with top-level op and session_id. However, it does not explain overwrite behavior, default save paths, permission needs, or what happens when save_path is empty, which leaves meaningful behavioral 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 long but highly structured: a high-level summary, a bullet list of operation signatures with one-line explanations, and a call-shape note. Each entry earns its place, though the repetitive 'generate_*' signatures could arguably be tightened slightly.

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 a tool must dispatch six distinct cryptographic operations, the description covers operation selection, signatures, defaults, and call format. It does not document session_id semantics or return value details, but the presence of an output schema reduces the burden for return-value explanation. Overall, an agent has enough to invoke the tool 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 description coverage is 0%, but the description compensates thoroughly: every operation lists its parameters, defaults, and accepted values (e.g., algorithms 'sha256', 'sha1', 'md5', output formats 'hex' or 'base64'). It also explains how the generic params object maps to specific operation arguments, which goes far beyond the bare input 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 opens with a specific resource class ('Cryptographic Operations, File/String Checksums, Random Tokens, RSA, and X509 Certificates') and then enumerates six concrete operations with distinct verbs. This makes the tool's scope unambiguous and clearly differentiates it from the many other *_manage 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?

The operation list gives clear context for when to use the tool: hashing files/strings, generating random bytes, creating RSA keys, generating certificates, and computing HMACs. It does not explicitly name alternatives or exclusions, but for a tool with no close siblings, the enumerated operations themselves provide adequate usage direction.

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 disclosure burden. It reveals that all write ops are undoable via EditorUndoRedoManager, and that sibling CSG shapes auto-combine—useful behavioral context beyond the basic operation. It could mention error cases, but current disclosures are solid.

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 well-structured with a one-liner summary, a detailed explanatory paragraph, and clearly formatted op bullets. It is slightly longer than necessary but every sentence adds value.

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 description covers operation semantics, parameter details, return values, undo behavior, grouping constraints, and property handling. Given the tool's two-OP scope, this is fully sufficient for an agent to select and invoke 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?

The input schema is generic (op/params/session_id) with 0% coverage of inner parameters. The description fully documents both ops: parameter names, defaults, enums, and return values, providing complete semantic 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 opens with 'CSG authoring' and clearly states it creates boolean shapes and sets their operations. It specifies resource types (box, sphere, cylinder, etc.) and differentiates from sibling tools like node_create by focusing on CSG-specific behavior.

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 explains the use case (carving holes/caves/tunnels in the editor) and gives guidance on grouping with CSGCombiner3D. It also directs users to node_set_property/material_manage for post-creation edits, but does not explicitly state when not to use this tool.

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 behavioral burden. It discloses the canonical call shape and the flat-parameter compatibility alias, plus the create/sample semantics of each operation. However, it does not disclose side effects such as whether save_path persists files, overwrites existing resources, or whether creation requires a project context.

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 long but highly structured: the domain is front-loaded, operations are grouped under 'Ops', and each bullet follows a consistent pattern with signature, defaults, and purpose. The final canonical call shape is valuable and earns its place; there is no filler or repetition of schema-only information.

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 multi-operation tool with seven sub-ops and no schema-level parameter documentation, the description is remarkably complete: every operation is documented with its parameters and intended use. The main gap is that save_path semantics and file-system behavior are left implicit, and return values are not described, though an output schema is indicated.

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 0%, so the description fully compensates by documenting every operation's parameters with defaults and examples, such as points=[[0.0, 0.0], [1.0, 1.0]], in_tangents=[], colors=['#000000', '#ffffff'], and offset=0.5. It also clarifies the top-level params object structure and flat-parameter compatibility alias.

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's domain: curves, splines, gradients, and color ramps, and immediately enumerates concrete operations like create_curve_1d, create_curve_2d, and sample_gradient. It is specific about resources and verbs, though it does not explicitly differentiate itself from sibling management tools such as resource_manage or texture_manage.

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?

Each operation gets a context and intended purpose: create_curve_2d is 'for paths and animation', create_curve_3d is 'for 3D paths and rail movement', and sample_gradient says it samples 'RGBA color'. This provides clear internal selection guidance, but the description does not state when to prefer this tool over a sibling tool or list 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?

With no annotations provided, the description carries the full disclosure burden and does well: it reveals session-only scoping, that params are 'forwarded unvalidated' to the addon handler, batch incompatibility for deferred tools, and the flat-parameter compatibility alias. It stops short of covering error behavior for an unknown tool_name, a minor gap given the dynamic nature of the tools.

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 purpose is front-loaded and every paragraph earns its place (op semantics, batch interaction, alternative routing, call-shape alias). It is dense but not padded; the only minor inefficiency is repeating 'custom' terminology across closely-packed paragraphs that could be slightly tightened.

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 complex, dynamic tool with no annotations and zero schema coverage, the description covers purpose, both operations, parameter shape, batching constraints, alternative first-class registration, and call format. An output schema exists, so return-value omission is excused. It falls just short of perfect only by not describing failure modes for invalid tool names or session handling.

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 0%, so the description must compensate — and it does thoroughly. It explains the meaning of each op enum value, specifies that op='invoke' requires a tool_name string plus an optional params dict whose shape follows the params_schema returned by op='list', and even provides the canonical JSON call shape. This adds far more meaning than the bare 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 first line, 'List or invoke custom tools registered by third-party addons,' pairs specific verbs (list/invoke) with a specific resource (custom tools from third-party addons), unambiguously distinguishing it from the many sibling *_manage tools. The purpose is concrete and immediately usable.

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 explicit routing guidance: state when to use it, and name the alternative — 'Some custom tools are also registered first-class as custom_<name> with their own schema — prefer those when present.' It also sets preconditions ('Active session only') and constraints for the sibling batch_execute (deferred tools cannot run in batches).

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 carry the behavioral burden. It does disclose substantial behavior (autoload registration, generated UI features, event signals, and overwrite=False), but it never explicitly warns that scaffold_system writes/overwrites project files or modifies project settings, nor does it explain failure/error behavior. This leaves a meaningful transparency gap for a potentially destructive scaffolding 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 organized with a short header and two bullet-style operation signatures, making the two dispatch modes easy to scan. The final canonical-call-shape note is useful but adds length; overall it is appropriately sized and front-loaded, though slightly feature-list-heavy.

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 a multi-operation dispatcher with an opaque params schema and no annotations, the description covers the main operations and call shape well. However, it omits per-operation requirements/validation, the expected structure of nodes, and explicit side-effect warnings, so an agent may still need to infer important details before invoking it 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?

Input schema coverage is 0% and params is only a generic object, so the description is the only place parameter meaning lives. It provides per-op signatures with defaults and describes the entities involved (e.g., script_path, scene_path, register_autoload, typewriter_speed, nodes, overwrite). It does not fully specify the nodes object structure or the optional session_id field, but it compensates well for the schema's emptiness.

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 clear purpose ('Dialogue and Narrative System Management') and enumerates two concrete operations: scaffolding a complete dialogue manager/UI box and creating a branching dialogue graph. These specifics distinguish it from sibling management tools and give an agent a reliable sense of the resource and actions involved.

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 operation-level descriptions imply when the tool is appropriate: scaffold_system for setting up a new dialogue manager UI/singleton, and create_dialogue for authoring a branching dialogue graph. However, there is no explicit guidance about prerequisites, exclusions, or when to prefer alternative sibling tools such as script_manage or node_manage.

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 disclosing behavior. It does state what each operation reads or modifies, including allowed values and defaults (e.g. set_mode window modes, VSync modes, mouse modes). It does not disclose side effects, reversibility, permissions, or platform constraints for these mutating display/window operations, which is a notable gap for an unannotated configuration 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?

The description is well structured: a brief header, a compact bulleted op list with signatures and defaults, and a short canonical-call note. Every line is informative and earns its place; there is no filler or redundant restatement of the tool name.

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 multi-operation tool with an output schema and minimal input schema coverage, the description is largely complete: it covers all six operations, their parameters, and the expected call envelope. It does not explain error conditions or clarify relationships to sibling tools, but the provided output schema removes the need to describe return values in detail.

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 gives almost no parameter semantics: params is a free-form object with 0% schema coverage. The description fully compensates by documenting every operation's sub-parameters, defaults, and accepted enum values, along with the canonical call shape. This is exactly the kind of semantic detail the schema is missing.

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 opens with a clear resource scope ('DisplayServer Configuration, Window Controls, and SubWindow Scaffolding') and enumerates six concrete operations, making the tool's purpose unmistakable. It is less explicit about how it differs from closely related siblings like viewport_manage or rendering_manage, so it loses one point.

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?

Usage guidance is implied through the op list: an agent can infer that window/display configuration goes here and subwindow scaffolding also goes here. However, there is no explicit statement of when to choose this over alternatives, nor any exclusions or 'use X instead' guidance, leaving some routing decisions to inference.

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 and excels. It discloses side effects (quit() 'Gracefully quit the Godot editor on next frame'), permission implications (eval 'Execute arbitrary GDScript directly... with full permissions'), and error semantics for game_eval (detailed EVAL_* codes with conditions). The canonical call shape is also explained. This is exemplary transparency.

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 long but well-organized: a summary line, a resource-forms note, then a bulleted list of ops with precise details. It is front-loaded with the summary and each line serves a purpose. Slight redundancy in the canonical call shape could be trimmed, but overall structure is effective.

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 complex tool with nine operations, the description covers everything an agent needs: parameter formats, return values (e.g., logs_clear returns cleared_count), error codes with actionable resolutions, and the call shape. It also notes output schema exists, so return structure is not missing. No gaps are apparent for correct usage.

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 only provides op as an enum and params as a free-form object, with 0% schema description coverage. The description compensates fully by explaining each operation's parameters (e.g., monitors_get with optional list, logs_clear with clear_debugger_errors, eval with code/mode/inputs). This adds meaning far beyond the schema, making it essential for correct invocation.

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 opens with a concise summary of the tool's scope: 'Editor selection, performance monitors, quit, log clearing, game eval.' It then enumerates specific operations, making it clear that this is a multi-purpose editor management tool. It does not present a single verb+resource, but the list of ops is unambiguous and differentiates from sibling tools like editor_state and logs_read by covering a broader set of editor actions.

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 internal guidance: it suggests preferring resource forms (godot://editor/state, etc.) for active-session reads, and explains when to use the opt-in flag for logs_clear. However, it does not explicitly contrast editor_manage with sibling tools or state conditions for choosing this tool over others. It gives usage context for specific ops but not cross-tool comparisons.

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 fully carries the behavioral disclosure burden. It openly states that a plugin-managed reload kills the server, drops the WebSocket transport, requires reconnect and session lookup, can time out after 90 seconds, and returns recovery diagnostics.

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 longer than average but earns its length: it is front-loaded with a one-line purpose and then organized into clear bulleted modes. Every sentence conveys necessary operational detail, and the structure makes conditional behavior easy to parse.

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 high complexity and the absence of annotations, the description is remarkably complete: it covers both execution contexts, response shapes, timeout behavior, error semantics, and recovery steps. Nothing meaningful is missing for an agent to call and handle the result 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?

The single parameter session_id is already 100% covered by the schema, including its default and empty-means-active semantics. The description adds no additional parameter detail, but none is needed because the schema fully documents the 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?

States a specific verb and resource ('Reload the Godot editor plugin') and immediately defines the concrete behavior: disables and re-enables the plugin on the next frame. The two-mode breakdown further differentiates this from sibling maintenance 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?

Provides very clear execution context by explaining both launch modes and the expected response in each, which effectively tells an agent when this tool is appropriate. It does not explicitly name alternatives or exclusions, but the modal detail makes selection unambiguous.

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 burden and excels: it documents error shapes (EDITOR_NOT_READY, NODE_NOT_FOUND, GAME_HELPER_TIMEOUT), the stale_frame note for backgrounded games, camera selection fallback for cinematic, and return behaviors like include_image and AABB metadata.

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 structured with a lead sentence, a guidance paragraph, a bulleted source list, and a closing note on parameters. Each section earns its place; the length is justified by the tool's four modes and ten parameters.

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, the description explains what callers receive (MCP ImageContent, AABB metadata, error data) and covers edge cases (no scene, no 3D content, no Camera3D, game not running, backgrounded game). It is fully actionable.

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?

Even though schema coverage is 100%, the description adds significant meaning: it explains that view_target takes comma-separated Node3D paths and reframes the editor camera, that coverage=True captures perspective + orthographic top-down references alongside AABB, and clarifies the behavior of include_image and default source.

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 opens with a specific verb+resource: 'Capture a screenshot of the Godot editor viewport or running game.' It clearly delineates four sources and is distinct from any sibling tool, so 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?

It provides explicit source-selection guidance: default 'viewport' requires Node3D content, 'viewport_2d' for 2D scenes, 'cinematic' requires a Camera3D, and 'game' requires a running project. It also gives exclusionary constraints, e.g., 'viewport_2d' is 'Not compatible with view_target/coverage/elevation/azimuth/fov.' and advises switching to 'cinematic' under specific conditions.

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 explains what each operation does (e.g., 'Set an editor setting value'), but does not mention side effects, persistence, permissions, or error behavior. It does note the canonical call shape and compatibility alias, which is a minor behavioral detail, but overall it provides minimal transparency beyond the basic 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 description is structured as a compact list of operations with one-line explanations, front-loaded with a clear purpose. It also includes the canonical call shape in a single sentence, keeping the whole description terse and scannable.

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 description covers all operations, their parameters, and the call format, which is sufficient for a multi-op tool. It omits explicit usage guidelines, but the operations are self-explanatory, and an output schema exists to define returns. Thus it's mostly 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 description explicitly names and defines parameters for each operation (e.g., 'get_setting(setting_name)', 'set_setting(setting_name, value)', 'list_settings(prefix="")'), which directly compensates for the schema's generic 'params' field. Since schema coverage is 0%, this descriptive detail is essential and well-provided.

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's purpose as 'Editor Settings and Configuration Management' and then enumerates four specific operations (get_setting, set_setting, list_settings, get_editor_paths), each with a clear verb and resource. This specificity distinguishes it from the many sibling *_manage tools, 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?

The description does not provide explicit guidance on when to use this tool versus other configuration or editor management tools. It implies usage through the listed operations, but lacks any conditional or alternative references, so an agent may not know if it should use this or a similar tool like config_manage.

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 fully discloses the side effect (refreshes session readiness cache), the non-mutating nature of the call, and nuanced field semantics like game_status.status='break' requiring a follow-up project_manage(op='stop'). No annotation contradictions.

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 long but extremely dense; every paragraph adds necessary operational details (resource form, adapter call conventions, side effect, field semantics). It is front-loaded with purpose and structured logically, though slightly longer than the minimum needed.

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?

Even with an output schema present, the description provides essential context the schema cannot: the resource form preference, cache-refresh side effect, adapter calling quirks, and the special 'break' state handling. Nothing an agent needs to call this correctly is missing.

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 the only parameter, session_id, is already well-documented in the schema ('Optional Godot session to target. Empty = active session.'). The description does not add further parameter guidance, but the schema fully covers it, so 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 opening line states the verb ('Get'), the resource ('current Godot editor state'), and the key fields (version, readiness, open scene, play state). It clearly distinguishes from siblings like project_manage and scene_open by referencing the dedicated current-scene resource for that need.

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 explicitly says to prefer the resource form for active-session reads, names readResource('godot-ai', 'godot://scene/current') as the alternative for scene-only data, and gives a concrete recovery use case after EDITOR_NOT_READY. It also includes a 'never' instruction for server-prefixed tool names, so the agent knows exactly when and how to call this.

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 burden of disclosing behavior. It does disclose headless CLI execution and a debug flag, which is useful. However, it does not state whether run_export overwrites files, what artifacts it produces, what preconditions exist, or what failure modes look like.

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 bulleted operations are scannable, defaults are inline, and the call-shape note is a single focused paragraph. Every line adds useful information without 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 three-operation tool with an output schema, the description covers every operation's parameters and invocation format. The main gaps are usage routing relative to siblings and run_export side effects, but the core calling contract is complete enough for an agent to invoke the tool 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?

The input schema only exposes op, params, and session_id, with params as a free-form object. The description defines the exact per-operation signatures with defaults, including preset_name, output_path, and debug, and clarifies the canonical call shape plus the flat-parameter compatibility alias. This fully compensates for the 0% schema description 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 opening line names the domain, and each listed operation uses a specific verb and resource: list_presets lists export targets, get_preset_info inspects preset settings, and run_export executes a headless Godot export. References to export_presets.cfg and the Godot CLI make it clearly distinguishable from broad sibling tools like project_manage.

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 or when-not-to-use guidance, and no mention of alternative tools among the dozens of siblings such as project_run, project_manage, or pck_manage. The operations imply their own purpose, but the description does not help an agent choose this tool versus a sibling.

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 responsibility for behavior disclosure. It is exceptionally transparent: it details side effects (write_text adds data.cleanup.rm for new files), scope of updates (single-file vs full scan), return structures, and caveats (reimport on non-imported resources does not prove parsing). It even explains the headless scan behavior and single-flight semantics. No behavioral traits are hidden.

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?

Although the description is long, it is well-structured: an opening summary, a bulleted list of operations with consistent formatting, and a closing note on call shape. Each sentence carries essential information—no filler. The information is front-loaded with the purpose, and the detailed operation blocks are logically ordered. The length is justified by the tool's multi-op nature.

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 description is complete for a complex multi-op tool. It covers every operation's parameters, return values, side effects, and edge cases. It even addresses when a full scan is needed versus single-file updates, and how to interpret results (e.g., skipped_non_imported). Given that an output schema exists but the description provides per-op return details, nothing an agent needs to call it correctly is missing.

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 schema coverage is 0% (no descriptions in schema), so the description must compensate. It does so comprehensively: each operation lists its parameters with types, defaults, and meaning (e.g., read_text(path), write_text(path, content=''), reimport(paths), list(path, recursive, max_depth)). It also describes the canonical call shape and accepts aliases. This fully bridges the gap left by 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 clearly states the tool's purpose: 'Project filesystem access via the Godot editor's EditorFileSystem.' It lists specific operations (read, write, reimport, list, delete, move, scan, search, download, etc.) with a clear verb+resource structure. It distinguishes itself from sibling tools by focusing on the filesystem layer, and it names alternatives within the tool (e.g., script_patch/script_create for diagnostics).

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 explicit guidance on when to use each operation and when to prefer alternatives. For example, reimport notes that non-imported resources are skipped and recommends script_patch/script_create for scripts, and scan for assets awaiting first import. It also explains when a full scan is necessary (after adding class_name scripts) versus single-file updates. This internal guidance helps agents choose correctly without external references.

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 does describe core behaviors: create operations, 'optionally save to disk', derivation from a base font, and inspect-only behavior for get_font_info. However, it does not disclose editor-session side effects, persistence rules beyond save_path, overwrite behavior, error conditions, or what happens to resources not saved to disk.

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 scannable bullet list with no filler; each line presents an operation and its signature or a needed call-shape detail. The note about canonical call shape and flat-parameter compatibility is useful rather than redundant. The structure allows an agent to quickly locate the relevant operation.

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 generic input schema and lack of annotations, the description supplies the essential operation catalog, parameter signatures, and invocation shape, and an output schema exists to document return values. The main gaps are the absence of tool-selection guidance against sibling tools and deeper behavioral caveats. An agent can still correctly select and invoke the documented operations, so this is above minimum viability 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?

Schema description coverage is 0% and the params object is generic free-form, so the description is the main source of parameter meaning. It provides full call signatures with defaults for every operation, conveying parameter names, optionality, and basic types. It stops short of explaining value domains such as weight ranges, variation_embolden scale, hex color format, or save_path behavior, so it is not a fully comprehensive reference.

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 opens with a clear domain statement and then enumerates four concrete operations, each with a specific verb and resource: 'Create a SystemFont resource', 'Create a FontVariation resource', 'Create a LabelSettings resource', and 'Inspect metadata and properties'. This makes it clear that font_manage handles font/label resource creation and inspection, distinguishing it from the many other *_manage 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?

The title and operation list imply when the tool is relevant: creating or inspecting font and label styling resources. However, the description never explicitly tells the agent when to prefer font_manage over related tools like theme_manage, ui_manage, or resource_manage, and it gives no exclusions or alternative routing. This is clear implied usage, but not explicit guidance.

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 burden of behavioral disclosure. It does disclose that files are scaffolded and that nodes are attached when target_node_path is set, which is meaningful. However, it does not mention side effects like potential file overwrites, directory creation, or whether an active scene is required, leaving important behavioral context unclear.

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 well-organized with a clear op listing, preset breakdown, and a canonical call shape note. It is compact and front-loaded with purpose, though the call-shape paragraph adds a bit of protocol detail that could be trimmed.

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 presence of an output schema reduces the need to explain return values, and the description covers the main scaffold behavior and presets. Still, initial_state is left unexplained, side effects are not fully disclosed, and there is no guidance about preconditions such as having an active scene or project context.

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 provides only a generic params object with 0% description coverage, so the description must compensate. It documents target_node_path, name, script_dir, preset, custom_states, and initial_state, and explains preset behavior and the effect of target_node_path. It still omits the meaning of initial_state, but it adds substantial 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 clearly states a specific verb ('scaffold') and resource ('modular node-based finite state machine architecture'), and names concrete presets and outcomes. It does not explicitly contrast itself with sibling management tools, but the domain is unambiguous from the name and content.

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 by describing FSM scaffolding, but it gives no explicit guidance about when to choose this tool over alternatives, nor does it state prerequisites or exclusions. The conditional behavior about target_node_path is useful but is not usage guidance relative to sibling 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?

With no annotations, the description carries the full burden and delivers richly: resume is declared idempotent, next_frame advances exactly one tick with verification and embed_signal/direct_session response semantics, input_mouse rejects malformed positions instead of silently falling back, input_sequence is frame-timed with non-decreasing at_frame ordering and focus-independent action input, and simulate_input has automatic clean release. This is exemplary behavioral disclosure of side effects, timing, failure modes, and environmental dependencies.

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 long (~600 words) but earns its length for 14 operations, with each op presented as a compact signature plus only semantically important notes. Purpose is front-loaded and the prerequisite placement is logical. Two minor structural flaws: the canonical call shape — needed for every invocation — is buried at the end, and the ops block is dense enough to tax a quick 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?

Given no annotations and an open params object, the description covers prerequisites, per-op semantics, timing rules, environment constraints (batch_execute, embedding fallback, backgrounded-window support), and failure behaviors for all documented ops — essentially a full API manual. The material gap is the three undocumented enum ops, which an agent would discover from the schema but could not invoke correctly, and the absence of any mention of how playtest/simulate relate to the documented ops or siblings.

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 0% and params is an open object (additionalProperties: true), so the description is the only parameter documentation. It comprehensively details signatures and semantics for 14 ops: root_path path types, position as {x,y} or [x,y], control enum values, the input_sequence step schema with frame-based timing, and input_state's empty=all-actions rule. The gap: playtest, run_playtest_suite, and simulate appear in the op enum but have zero parameter documentation anywhere.

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 title 'Runtime game inspection and input simulation' plus the opening line names a specific target resource (the running game process via Godot's EngineDebugger bridge) and a clear verb set (inspect, simulate). This distills cleanly against siblings: scene_manage/node_manage handle static scene/node editing, project_run launches the game, and input_map_manage configures mappings — none cover runtime inspection and input simulation.

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?

Explicit prerequisites are given ('Start the project first with project_run and poll editor_state until game_capture_ready=true'), and input_sequence gets an explicit when-to-use vs. input_action plus a when-not ('Cannot run inside batch_execute'). However, three ops in the op enum (playtest, run_playtest_suite, simulate) are undocumented, so an agent gets no guidance on when to choose them over the documented simulate_input or the sibling test_run.

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 disclosure burden. It does reveal important side effects: scaffold_polygon_2d 'Instantiate and attach' to the active scene and generate_mesh 'attach to scene or save.' However, it does not mention whether the pure geometry ops (boolean, offset, triangulate, hull) have side effects, nor does it discuss permissions, reversibility, or failure modes. The compatibility-alias note is useful.

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 longer than average, but it is efficiently structured: a one-line summary followed by a compact op list with call signatures. Every line contributes. The canonical call shape note is important and not padding. It could be slightly tightened, but it earns its 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?

For a tool with six operations and no annotations, the description covers all operation signatures, defaults, and key side effects. It does not explain prerequisites like requiring an active scene for scaffold/generate_mesh, and return values are not mentioned (though an output schema exists). Still, it is largely complete for an agent to invoke 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 description coverage is 0%, so the description must compensate. It does thoroughly: each op lists its parameters with defaults and expected inputs, e.g., polygon_boolean(operation='merge', poly_a=[...], poly_b=[...]), polygon_offset(polygon, delta, join_type), scaffold_polygon_2d(parent_path, points, polygon_name, is_collision, color). This is exactly the meaning the generic 'params' object in the schema lacks.

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 opens with a clear domain statement ('Constructive 2D Solid Geometry and Procedural 3D Mesh Generation') and then enumerates six specific operations with verbs like polygon_boolean, triangulate, and generate_mesh. This makes the tool's purpose and scope evident, and it distinguishes itself from sibling tools such as mesh_manage by focusing on geometry construction/procedural generation rather than asset management.

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 through the operation list and the canonical call shape, but it never explicitly states when to choose geometry_manage over alternatives, nor does it mention exclusions or when-not conditions. It provides call formatting guidance but not situational routing.

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 bears full responsibility for disclosing side effects, preconditions, and return behavior. It only gives terse one-line summaries like 'Create a Decal node' and 'Inspect properties', without mentioning requirements (e.g., an active scene), destructive potential, error handling, or what the output schema contains. This is insufficient for a mutation-heavy 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?

The description is well-structured with a clear top-level purpose, bulleted operations, and a concise canonical call shape note. Each operation is one line plus a brief summary, avoiding fluff. The front-loaded purpose and operation list make it easy to scan. It earns high marks for efficiency, though the parameter lists add bulk.

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 (six ops, many parameters, no annotations, and an output schema not described), the description is not complete. It lacks return value details, error handling, preconditions, and example calls. While it covers the basic purpose of each op, an agent would need to inspect the output schema or experiment to understand behavior fully.

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 0%, so the description must compensate. It lists parameters in the op signatures and gives partial explanations (e.g., create_decal's 'optional albedo texture and dimensions' hints at texture_albedo and size). However, many parameters like subdivide, update_mode, and bounces are not explained, and configure_decal's long parameter list lacks individual descriptions. The op-level summaries add some value but are not exhaustive.

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's domain ('Global Illumination, Decal Projections, and Lighting Probes Management') and enumerates each operation with a specific verb+resource pair (e.g., 'create_decal', 'configure_decal'). This distinguishes it from the many sibling *manage tools, which target different subsystems.

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 lists operations but provides no explicit guidance on when to choose this tool over alternatives. While the domain is self-evident, there is no mention of when not to use it or which sibling tool might be more appropriate for related tasks (e.g., light_manage for general lights). Usage is implied by the operation names but not explicitly scoped.

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 behavioral disclosure. It reveals that write operations are undoable via EditorUndoRedoManager, explains item=-1 erase semantics and orientation range 0..24, and specifies return structures for every operation. This is exemplary transparency.

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 well-structured with a summary, a 'Ops:' bulleted list, and a closing canonical call-shape note. Each sentence adds value, and the bullet format makes complex multi-operation details 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 description covers all five sub-operations with parameters and returns, the call shape, scene targeting, and undo behavior. Given the tool's complexity and lack of annotations, this is fully complete for agent 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 0%, but the description fully compensates by documenting every operation's parameters (path, item, map coordinates, rect dimensions, orientation) and giving semantic details like valid item discovery and orientation index meaning. It adds far more meaning than the sparse 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 opens with 'GridMap authoring (set items, fill 3D regions, clear, read cells + library items)', naming specific verbs and a concrete resource (GridMap nodes). It distinguishes itself from sibling 2D tile/tileset tools by explicitly focusing on 3D GridMap 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 clearly states that all operations target GridMap nodes in the currently edited scene by scene-relative path, and it recommends using gridmap_list_library_items before placing cells. It doesn't explicitly exclude alternative tools, but the '3D analogue of tileset atlas inspection' note gives contextual differentiation from sibling 2D 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?

Annotations are absent, so the description must carry the full burden. Each operation's one-liner implies some behavior: export_project_cli 'Triggers a headless project export'; reimport_assets_cli 'Reimport modified assets' – these hint at write effects. However, there is no disclosure of side effects, prerequisites (e.g., Godot executable, project config), or potential errors. The description is behaviorally informative but not comprehensive for a multi-action 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?

The description is well-structured: a summary line, a bulleted list of operations with parameters and one-line purposes, and a note on call format. It is front-loaded with the core purpose and uses whitespace effectively. Every sentence adds value; there is no redundancy or fluff. Slightly long due to the five ops, but each 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?

Given the tool's complexity (five distinct operations) and the presence of an output schema (not shown here), the description covers the 'what' but not the 'how' in depth. It omits important context like error handling, session requirements, and whether operations modify the project (export and reimport are implied writes). The lack of explicit usage guidance and behavioral detail leaves an agent needing to infer too much.

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 schema has zero descriptions for properties (op, params, session_id). The description compensates by listing each operation's parameters with defaults (e.g., run_script(script_path="", inline_code="")), and the operation text gives some semantic meaning (e.g., 'Execute a GDScript file or inline code snippet'). However, not all parameters are explained – is_debug is never defined, and the generic 'params' container is left opaque. This partial coverage earns a 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 clearly states the tool's purpose: 'Standalone Headless Engine & CLI Management.' It enumerates five distinct operations with specific verbs (run, export, reimport, inspect), each with a resource and intent. This distinguishes it from sibling tools like export_manage or editor_manage, which focus on different scopes. The title alone would be ambiguous, but the bullet list removes doubt.

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. It never mentions scenarios where a different tool would be more appropriate (e.g., for non-headless operations) or any exclusions. It simply lists operations without routing the agent to siblings. Given the large sibling set, this is a significant gap.

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 and does substantial work: it discloses that send_request executes via Godot's networking stack, download_file writes into res:// or user://, and scaffold_http_request inserts a node into the scene hierarchy. It stops short of discussing side effects like overwriting files or network error behavior, but it gives meaningful behavioral context 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 tightly organized: a one-line purpose summary, three bullet-pointed ops with signatures, and a brief note on call shape. Every sentence earns its place, and the structure makes op variants scannable without extraneous prose.

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 multi-op tool with an output schema present, the description covers operation behavior and parameter lists, and the output schema can handle return-value details. The remaining gap is per-parameter format documentation, which is partly addressed in parameter semantics. Overall, an agent has enough to invoke all three ops correctly in most 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 coverage is 0% and the params property is a free-form object, so the description is the only parameter source. It provides each op's signature with names and defaults (e.g., method='GET', timeout=10.0), which adds some meaning, but it does not define formats for headers, body, or valid method values. This partially compensates for the schema gap but not completely.

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 the resource and verbs explicitly: 'In-Engine HTTP Requests, File Downloads, and HTTPRequest Scaffolding' and then enumerates three distinct operations with signatures. This clearly differentiates the tool from broad siblings like network_manage or api_manage by scoping it to Godot's in-engine networking stack and project filesystem.

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 lists concrete operations and a canonical call shape, so an agent can infer when to use this tool (e.g., when it needs an HTTP request, file download, or HTTPRequest node scaffold). However, it provides no explicit guidance on when to prefer this tool over siblings such as network_manage or api_manage, nor any when-not-to-use conditions.

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. It lists operations and parameters but does not disclose side effects (e.g., whether simulated inputs permanently affect game state), permissions required, reversibility, or rate limits. It mentions 'in the running game or editor' for one op but omits broader behavioral traits like whether actions are destructive or require a paused 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 well-structured with a summary line followed by a bullet-like list of operations and their parameters. It is slightly long but each line adds necessary information because the schema is generic. The canonical call shape is included, which aids parsing. It is efficient for the complexity covered.

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 multiple operations and the schema provides no parameter details, the description is quite complete: it covers all ops, their parameters, and the call format. However, it does not describe return values for operations like get_input_state beyond implying inspection, nor does it mention error conditions. For a tool of this complexity, it is fairly complete but not exhaustive.

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 is generic (only 'op' and 'params'), covering 0% of the actual parameters. The description compensates fully by documenting each op's parameters in detail (e.g., action, pressed, strength; key, echo, shift; button_index, position; etc.). This provides meaning that the schema lacks, making it easy for an agent to construct correct calls.

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 it is for 'Input Event Simulation, Macro Replay, and Virtual Actions' and then enumerates specific operations like simulate_action, simulate_key, replay_macro, etc. This distinguishes it from siblings like input_map_manage (which is about configuring input mappings) by focusing on runtime simulation and inspection.

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 (simulate input events in a running game/editor) but does not explicitly state when to use this tool versus alternatives, nor does it give exclusion criteria. For instance, it doesn't mention that input_map_manage should be used for defining mappings rather than simulating. The usage context is clear but not formally contrasted with 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well: it explains persistence, idempotency, error conditions (out-of-range deadzone rejected with VALUE_OUT_OF_RANGE), and the distinction between live InputMap and project.godot state. It also clarifies that deadzone is not a key-repeat delay. However, it doesn't mention the output format of list or what happens on failures beyond the error code, which would be expected for a tool with this many operations.

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 lengthy but well-organized with a clear introduction, bullet-pointed operations, and a canonical call shape. It front-loads the most important information (resource form preference) and each operation is concise yet complete. However, it could be slightly trimmed in places, but the length is justified given the tool's complexity and the lack of schema parameter documentation.

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 (7 operations, 3 parameters, output schema present), the description is quite complete. It covers when to use, how to use, and what to expect, including edge cases like persisted-but-not-loaded actions. The output schema provides return formats, so the description doesn't need to repeat that. The only minor gap is the lack of error handling for other operations besides deadzone, but that doesn't prevent correct usage.

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 0% for the params object (it's just a generic anyOf), so the description must fully compensate. It does: for each operation, every parameter is explained with types, allowed values, and examples. For bind_event, it details event_type, keycode (as Godot keycode name strings), button indices, axis values, and modifier booleans. This is far beyond what the schema provides and is essential for correct invocation.

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 starts with a clear statement of the tool's function: managing input actions and bindings (keyboard, mouse, gamepad) with persistence to project.godot. It then breaks down each operation with specific verbs (list, add_action, etc.) and details that distinguish it from generic manage tools. This clearly differentiates it from siblings like input_event_manage and ui_manage, which likely handle different aspects of 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 provides explicit guidance on when to use the resource form over the file form, and for each operation includes prerequisites (e.g., 'action must already exist' for bind_event) and idempotency notes (ensure_action, ensure_binding). It also mentions that list by default excludes built-in actions, guiding when to set include_builtin=True. This is comprehensive and leaves little to inference.

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 full burden of behavioral disclosure. It explains the canonical call shape and op handling, but does not disclose side effects (e.g., whether scaffolding modifies the scene graph), error conditions, required permissions, or reversibility of operations. The get_joint_info operation is read-only but never stated, and configure_joint implies mutation without elaboration.

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 well-structured with a clear header and bullet-like list of operations, each with parameters and purpose. It front-loads the domain and call shape. While it is somewhat long, every sentence serves a purpose—detailing ops, defaults, and the call convention—without 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?

The description covers all four operations, parameter syntax, and the call shape (including flat-parameter alias). It does not explain return values or error handling, but an output schema exists, which likely covers return structure. Missing details like prerequisites (e.g., need for an open scene) are not mentioned, but overall the description is sufficiently complete for an agent to invoke the tool 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?

The description provides exhaustive parameter details for each op, including names, defaults, and allowed joint types (pin, hinge, slider, etc.). This goes far beyond the generic input schema, which only defines op, params, and session_id with 0% coverage of inner parameters. The description fully compensates for the schema's lack of detail.

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 explicitly states 'Physics Joints Management (2D and 3D)' and enumerates four concrete operations (scaffold_joint_2d, scaffold_joint_3d, configure_joint, get_joint_info), each with a specific verb and resource. This clearly distinguishes it from sibling tools like physics_manage or body_manage, which manage other aspects of physics.

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 by listing joint-specific operations, but it does not explicitly state when to choose this tool over alternatives like physics_manage or node_manage. It lacks any 'when not to use' or cross-referencing to sibling tools, leaving the agent to infer the domain from the title and operation names.

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 bears full responsibility for behavioral disclosure. It mentions operations like 'Scaffold' and 'Update' but does not detail side effects, permission requirements, or whether operations are destructive or reversible. The canonical call shape and compatibility alias are mentioned, but the broader behavioral profile (e.g., impact on scene, potential overwriting) is absent.

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 structured with a clear header and a bulleted list of ops, each with a one-line signature and brief comment. It front-loads the overall purpose and uses consistent formatting. While long, it is dense with useful information and avoids fluff, though the canonical call shape note could be considered slightly redundant given 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?

Given the tool's complexity (six distinct operations) and the generic schema, the description provides sufficient context for an agent to construct calls. It includes the canonical call shape and per-op parameter details. The output schema exists (though not shown), which may cover return values, so the description's lack of return-value explanation is acceptable. It covers operation semantics adequately, though it could add examples of valid parameter values.

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 schema provides only a generic 'op' enum and a 'params' object with no property definitions (0% schema coverage). The description compensates thoroughly by listing every operation with its parameters, defaults, and types, such as scaffold_light_3d(type, parent_path, name, color, energy, shadows, range, attenuation, spot_angle). This gives agents complete understanding of how to construct parameters 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 clearly identifies the tool's domain: '2D and 3D Lighting, Shadow Tuning, Decal Projection, and Reflection/GI Probes.' It enumerates specific operations with detailed signatures, making the purpose unambiguous and distinguishing it from sibling tools that handle other domains like mesh, animation, or physics.

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 does not explicitly state when to use this tool versus alternatives or when not to use it. The domain is clear, but there is no guidance on selection criteria among the many sibling tools. It implies usage through the listed ops, but lacks exclusions or alternative routing.

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—and it delivers: it discloses asynchronous/threaded/background execution, the canonical call shape ('Canonical call shape: {"op": ..., "params": ...}'), the flat-alias compatibility behavior, and status/progress ranges (0.0-1.0, in_progress/loaded/failed). The only gaps are error-handling behavior on failure and side effects, but the described invocation contract is substantial.

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?

Well-structured: a one-line purpose summary front-loads intent, then a tight bulleted op list earns its space because the schema is opaque and needs the per-op parameter documentation. The canonical-call-shape line adds genuine invocation value. Slightly verbose for four ops, but every sentence pulls its weight given the opaque 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 multi-op tool with an opaque params schema, zero annotations, and an output schema that the agent must interpret, this description is nearly complete: it covers all ops, their parameters/defaults, the call envelope, and status result values. Minor omissions—failure semantics and routing vs. sibling tools—keep it from a 5, but it's strong given the tool's complexity.

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 0% and the schema's params field is a generic anyOf object with additionalProperties true, so it documents nothing. The description fully compensates by documenting every op's parameters with names, types, defaults (e.g., start_load(path, type_hint="", use_sub_threads=false, cache_mode=1)) and per-op signatures. This is where the description adds the most value, beyond what any structured field 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 very first line names a specific purpose: 'Asynchronous Threaded Resource Loading, Progress Polling, and Loading Screen Scaffolding.' The four ops are each given a verb + resource + documented parameters (start_load, get_status, get_resource, scaffold_loading_screen), leaving no ambiguity about what the tool does or how it separates from the broader *_manage family.

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 op list makes the tool's jobs clear (async load, poll progress, retrieve results, scaffold a loading screen), so usage is implied well. However, with ~90 siblings including resource_manage, scene_manage, and filesystem_manage, the description never states when this tool is preferred over alternatives or when NOT to use it (e.g., sync loading, direct resource access). The guidance is implied, not explicit.

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 supplied, so the description carries full responsibility for behavioral disclosure. It does state what each operation does (e.g., generates a CSV, adds a row, queries locales) and mentions the canonical call shape and a compatibility alias, which is useful. However, it omits side effects like file system changes, reversibility, prerequisites (e.g., whether a project must be open), or error behavior, so transparency is only partial.

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 long but well-structured: it starts with the overall purpose, then breaks down each operation into bullets with signatures and examples. It front-loads the key information and avoids redundancy. While it could be shortened by removing examples, they add value for agent comprehension, so a 4 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?

Given the tool's complexity (multiple operations) and a minimal schema (only op and params), the description provides all necessary details to invoke each operation correctly. It covers each op's parameters, defaults, and the overall call shape. Since an output schema exists, the description is not required to explain return values, so the tool is effectively complete for an agent to use.

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 0%, so the description must fully compensate. It does so by listing every operation's parameters with types and defaults (e.g., path, languages, key, translations, locale, message, context, root_dir) and even shows example calls. This goes well beyond the bare schema and leaves no ambiguity about parameter 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 clearly identifies the tool as managing Godot TranslationServer localization and CSV translation workflows, then enumerates six distinct operations (scaffold_csv, add_entry, get_locales, set_locale, translate, extract_strings) each with a specific verb and resource. An agent can immediately understand what the tool does and differentiate between its operations 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 provides no guidance on when to use this tool versus alternatives. It does not mention any sibling tools, nor does it state conditions for when this tool should be preferred or avoided. The usage context is implied by the operations themselves but not explicitly compared against other management 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?

With no annotations provided, the description carries the full burden, and it delivers extensively: buffer sizes (500/2000), retention across runs, boot-time parse errors never included, editor_errors_count/hint semantics, filtering rules, addons dropped, cursor superseding offset, and truncation behavior. This is exemplary behavioral disclosure.

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 long, but every block earns its place given the tool's complexity and the absence of annotations. It is front-loaded with a one-sentence purpose, then structured into source categories and tail-pattern guidance. It is dense rather than padded, though slightly longer than strictly necessary.

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 description covers return-field semantics (run_id, current_run_id, stale_run_id, dropped_count, editor_errors_hint), source-specific entry shapes, cursor/run lifecycle, edge cases like lost scripts, and polling patterns. Combined with the existing output schema, an agent has everything needed to invoke and interpret results 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?

Although the schema covers all 7 parameters (100%), the description adds substantial meaning beyond the schema: since_cursor supersedes offset, since_run_id reads retained prior runs, include_details returns Errors-tab metadata, and source determines entry shape. It transforms the parameters into a coherent replay/pagination model.

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 opens with a specific verb and resource: 'Read recent log lines from the Godot editor, plugin, or running game.' It then enumerates the exact source modes (plugin/game/editor/all) and the resource form, making the tool's scope unambiguous and clearly distinct from the unrelated 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?

The description gives explicit when-to-use guidance, e.g., 'Use when the editor Output or Debugger Errors panel shows red/yellow rows but other sources turned up nothing.' It also explains the default source, when to use since_run_id versus since_cursor, and how to poll game logs with offset and run_id. This is far beyond minimal guidance.

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 fully carries the transparency burden, and it does so excellently. Each op lists its side effects: save to disk, assign to node, inline material creation, error when file exists unless overwrite=True, and one undo action for apply_to_node. The compatibility alias for flat parameters is also 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 long but extremely well-structured: it opens with the tool's scope, then uses bullet-pointed op signatures, and closes with a note on call shape. Every sentence carries necessary information for a multi-op tool, though a couple of lines could be tightened without losing value.

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 (eight operations, many parameter combinations) and the generic schema, the description leaves no critical gaps. It covers all ops, their parameters, error semantics, resource-form usage, and edge cases. Since an output schema exists, the lack of return-value descriptions is appropriate.

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 only exposes op, params, and session_id with 0% coverage of actual parameters. The description compensates comprehensively by providing full pseudo-signatures for every operation, including defaults, enum values, and domain-specific rules like texture properties accepting res:// paths and enum-valued params accepting names.

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 a material authoring and management tool, listing specific material types (StandardMaterial3D, ORMMaterial3D, ShaderMaterial, CanvasItemMaterial) and eight concrete operations. It uses strong verbs like create, set_param, get, list, assign, apply_to_node, and apply_preset, making the tool's purpose very distinct from the vague 'material_manage' name.

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?

It provides detailed per-operation guidance, including parameter signatures, valid types, and behavior like overwrite errors and undo grouping. It also notes the canonical call shape and a compatibility alias. However, it does not explicitly compare this tool to siblings like resource_manage, so alternatives are not discussed.

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 must carry the full burden of behavioral disclosure. It mentions that deform_mesh 'inspects and deforms an existing mesh' (implying mutation), and generate_surface_mesh 'generates' new geometry, but it does not specify whether operations are destructive, reversible, or require save_path to persist. It also omits any permission or side-effect details, leaving safety and side-effect behavior under-specified.

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 well-structured with an introductory phrase, a bulleted list of operations, and a call-shape note. It is front-loaded with the overall purpose and each line serves a distinct role. While lengthy, it is organized and avoids 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?

For a tool with four operations and many parameters, the description is moderately complete. It covers the existence and purpose of each op and the call shape, but it omits return values (partially covered by the output schema), error handling, and path resolution details. Given the tool's complexity, more context on expected inputs and outputs would improve completeness.

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 0%, but the description compensates by listing each operation's parameters with defaults. However, it does not explain parameter formats or expected values (e.g., how vertices should be structured, what primitive types are valid). The description provides a basic map but lacks depth for correct invocation.

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's purpose: procedural mesh synthesis, deformation, and primitive generation. It enumerates four specific operations with brief one-line descriptions, making it distinct from generic manage tools. However, it does not explicitly contrast with sibling tools like geometry_manage, leaving some ambiguity about when this is the right choice.

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. It explains the call shape (canonical and flat op parameters) but does not mention scenarios where mesh_manage is preferred over other tools or when it is not appropriate. This leaves the agent to infer 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?

No annotations are present, so the description carries the full burden. While it explains what each op does (e.g., generates a script, attaches a node), it does not disclose side effects such as file overwriting, scene modification prerequisites, or whether operations are destructive. The mutation vs read-only distinction is also absent, leaving safety-relevant behavior unclear.

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 longer than a single-purpose tool's, but it is well-structured with a summary line, bullet-pointed op signatures, and a final note on call shape. Each section earns its place; there is no filler. It is appropriately detailed for a multi-op 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?

Given the complexity of four sub-operations and the presence of an output schema (which covers return values), the description is largely complete. Minor gaps include missing error-handling behavior, prerequisites like an open project, and explicit notes on when to use the canonical vs alias call shape. These are not critical for basic 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 0%, so the description must compensate. It provides full signatures for each op with parameter names, defaults, and brief contextual descriptions (e.g., 'Generate an ENetMultiplayerPeer network manager script with host/join/disconnect methods and peer signal handling'). This adds meaningful semantics beyond the empty params object in 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 states a specific purpose: high-level Godot multiplayer networking scaffolding and topology inspection. It enumerates four distinct verb operations (scaffold_network_manager, scaffold_spawner, scaffold_synchronizer, get_network_status), each with a clear resource target, which distinguishes it from siblings like network_manage or scene_manage that focus on other aspects.

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