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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic mutation ('add a bone') and gives minimal meaning for head and tail. It does not mention whether the armature must be in a particular mode, whether the operation is reversible, error conditions, or any side effects on the armature's bone hierarchy. This is a significant gap for a mutation tool.

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

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

The description is extremely concise: two short sentences with no filler. The core action is front-loaded. It could be slightly more informative without becoming verbose, but as it stands, every word earns its place, and it is not bloated.

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

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

Despite having an output schema, the description is incomplete for a tool with 5 parameters and 0% schema coverage. It fails to specify how to identify the target armature (`object`), how the bone name is used, or how the optional parent bone is referenced. It also omits practical constraints like coordinate space or edit-mode requirements. The agent would need to open the schema and likely still be unsure about parameter semantics and operation 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?

Schema description coverage is 0%, so the description must compensate. It explains that head and tail are 3D positions, which adds meaning for those two parameters, but it leaves `object`, `name`, and `parent` entirely unexplained. The agent cannot infer from the description what `object` refers to (e.g., the armature object name) or how `parent` should be specified, so the compensation is only partial.

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

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

The description clearly states the action ('Add a bone') and the target resource ('to an armature'), which distinguishes it from siblings like set_bone_property (modifying an existing bone) or add_bone_constraint (adding a constraint). The sentence is specific and unambiguous.

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

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

The description offers no guidance on when to use this tool versus alternatives, prerequisites (e.g., the armature must exist or be in edit mode), or context about the parent relationship. Usage is only implied by the verb 'add,' leaving the agent to infer the appropriate situation from the schema alone.

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

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

With no annotations, the description carries the full burden. It only says 'Add a constraint', implying mutation, but doesn't disclose side effects, required object/bone existence, default constraint settings, error behavior, or return value. This is insufficient for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the action and lists supported types. It's appropriately concise for the limited information it conveys, though it could afford more detail without becoming verbose.

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

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

For a 4-parameter mutation tool with no annotations and an output schema (unseen), the description is incomplete. It lacks essential context about prerequisites, parameter semantics, and behavioral outcomes, making it difficult for an agent to invoke correctly without additional knowledge.

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 explain parameters. It only clarifies the 'type' parameter by listing valid values. The 'object' (presumably armature), 'bone' (bone name), and 'name' (constraint name) are left undefined, leaving the agent to guess their 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 states the action ('Add a constraint') and the target ('pose bone'), and lists specific constraint types (IK, COPY_ROTATION, etc.), which distinguishes it from generic add_constraint. However, it doesn't explicitly contrast with sibling tools like add_constraint, so it's not fully 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?

No guidance on when to use this tool versus alternatives like add_constraint or set_constraint_property. It doesn't mention prerequisites (e.g., the object must be an armature) or conditions that would make this tool preferable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it says nothing about side effects, whether the constraint is added to the specified object or the active object, whether it replaces existing constraints, or what the output/results are. The phrase 'Add a constraint' essentially restates the tool name, and the type list conveys no behavioral traits.

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 highly concise: a single sentence followed by a compact list of constraint types. There is no redundant or filler content, and the action word 'Add' is front-loaded. The list is necessary and efficiently formatted.

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 4 parameters, 0% schema description coverage, no annotations, and existing output schema, the description is radically incomplete. It does not explain what 'object' refers to, when 'bone' should be used, what 'name' does, or what the output will be. It also does not differentiate from add_bone_constraint. An agent cannot reliably invoke this tool correctly based on the provided description alone.

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

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

Schema description coverage is 0%, so the description must compensate. It does provide the allowed values for the 'type' parameter, which is valuable since the schema has no enums. However, the required 'object' parameter and the optional 'bone' and 'name' parameters are left completely unexplained. The description addresses only one of four parameters, leaving significant gaps.

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 the action clearly: 'Add a constraint.' It further specifies the resource by listing all supported constraint types (COPY_LOCATION through CLAMP_TO), which gives an agent concrete grounding. However, it does not explicitly distinguish from the sibling add_bone_constraint, leaving ambiguity about whether this is strictly for object constraints.

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

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

There is no guidance on when to use this tool versus alternatives like set_constraint_property, remove_constraint, or add_bone_constraint. The description lists types but does not mention any context, prerequisites, or exclusions. An agent has to infer usage solely from the tool name.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure. It does not mention side effects like whether the new layer becomes active, how duplicate names are handled, or whether the operation is idempotent or fails.

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

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

A single clear sentence with no filler or irrelevant detail. The key information is front-loaded and easily parsed.

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?

Despite the tool's low complexity, the absence of any parameter documentation, annotations, or operational notes leaves significant gaps. An agent does not know how to reference the object, whether the layer name must be unique, or what happens under edge cases. The presence of an output schema does not compensate for missing invocation 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?

Schema description coverage is 0%, and the description does not explain the 'object' or 'name' parameters beyond what their names suggest. The parameter names are somewhat self-explanatory, but no meaning is added for how objects are identified or what constraints apply to the layer name.

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 'Add a layer to a grease pencil object' uses a specific verb and resource, making the core action clear. It does not explicitly contrast with sibling tools like set_gp_layer_property, but the action of adding versus setting properties is inherently distinguishable.

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

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

No guidance is provided about when to use this tool versus alternatives, nor about prerequisites such as the object already being a grease pencil object. The description only states the action without any 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?

With no annotations, the description must disclose behavior but only states the action. No mention of side effects, error conditions, or requirements (e.g., object must be a Grease Pencil). Minimal 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?

Single concise sentence that front-loads the action and then enumerates types. No wasted words.

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?

Incomplete for a tool with three parameters and no schema descriptions. Lacks explanation of parameter roles, expected object type, return value (though output schema exists), and any usage context. The description alone is insufficient 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?

Schema has 0% description coverage. The description lists the allowed 'type' values but does not explain the 'object' parameter (target object) or 'name' parameter (optional modifier name). Incomplete parameter documentation.

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

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

States a specific verb and resource: 'Add a GP modifier.' Lists the valid types, which adds specificity. Differentiates from the sibling add_modifier by the GP prefix, making its scope clear.

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

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

No guidance on when to use this tool vs add_modifier or other modifier tools. No mention of conditions, prerequisites, or alternatives. The agent must infer from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Add a modifier to an object' and lists types, without mentioning that this mutates the object's modifier stack, whether the operation is reversible, error conditions, or any side effects.

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

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

The description is a single concise sentence followed by a useful list of common types. It is front-loaded with the core action and contains no filler, with every element adding 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?

This is a 3-parameter tool with 0% schema coverage and no annotations, so the description must compensate. It does not explain parameter semantics, behavior, or prerequisites. While an output schema exists, the missing parameter and behavioral context leaves the definition incomplete for reliable 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 explain parameters. It lists common values for the 'type' parameter but does not clarify that 'object' is the target object or that 'name' is an optional custom modifier name. Two of three parameters remain semantically unexplained.

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

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

The description states a specific verb ('Add'), resource ('modifier'), and target ('object'), making the tool's function immediately clear. Listing common modifier types (SUBSURF, BOOLEAN, etc.) further disambiguates it from siblings like remove_modifier, list_modifiers, and set_modifier_property.

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

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

The description implies the use case: adding a modifier to an object. However, it provides no explicit guidance on when to prefer this tool over alternatives such as add_geonodes_modifier, nor does it mention prerequisites like object existence or valid modifier types.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It implies a mutating operation but does not state prerequisites, side effects on the material's existing node tree, error behavior, or reversibility. For a mutation tool with zero annotation coverage, this is a meaningful gap.

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

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

A single sentence with no filler. The core action is front-loaded, and every word contributes meaning.

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?

Despite having an output schema, the description leaves key operational details unspecified: the meaning of location, required preconditions, and what counts as a valid group_name. An agent has enough to guess the high-level intent but not enough to invoke the tool confidently with correct parameters.

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 only adds minimal context for material (target) and group_name (identifier of the existing group). The optional location parameter is completely unexplained: its coordinate format, units, or behavior when null are left to the agent to guess.

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 action ('Add an instance of an existing node group') and a target resource ('to a material'). This distinguishes it from related siblings like create_node_group, which creates a group definition, and create_shader_node, which creates a generic shader node.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It implies that the node group must already exist, but it does not mention when to prefer this over create_node_group or how it relates to node tree manipulation 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 carries full responsibility for disclosing behavioral traits. It only says 'Add a particle system' and lists types, without mentioning that this mutates the target object, requires the object to exist, or how invalid objects/types are handled.

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

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

The description is very brief and front-loaded, with no filler words. However, it is so terse that it borders on under-specification, providing only a bare type list without connection to the 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 there are three parameterschild, one required, and no schema descriptions, the description is incomplete. It does not explain what 'object' refers to, what causes the 'type' to matter, or what the output schema will return. The presence of an output schema helps, but the behavioral and parameter semantics are still under-specified.

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, but it only provides type hints (EMITTER, HAIR). It does not explain the required 'object' parameter or the optional 'name' parameter, leaving the agent to infer their meaning from parameter names alone.

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 uses a specific verb 'Add' and resource 'particle system', and distinguishes it from sibling tools like remove_particle_system, set_particle_property, and get_particle_info. It also mentions the allowed types, though it doesn't explicitly state that the system is added to the required object parameter.

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

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

No guidance is given on when to use this tool versus alternatives such as setup_hair, set_particle_property, or bake_particles. The description implies creation via the word 'Add' but does not state prerequisites, constraints, or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It states that physics will be added and lists types, but it does not describe side effects on the target object, whether existing physics are replaced, prerequisites, or other behavioral consequences.

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 two short sentences with no filler. The core action is front-loaded and the type enum is the only additional content, making it appropriately compact for the information it offers.

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

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

For an add/creation tool with no annotations, the lack of object semantics and the absence of guidance about when to use this tool versus the specialized physics setup siblings leave important context missing. The output schema may cover return values, but prerequisites, consequences, and parameter semantics are insufficiently explained.

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?

With 0% schema description coverage, the description must compensate for the schema's bare string parameters. It does add meaning by enumerating valid type values (RIGID_BODY, CLOTH, FLUID, SOFT_BODY, COLLISION), but it leaves the 'object' parameter completely unexplained—it does not say what the object identifier refers to or how it should be formatted.

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

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

The description clearly states the action ('Add') and the resource ('a physics simulation'), and it lists the supported simulation types. However, it does not differentiate add_physics from specialized siblings like setup_rigid_body_world or setup_cloth_sim, leaving the distinction to be inferred from the type parameter.

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 about when to use add_physics versus the specialized setup_* physics tools, nor any exclusions or prerequisites. The listed types imply intended usage but do not explain the selection context or alternatives.

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

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

The annotation destructiveHint already signals destructive behavior, and the description reinforces this with 'Irreversible' and 'baking it into the mesh.' It also adds the Object Mode requirement, which is useful beyond the annotation.

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

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

Two short sentences with no filler. The action, prerequisite, and consequence are all stated clearly and efficiently.

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

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

For a simple two-parameter action with an output schema and a destructive annotation, the description provides enough context: what happens, the required mode, and irreversibility. It could mention error cases, but they are not essential for correct 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%, and the description provides no extra meaning for 'object' or 'modifier.' It does not clarify whether these are names, IDs, or references, leaving the agent to infer from context.

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 ('apply') and resource ('modifier'), clarifying that it bakes the modifier into the mesh. This clearly distinguishes it from sibling tools like add_modifier or remove_modifier.

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 a clear prerequisite: 'Requires Object Mode.' It does not explicitly mention alternative tools or when not to use it, but the context is sufficient for most use cases.

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 states the conversion but doesn't disclose whether the sculpt mask is deleted, whether the vertex group is created fresh or overwritten, whether the object must be a mesh, or what happens if no sculpt mask exists. The default vertex_group name 'SculptMask' is in the schema, not the description, so the description adds minimal behavioral 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 a single, short sentence that is easy to parse. It is appropriately sized for a simple conversion tool. However, it could have included a bit more context without becoming verbose.

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

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

Given the tool has an output schema and 2 parameters, the description is too thin. It doesn't explain the object parameter, the vertex_group parameter, or the behavior when the mask is missing. The output schema exists but the description doesn't reference what the tool returns. For a tool that converts a sculpt mask, an agent needs to know prerequisites and side effects.

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 doesn't explain what 'object' means (the target object name?) or what 'vertex_group' means (the name of the resulting group, with default 'SculptMask'). The description only mentions the conversion, not the parameters. With 2 params and 0% coverage, this is a significant gap.

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 'Convert sculpt mask to a vertex group' clearly states the action (convert) and the resource (sculpt mask) and the result (vertex group). It is concise and specific. It doesn't explicitly distinguish from sibling tools like create_vertex_group or set_vertices, but the verb 'convert' and the source 'sculpt mask' make the purpose clear enough.

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

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

The description gives no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., object must be in sculpt mode or have a sculpt mask), nor does it say when not to use it. Sibling tools like create_vertex_group or set_vertices exist, but no differentiation is provided.

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

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

With no annotations, the description carries the disclosure burden and clearly states the core side effect: transforms are baked into mesh data and the applied transforms are reset to identity. It does not cover edge cases like non-mesh objects or undoability, but the primary mutation is 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?

Two short sentences, each carrying distinct information: the operation and the postcondition. 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?

The core behavior is present, but with no annotations and no parameter explanations, an agent cannot fully predict which transforms are applied when toggles are false or what happens for non-mesh objects. The output schema may cover return values, so the main gaps are usage guidance and parameter semantics rather than return format.

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 does not explain that the scale, location, and rotation booleans select which transform components are frozen, nor what the required name parameter refers to beyond the obvious. The property names are self-explanatory from the schema, but the description adds no parameter-level meaning.

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

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

States a specific verb ('Apply (freeze)'), the target ('the object's transforms'), and the destination ('to mesh data'), plus the postcondition ('Resets the applied transforms to identity'). This clearly distinguishes it from set_transform, which changes transform values rather than baking them, and from apply_modifier.

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

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

No explicit guidance on when to use this tool versus alternatives like set_transform, set_origin, convert_to_mesh, or apply_modifier. The intended use is implied by the freeze/bake language, but no conditions or exclusions are provided.

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

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

With no annotations, the description carries the behavioral burden. It discloses the key side effect: replacing an existing slot when slot is specified, otherwise appending a new slot. This is meaningful beyond the name and schema, though it does not mention prerequisites or error 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?

Two concise sentences with the core action front-loaded and the conditional slot behavior immediately following. Every word earns its place.

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

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

The tool is simple and has an output schema, so return details are not necessary. However, with no annotations and no usage guidance, the description leaves some gaps around prerequisites and material/object identifier semantics, making it adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the optional slot parameter's effect well, but object and material are only glossed as 'an object' and 'a material' without specifying identifier formats or whether the material must already exist.

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 and resource: 'Assign a material to an object,' and adds precise slot behavior ('replaces that slot; otherwise appends a new slot'). This clearly distinguishes it from material creation, removal, or property-setting 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?

No guidance is given about when to use this tool versus alternatives such as set_material_property or create_material. The intended use is implied by the name and description, but no exclusions or alternative conditions 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 provided, the description carries full burden for behavioral disclosure. It only states the action, not whether it overwrites existing weights, the weight range, or any error conditions. No side effects or reversibility are mentioned.

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

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

The description is a single, concise sentence with no wasted words, but it is under-specified rather than efficiently structured. It lacks any breakdown of parameters or usage context, so while concise, it fails to provide actionable structure.

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

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

For a tool with 4 parameters (3 required) and no schema descriptions, this description is grossly incomplete. It omits how to specify the object and bone, what the vertices array means, and the expected weight range. The presence of an output schema doesn't compensate for the lack of input guidance.

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 adds no meaning beyond the schema. It does not explain that 'object' refers to the mesh, 'bone' is a bone name, 'vertices' are indices, or that 'weight' has a default of 1. The agent is left without any semantic guidance.

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

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

The description clearly states the action (assign vertex weights) and the resource (a bone's vertex group), which distinguishes it from siblings like set_vertices or create_vertex_group. However, it lacks specificity about the context (e.g., which object, how the bone is referenced) and doesn't mention that it modifies an existing group.

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

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

No guidance is provided on when to use this tool versus alternatives like set_vertices or create_vertex_group. There is no mention of prerequisites (e.g., the vertex group must exist) or conditions under which this tool should be chosen.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the particle simulation will be baked and gives no information about side effects, whether existing baked data is overwritten, required object state, or what the resulting cache behavior is.

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

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

The description is extremely short with no fluff, but it is under-specified rather than appropriately concise. A single phrase without parameter or usage context does not earn high marks for structure, as it sacrifices necessary information for brevity.

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 two parameters, 0% schema description coverage, and no annotations, the description is far from complete. It fails to mention prerequisites, parameter roles, or how this relates to sibling baking tools, leaving critical context missing for correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain the two parameters (object and system). The agent gets no help understanding what values to supply, what 'object' refers to, or how 'system' should be specified. The description adds no parameter-level meaning.

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

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

The description names a specific verb and resource: 'bake' and 'particle simulation'. It is clear enough for an agent to understand the core operation, but it does not explicitly distinguish itself from the closely related sibling tools like bake_physics or free_physics_bake.

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

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

There is no guidance about when to use this tool, what prerequisites are needed (e.g., an existing particle system), or which alternatives to prefer. The description simply states the action without providing decision-making 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, the description carries the full behavioral burden. It discloses that the operation is long-running, which is useful, but it does not explain side effects, whether existing bakes are overwritten, whether it blocks, or what happens if no valid physics simulation exists.

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

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

The description is very concise and front-loads the core action, with the long-running caveat right after. Every sentence is informative, though the brevity leaves out important semantic details.

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?

Despite having an output schema, the description is incomplete for an operation with an ambiguous optional parameter and no annotation context. It lacks usage context, parameter meaning, and behavioral expectations, leaving an agent guessing about correct invocation.

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

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

The schema has one parameter, 'object', with zero description coverage. The description does not mention this parameter at all, so it adds no meaning beyond the raw schema. Since the schema coverage is 0%, the description needed to compensate and completely failed to do so.

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 and resource: 'Bake physics simulation.' This is clear about what the tool does. However, it does not distinguish it from related siblings like bake_particles or free_physics_bake, so it misses the differentiation needed for a 5.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of whether the object parameter is required or how it relates to selection. The only contextual hint is that it is long-running, which is not enough to guide selection.

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

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

Annotations already declare destructiveHint=true, covering the destructive nature. The description adds 'Confirm required,' indicating that confirmation is needed for deletion, which goes beyond the annotation. However, it is ambiguous—it does not state that the confirm parameter must be true, nor what happens if it is false. It provides minimal extra behavioral context without contradiction.

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

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

The description is very concise: two short sentences, front-loaded with the primary action. Every sentence earns its place—the purpose sentence and the confirmation note are both relevant. It is not verbose, though it could be more structured (e.g., separate behavior details), but it is efficient.

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 it is a destructive batch operation with a confirmation parameter, the description is incomplete. It does not clarify the confirmation behavior (e.g., does confirm need to be explicitly true?), nor does it explain what constitutes 'objects' (IDs vs. names). Output schema exists, so return values are not needed, but the operational context is insufficient for an agent to call this safely and correctly without additional assumptions.

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% (description does not document parameters), so the description must compensate. It only says 'multiple objects at once' and 'Confirm required,' which vaguely implies the 'objects' array and the 'confirm' flag. It does not explain what the objects array contains (e.g., IDs, names), the format, or the exact role of confirm beyond being required. This is insufficient for the schema coverage gap.

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 deletes multiple objects at once, which is a specific verb+resource. It distinguishes from sibling tools like delete_object (single deletion) and delete_collection (collection-level deletion), so an agent can understand its unique role 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 batch operations as a preferred choice over repeated delete_object calls, nor does it state any conditions or exclusions. The only hint is 'Confirm required,' which is a behavioral note, not a usage guideline.

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. 'Set' implies mutation, but the description does not state whether existing property values are overwritten, whether missing properties are created, how errors on individual objects are handled, or whether the operation is atomic.

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

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

The description is one short sentence with no filler and it leads with the core action. It is concise, though it sacrifices useful contextual detail that could have been added without bloating the description.

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 batch mutation tool with no annotations and 0% parameter coverage, this description is too thin. An agent is not told what kinds of properties are valid, whether the operation creates or overwrites properties, or how object identifiers are resolved; the output schema exists but does not excuse the missing operational 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?

Schema description coverage is 0%, so the description must compensate, but it only clarifies that the property is applied to multiple objects. It does not explain the allowed domain of the property string, how objects are referenced, or the role/value constraints of the value parameter beyond what the bare parameter names suggest.

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 operation: setting one property across multiple objects. The phrase 'same property' and 'at once' clearly establish the batch scope, which distinguishes it from the many sibling set_*_property tools that target a single element.

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 use case is implied: use this tool when the same property must be applied to multiple objects, rather than calling an individual setter repeatedly. However, it names no alternative tools and gives no exclusions or conditions for when an individual setter 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the intended effect and does not mention prerequisites, side effects, whether the camera must already exist, or 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 a single sentence with no filler words and is front-loaded with the core action. It is appropriately sized for the tool's apparent simplicity.

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 output schema exists, so return-value details are not necessary, but 0% schema coverage and no annotations leave important context missing. An agent still lacks enough information about prerequisites, coordinate semantics, and parameter interactions to reliably construct a correct call.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at two modes ('target object' vs 'world location') but does not name the parameters, explain that camera is likely the camera name, specify coordinate format for location, or clarify what happens if both target and location are 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 uses a specific verb ('point') and resource ('camera') and clearly states the operation: aiming at a target object or world location. This distinguishes it from sibling camera operations like set_active_camera or set_camera_property without needing to name them explicitly.

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

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

There is no guidance about when to use this tool versus alternatives. The description implies a camera-orientation use case, but it never states when this tool should be preferred over set_camera_property, setup_camera_dof, or other camera 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 already declare readOnlyHint=true, so the safety profile is covered. The description adds that a file is written and a file path is returned, which is useful, but it does not disclose overwrite behavior, path creation, or filesystem side effects. No contradiction with annotations.

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

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

A single, front-loaded sentence of 14 words contains all core information with no filler. Every phrase earns its place, and the primary action is stated immediately.

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

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

For a simple one-parameter tool with a default value, read-only annotation, and existing output schema, the description plus schema is nearly sufficient for correct invocation. The main missing piece is the distinction from render_viewport, which affects tool selection more than calling mechanics.

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 filepath parameter has no schema description (0% coverage), but the phrase 'to a file' and 'Returns the file path' loosely imply that the parameter controls the output location. It does not explicitly name the parameter or explain defaults/format, so compensation is only partial.

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

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

The description uses a specific verb ('Capture') and a specific resource ('3D viewport'), and states the output ('file path'). It is clearly not a tautology. However, it never contrasts with the sibling render_viewport tool, so an agent must infer that a screenshot differs from a render.

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

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

No guidance is provided on when to use capture_viewport instead of render_viewport, render_image, or get_viewport_info. There are no conditions, exclusions, or alternative routing signals; the agent is left to infer selection from the name and description alone.

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

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

The annotations already declare destructiveHint=true, and the description adds the important behavioral detail that the operation is irreversible. It also specifies what gets removed (keyframes and actions), which is useful context beyond the annotation. No contradiction with annotations.

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

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

The description is a single sentence with no filler. It front-loads the action and scope, then adds the critical irreversibility warning. Every word earns its place.

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

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

For a simple one-parameter destructive tool with annotations and an output schema, the description is largely sufficient. It states the operation, target, and irreversibility. The main gap is the lack of parameter clarification and explicit alternative routing, but these are minor given the tool's simplicity.

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 undocumented 'object' parameter. The phrase 'from an object' adds minimal meaning beyond the schema property name and does not clarify how the object should be identified (e.g., name, path, or ID).

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

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

The description uses a specific verb ('Remove') and resource ('all animation data (keyframes, actions) from an object'), making the tool's scope clear. It also distinguishes itself from sibling tools like delete_keyframe by emphasizing that it removes all animation data, not just a single keyframe.

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

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

The description implies the tool is for clearing all animation data from an object, but it does not explicitly state when to use it versus alternatives like delete_keyframe or list_actions. No exclusions or alternative routing are provided, so the agent must 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a meaningful behavioral trait: the object's world transform is preserved after clearing the parent. However, it does not mention side effects on children, local transform recalculation, or behavior when the object has no parent.

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

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

The description is a single, tightly worded sentence that front-loads the core action and immediately states the critical behavioral qualifier. There is no redundant or filler content.

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

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

For a simple one-parameter operation with an output schema, the description is mostly adequate: it states the action and the key transform-preservation behavior. However, it lacks usage guidance, parameter clarification, and any mention of edge cases or side effects, leaving some gaps for an agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'name' parameter. The phrase 'an object's parent' implies that 'name' identifies the object, but it does not explicitly explain the parameter's meaning, format, or valid values. This is minimal compensation.

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 ('Clear') and resource ('an object's parent'), and adds the key behavioral qualifier 'keeping its world transform.' This clearly distinguishes it from sibling tools like set_parent or parent_mesh_to_armature, which establish rather than remove parent relationships.

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

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

The description implies the tool is used when an object's parent should be removed, but it gives no explicit guidance about when to choose this over alternatives, nor does it mention any prerequisites or exclusions. There is no comparison to set_parent or other parenting-related tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'connect', with no details about whether existing input connections are replaced, whether socket types must match, what happens on failure, or whether the operation is reversible. The behavior beyond the bare action is not 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 very short and front-loaded, but it is under-specified for a tool with four required parameters and no parameter documentation. It is concise without being wasteful, but the brevity crosses into missing useful context.

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

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

For a connection operation with four required parameters, no annotations, and no parameter descriptions, a three-word description is insufficient. An agent would need to know how to identify outputs/inputs, whether nodes must already exist, and the semantics of string versus integer socket references.

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 does not compensate by explaining the four required parameters. While names like from_node and to_node are self-explanatory, from_output and to_input are ambiguous between socket names and indices, and the description provides no clarification.

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 and resource: connecting compositor nodes. It is not a tautology, and 'compositor' clearly distinguishes this from sibling tools like connect_shader_nodes and connect_geonodes, though it does not explicitly name those 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 gives no guidance on when to use this tool versus connecting shader or geometry nodes, nor does it mention prerequisites like existing nodes or compatible socket types. Usage is only implicitly tied to compositor nodes by the description itself.

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

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

There are no annotations provided, so the description carries the full burden of behavioral disclosure. It only says 'Connect nodes' and does not mention whether connecting an input replaces an existing connection, whether it modifies the object's modifier node tree, or any side effects. This is insufficient for a mutating 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 very short and front-loaded, but it is under-specified rather than genuinely concise. Omitting all parameter and behavior context makes the brevity a deficiency, not a strength.

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?

While an output schema exists, the description still fails to provide enough context for correct invocation of a tool with six required parameters and no parameter documentation. The operation is simple in concept, but socket addressing and replacement behavior are not covered, which leaves significant gaps for an agent.

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 adds no parameter information at all. The six required parameters—object, modifier, from_node, from_output, to_node, to_input—are left entirely to name inference, and the string/integer socket addressing format is not explained.

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, 'connect', and a clear resource, 'nodes in a geometry node tree.' It distinguishes itself from similar sibling tools like connect_shader_nodes and connect_comp_nodes through the 'geometry node tree' qualifier. However, it does not explain the exact operation scope, such as socket-level connection or one-to-one linking.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It does not explicitly direct an agent to use this tool only for geometry node trees or mention that shader/compositor connections belong elsewhere.

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 usefully reveals that sockets can be addressed by name or index, but it does not disclose what happens to an existing connection on the target input (Blender inputs accept a single connection, so this likely replaces it), nor does it mention validation of socket types or error behavior. For a mutating tool this is a significant gap.

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

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

Two sentences with no filler; the core action is front-loaded and the second sentence adds genuinely useful parameter semantics. Every word earns its place.

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

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

For a 5-parameter graph-editing mutation with zero annotations and zero schema descriptions, the description is thin. It omits node/material reference semantics, the replacement behavior on existing connections, and any guidance on resolving socket type mismatches. The presence of an output schema mitigates return-value ambiguity, but input-side semantics remain under-specified.

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% for all 5 parameters, so the description must compensate. It explains the string-or-integer socket variants ('by name or index'), which maps to from_output and to_input, but it leaves material, from_node, and to_node semantics to inference from their names, and does not explain how nodes or materials are identified or how directionality is encoded.

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 and resource ('Connect an output socket to an input socket') with a clear direction of data flow. The tool name carries the 'shader' scope, distinguishing it from connect_geonodes and connect_comp_nodes, though the description itself does not explicitly name this differentiation.

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

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

There is no guidance on when to use this tool versus its close alternatives (connect_geonodes, connect_comp_nodes, disconnect_shader_node, set_node_input). No context is given about prerequisites such as the material existing or the nodes being present in the tree, and no exclusions 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?

The annotation destructiveHint=true already discloses mutability, but the description adds specific behavioral context: it explicitly warns that curve editability is lost. This goes beyond the generic annotation, explaining what is destroyed. However, it does not mention other potentially relevant side effects (e.g., whether the curve object is replaced or a new object is created).

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 two sentences, front-loaded with the core purpose followed by a single caveat. Every word earns its place; there is no padding 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 single-parameter conversion tool with an output schema, the description is adequate but not complete. It lacks guidance on how to identify the object, what happens to the original curve, and how errors (e.g., non-curve input) are handled. The output schema may cover return values, but parameter semantics remain a significant gap.

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

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

The schema exposes one required string parameter 'object' with zero description coverage. The description does not explain what value should be passed (e.g., object name, ID), nor does it mention validation requirements. 'Convert a curve object' only implies the target is a curve, but the parameter format is left entirely to inference.

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 specific action ('Convert a curve object') and result ('to a mesh'). It differentiates from siblings like get_curve_info or create_curve by naming the transformation. The added caveat 'Loses curve editability' further defines the purpose.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., the object must be a curve), when not to use it, or relationships to sibling tools like apply_modifier or remesh. The description only states what the tool does, not when to select it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether existing modifiers on the target are replaced or appended, whether the source remains unchanged, or what happens if the source has no modifiers. The basic effect is clear, but these behavioral details are material for a mutation tool.

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

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

A single sentence with no filler; the action and direction are front-loaded. Every word earns its place.

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

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

Given the simple two-parameter schema and presence of an output schema, the description is mostly adequate, but it omits the key side effect on the target object's existing modifiers. The absence of annotations raises the importance of that missing behavioral 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?

With 0% schema description coverage, the description compensates by clarifying that source is the object providing modifiers and target is the object receiving them, using 'from source object to target object'. It does not give identifier format or merge behavior, but for two simple string parameters the roles are meaningfully specified.

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

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

The description states a specific action ('Copy'), a precise resource ('all modifiers'), and a clear direction ('from source object to target object'). This is distinct from related siblings like move_modifier or add_modifier, so an agent can tell what it does without inspecting 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 intended use is implied by the verb 'copy' (use when all modifiers should be duplicated from one object to another), but the description gives no explicit guidance about when to prefer this over move_modifier, add_modifier, or remove_modifier, and no exclusions or caveats.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core action, but does not mention side effects like selection/activation of the new armature, naming defaults, coordinate handling, or error scenarios. This is minimal disclosure for a creation 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 a single sentence with no filler or repetition. It communicates the essential purpose immediately and every word earns its place.

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

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

For a simple two-parameter creation tool with an output schema, the description is minimally sufficient. However, with no annotations and no parameter guidance, an agent is left to infer defaults and behavior from the schema alone, leaving minor but real gaps.

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%, yet the description mentions neither the 'name' nor the 'location' parameter. It adds no semantic meaning beyond what the raw schema fields already expose, failing to compensate for the low coverage.

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

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

The description uses a specific verb ('Create') and resource ('armature') and adds 'with an initial bone', which clearly distinguishes it from sibling tools like add_bone. An agent can understand exactly what this tool does 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 implies this tool is for creating a new armature rather than modifying an existing one, and the sibling set includes add_bone for later bone additions. However, it does not explicitly state when to prefer this over alternatives or mention any exclusions.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only states the creation action, leaving unclear whether the camera is added to the active scene, whether it becomes the active camera, what naming behavior occurs, or what units focal_length uses.

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

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

A single, front-loaded sentence with no filler. Every word contributes meaning, and the key customization, focal length, is stated immediately after the action.

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

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

For a low-complexity creation tool with fully optional parameters and an output schema, an agent can likely invoke this successfully. However, the description leaves parameter semantics, side effects, and usage-versus-alternatives unaddressed, so it is only minimally 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 for parameter meaning. It mentions focal_length but adds no detail about units, range, or default behavior, and it entirely omits the name and location parameters. The schema defaults help, but the description does not fill the gap.

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 specific operation (create), the resource (camera), and the key attribute (focal length). This clearly separates it from sibling tools like list_cameras, set_camera_property, and set_active_camera, which are not creation 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 no guidance on when to use this tool versus alternatives such as set_camera_property or set_active_camera, and no context about prerequisites like requiring an active scene. Usage is only implied by the word 'create'.

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 behavioral traits. It only states 'create', which implies mutation, but does not mention side effects, permissions, error conditions, or what happens if the parent does not exist. The default parent value is not explained either.

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

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

The description is a single, concise sentence with no filler. It states the core action and the optionality of the parent, which is efficient and 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 creation operation with no annotations and no output schema description, the description is minimal. It doesn't explain return values, prerequisites (like whether the parent collection must already exist), or error handling. Given the low parameter count, it could be acceptable, but for a mutating operation more context is expected.

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 add meaning. It explains that 'parent' is optional ('optionally under a parent collection'), giving some semantic context, but does not elaborate on the 'name' parameter beyond its presence in the schema. This is partial compensation.

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

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

The description clearly states the tool creates a new collection, optionally under a parent. It distinguishes itself from sibling tools like delete_collection and list_collections by its verb and object, though it doesn't explicitly name alternatives.

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

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

No guidance is given on when to use this tool versus related tools like move_to_collection or list_collections. The context of creating a new collection is obvious, but there's no mention of prerequisites (e.g., parent must exist) or when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Add a compositor node' with no mention of side effects, requirements, or what happens if the compositor tree doesn't exist. It doesn't even state that the node will be added to the current scene's compositor tree or how it interacts with other compositor operations. This is a significant lack of transparency for a mutating tool.

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

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

The description is a single sentence with a list of types. It is concise and front-loaded with the primary action. Every word contributes to the core purpose, though it could be slightly more structured with separate notes on 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?

For a creation tool with no annotations, an output schema, and 0% schema coverage, the description is incomplete. It fails to mention that the tool operates within a compositor node tree, that the tree must be enabled or accessed via get_compositor_tree, or that the node will be placed but not connected. The list of common types helps, but missing parameter semantics and workflow context leave the agent without enough information to call it reliably.

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 provides a list of common types for the 'type' parameter, which gives some semantic guidance, but it does not explain that 'type' is required or describe the 'name' and 'location' parameters at all. The agent is left to guess what values are valid for those fields, and the description offers no syntax or examples beyond the type list.

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

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

The description clearly states the action: 'Add a compositor node.' It identifies the resource type (compositor node) and lists common types, which helps distinguish it from shader or geometry node creation tools. However, it does not explicitly connect it to the compositor node tree or mention the broader workflow, so it's clear but not fully differentiated from all 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?

There is no guidance on when to use this tool versus alternatives like create_shader_node or create_geonode. It also doesn't mention prerequisites such as needing an active compositor tree or whether the node will be automatically connected. The only hint is the word 'compositor' in the description, which is implicit rather than 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 present, so the description carries the full burden of behavioral disclosure. It only states 'Create a curve object' and lists types; it does not mention side effects, coordinate space, default naming/location behavior, or whether prior selection matters. For a mutation tool, this is minimal.

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

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

A single, front-loaded sentence with no filler. The essential information—action, resource, and type options—is delivered efficiently.

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 3-parameter creation tool with no annotations, the description is too sparse. It does not explain how location is interpreted, whether name is a unique identifier, or what the output of the operation is (though an output schema exists). The type list helps, but the overall guidance is incomplete.

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

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

Schema coverage is 0%, so the description must compensate. It does cover the 'type' parameter by listing allowed values, but it says nothing about 'name' or 'location'. Even the type list lacks details like default behavior or format restrictions beyond what the schema enumerates.

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

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

The description clearly states the action ('Create') and the resource ('a curve object'), and enumerates the valid types (BEZIER, NURBS, POLY). This adequately distinguishes it from modification tools like set_curve_property or set_curve_points, though it doesn't explicitly contrast with generic create_object.

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

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

No guidance is provided about when to use this tool versus alternatives like create_object or set_curve_property. The intended use case is implied by the name and description, but there are no explicit conditions, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action (adds a node) but does not mention side effects (e.g., whether existing nodes are affected), required permissions, potential failures for unsupported types, or the return value. For a mutation tool, this is a significant gap in 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 concise (one sentence plus a list of examples) and front-loaded with the core action. The list of types is somewhat long but adds value for the 'type' parameter. There is no fluff or redundancy, though the list could be trimmed or moved to an external reference without losing clarity.

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 five parameters (three required) and no schema descriptions, the description is insufficient. It does not explain what 'object' and 'modifier' refer to, whether the node tree must already exist, or what the output is. The presence of an output schema is noted, but the description alone does not give an agent enough context 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 schema provides no parameter descriptions (coverage 0%). The description lists valid values for 'type' (e.g., GeometryNodeMeshGrid), which is helpful, but it does not explain the roles of 'object', 'modifier', 'location', or 'name'. This leaves most parameters ambiguous, and the description only partially compensates for the missing schema documentation.

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

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

The description clearly states the tool's purpose: 'Add a node to a geometry node tree.' This is a specific verb-resource combination that distinguishes it from sibling tools like connect_geonodes (which connects nodes) and create_geonodes_modifier (which creates a modifier). The mention of common node types further clarifies the 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., an existing geometry node tree or modifier), nor does it contrast with related operations like delete_geonode or connect_geonodes. The common types list hints at usage but does not explicitly state conditions or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal an important behavior—creating a new tree or reusing an existing one—but it omits side effects, prerequisites, or what happens to the target object. For a mutating tool, this is thin.

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

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

The description is concise and front-loaded with the core action. Both sentences carry meaning and there is no filler. It is slightly under-specified for the parameter set, but as a concise statement it is well structured.

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 three parameters, no annotations, and no parameter documentation in the description, this is incomplete. An agent would not know that object is required, what name defaults to, or how tree_name selects between new and existing trees. The output schema may describe return values, but the input semantics are insufficiently covered.

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

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

Schema description coverage is 0%, so the description must compensate, but it only vaguely hints at tree_name behavior ('Creates a new tree or uses an existing one'). It does not explain the required object parameter, the name default, or how tree_name interacts with tree creation.

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 verb and resource: 'Add a geometry nodes modifier.' It also adds scope by noting it creates a new tree or uses an existing one, which differentiates it from generic modifier tools. It could more explicitly contrast with the sibling add_modifier, but the 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?

No guidance is given about when to use this tool versus alternatives like add_modifier or create_geonode. The description implies its use case but does not state exclusions or provide decision criteria for choosing it over 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?

No annotations are provided, so the description carries the full burden. It indicates a creation side effect, but does not disclose whether the stroke replaces or appends to existing strokes, what happens with the optional frame parameter, or failure behavior for invalid object/layer references.

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

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

The description is concise and front-loaded with the purpose, followed by a compact definition of the point list format. Every sentence earns its place, but the brevity leaves out essential guidance that the other dimensions require.

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

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

For a 4-parameter mutation tool with no annotations and no schema descriptions, the description is not complete enough. It covers the point structure but omits identifier semantics, frame behavior, error conditions, and side effects, leaving an agent to guess critical invocation details.

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 only documents the 'points' parameter structure (co, pressure, strength), which is helpful, but it leaves the required 'object' and 'layer' parameters and the optional 'frame' parameter entirely unexplained. Given 0% schema description coverage, this falls short of compensating for the missing parameter semantics.

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

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

The description states a specific verb and resource ('Create a stroke from point list') and gives the point data format. The sibling list contains no other stroke-creation tool, so the purpose is reasonably distinguishable, though it does not explicitly mention 'grease pencil' in prose.

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

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

There is no guidance about when to use this tool versus siblings like create_grease_pencil or add_gp_layer, nor any mention of prerequisites such as an existing grease pencil object and layer. The intended context is only implied by the name and description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the creation action and does not mention scene insertion, data-block creation, active-object changes, or name-collision behavior.

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

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

The description is a single direct sentence with no filler and is easy to parse. However, it is so terse that it leaves behavioral and usage gaps, so it is concise but not fully informative.

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 need not be described. For a two-parameter creation tool this is near-minimal viable, but missing context about how and where the object is created and how it relates to existing grease pencil objects leaves clear gaps.

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 does not mention name or location at all. While the parameter names and defaults are fairly self-explanatory, the description should have compensated for the missing schema descriptions and does not.

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 clear verb ('Create') and resource ('grease pencil object'), which distinguishes it from generic create_object and from create_gp_stroke/add_gp_layer that operate on strokes or layers. It is specific enough, though it stays at the phrase level without elaborating on what 'grease pencil object' includes.

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

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

No guidance is given on when to use this tool versus alternatives such as create_object, create_gp_stroke, or add_gp_layer. The description provides no context, prerequisites, or selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Set up HDRI environment lighting') but doesn't disclose whether this replaces existing world lighting, whether the filepath must reference an already-loaded image or a path on disk, what happens to the existing world setup, or any side effects. For a setup/mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, concise sentence that front-loads the core action. It's appropriately sized for a simple tool, though it could earn its place better by adding a note about the strength parameter or side effects without becoming verbose.

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

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

The tool has an output schema (not shown) and only 2 parameters, so the description doesn't need to explain return values. However, for a mutation tool with no annotations, the description is incomplete: it doesn't clarify the filepath semantics (loaded image vs. disk path), the effect of strength, or whether existing HDRI setup is replaced. An agent would need to open the schema or guess to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'from an image file' which maps to the filepath parameter, but it doesn't explain the 'strength' parameter at all. The description adds minimal meaning beyond the schema's bare property names, leaving the agent to guess what 'strength' controls (likely light intensity, but not stated).

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 ('Set up') and resource ('HDRI environment lighting from an image file'), which clearly identifies the tool's function. It distinguishes itself from sibling tools like create_light and set_world_property by focusing on HDRI environment setup, though it doesn't explicitly name those 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 implies usage context: setting up HDRI environment lighting from an image file. It doesn't explicitly state when to use this over create_light or set_world_property, nor does it mention prerequisites like the image needing to be loaded first. The context is clear enough for an agent to infer the primary use case, but lacks explicit routing 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 provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, required context, or return behavior. It does not indicate whether creating a light modifies the scene immediately, whether it is reversible, or what the output schema contains.

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

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

The description is a single sentence and is front-loaded with the action and key type information. It contains no filler and is appropriately brief. The brevity is a strength, though it comes at the cost of missing critical details.

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 severely incomplete for a tool with five parameters and no annotations. While an output schema exists, the description does not explain parameter semantics, behavioral effects, or usage context. An agent would be left guessing about how to correctly invoke the tool without additional inference.

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 adds meaning only for the 'type' parameter by listing valid values (POINT, SUN, SPOT, AREA). The other four parameters (name, color, energy, location) are left completely unexplained, with no format, constraints, or default behaviors described. This is insufficient for a tool with five 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 clearly states the action 'Create a light' and enumerates the valid types (POINT, SUN, SPOT, AREA). This differentiates it from other creation tools like create_camera or create_object, and the type list adds specificity. Although it doesn't explicitly contrast with create_light_rig, the core 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?

No guidance is provided on when to use this tool versus alternatives such as create_light_rig, set_light_property, or create_hdri_world. There are no conditions, prerequisites, or exclusions mentioned, leaving the agent without routing information.

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

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

With no annotations, the description must disclose all behavioral traits. It mentions optional aiming and the creation of three lights, but does not state whether it replaces existing lights, how energies map to light intensities, or any side effects. This is a significant gap for a creation 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 a single, efficient sentence that front-loads the core purpose and adds the optional targeting detail. 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's moderate complexity (4 optional parameters with defaults), the description provides a conceptual overview but lacks parameter-level detail and side-effect disclosure. The presence of an output schema (not shown) may clarify return values, but the description alone is incomplete for an agent to call correctly without additional reasoning.

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 should explain the parameters. It references key, fill, rim and target, but does not explain the energy parameters (key_energy, rim_energy, fill_energy) or their roles. The schema only provides names and defaults, leaving the agent to guess the meaning of these numeric values.

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

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

The description clearly states the verb 'Create' and the resource 'three-point lighting setup' with components key, fill, rim. This distinguishes it from sibling create_light, which likely creates a single light, and other lighting tools. It also notes optional targeting of an object, making the purpose unambiguous.

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

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

The description implies it is a convenience tool for a classic three-point setup but does not explicitly contrast it with alternatives like create_light or set_light_property. No guidance on when to prefer this over creating lights individually is given, leaving the agent to infer from 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 behavioral burden, but it only reveals the base_color input format. It does not disclose what happens on creation (e.g., whether the material is auto-assigned, how name conflicts are handled, or the effect of a null base_color).

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

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

One sentence with the action front-loaded and zero filler. The base_color format note earns its place, though the brevity comes at the cost of omitted parameter semantics.

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

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

For a creation tool with 4 parameters, zero annotations, and 0% schema description coverage, this description is incomplete: three parameters are undocumented and creation side effects are not stated. The output schema covers return values, but that does not compensate for the missing input and behavioral 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?

Schema description coverage is 0%, so the description must document the parameters, yet it only explains base_color's [R,G,B,A] format and 0-1 range. name, metallic, and roughness rely entirely on their names and defaults, leaving their semantics and valid ranges undocumented.

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 the verb (Create), resource (material), and specific type (Principled BSDF) in one clear clause. This distinguishes it from siblings like duplicate_material (copy existing) and create_shader_node (node-graph elements), so an agent can select it correctly 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?

No guidance on when to create a new material versus reusing, duplicating, or modifying an existing one. The sibling set includes duplicate_material, assign_material, and set_material_property, but the description offers no selection criteria among them.

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 disclose behavioral traits itself. It only states the action 'Create' and does not explain side effects (e.g., whether selected nodes are moved or duplicated), any required context (e.g., active node tree), or what happens to the original nodes. The existence of an output schema is not mentioned, and there is no information about permissions or reversibility. This is a significant gap for a mutation tool.

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

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

The description is a single sentence with no filler words, making it efficient and front-loaded with the core action. However, it is overly sparse; while conciseness is good, it sacrifices essential detail. It could be more informative without becoming verbose, so it earns a 4 rather than a 5.

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 3 parameters, no annotations, and an output schema, this description is severely incomplete. It does not explain the role of the required 'material' parameter, how 'nodes' are referenced, the meaning of the optional 'name', or what the output represents. It also fails to distinguish from the many node-related siblings. An agent cannot reliably invoke this tool based on this description alone.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings. It does not mention 'material', 'nodes', or 'name' at all. The description adds zero value beyond the schema, which already lists parameter names and types. This leaves the agent guessing what 'material' represents (e.g., a shader material, a material slot) and what the 'nodes' array expects.

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 action ('Create') on a specific resource ('a node group') and specifies the source ('from selected nodes'), making the core purpose understandable. However, it does not differentiate from sibling node tools like create_shader_node or create_geonode, nor does it clarify whether this is a shader node group, geometry node group, or generic, leaving ambiguity about its 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?

No guidance is given on when to use this tool versus alternatives such as add_node_group_instance or create_shader_node. It does not state prerequisites like having nodes selected or being inside a specific node tree, nor does it mention any exclusions. The only implied usage is 'create a node group', which is too vague to route an agent correctly.

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 not provided, so the description carries the burden of behavioral disclosure. The description mentions that the returned name may differ if the name exists, which is a useful behavioral note. However, it does not disclose other behaviors like error handling, whether the object is automatically selected, or any side effects like affecting the active collection. It also doesn't specify if the object is created in the current scene or if any coordinate system is used.

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 two sentences long, with the first sentence front-loading the verb and object types. The second sentence adds a critical behavioral detail about name uniqueness. It is concise with no filler. The only minor issue is that the list of types could be trimmed or moved to schema, but it is useful in the description.

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 all parameters are optional (0 required), the tool is relatively simple. An output schema exists, so return format is covered. The description covers the supported types and name uniqueness. Missing context includes whether location is optional and what happens if type is invalid. But for a simple creation tool, it is adequate. It could be more complete by noting that location uses world coordinates or that the object is added to the active collection, but these are minor.

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. The description lists the 'type' possible values and explains the return name behavior, but the 'name' and 'location' parameters are left to the schema, which has enums? Actually, there are no enums. The schema shows defaults and types but not semantics beyond that. The description adds minimal value for parameter understanding; the agent still needs to infer that location expects coordinates and name is a string identifier. A baseline of 3 is appropriate because the description adds some context but not much beyond what the schema implies.

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

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

The description clearly states the tool creates a new object and provides a list of supported types, which aligns with the 'create_object' name. It distinguishes itself from sibling tools like create_light, create_camera, etc., by focusing on generic object creation. However, it does not explicitly name any sibling or explain why this tool is used over others, but the purpose is unambiguous.

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

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

The description implies usage context: creating objects of various types in the scene. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. For example, it doesn't clarify that this is for basic primitives and that more complex objects like lights, cameras, or curves have dedicated tools, which are listed as siblings. This is a gap but not misleading.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the creation action and lists common types; it does not mention failure behavior for invalid material or type, how location defaults work, or what the response contains. This is insufficient for a mutation tool.

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

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

Two compact sentences, front-loaded with the action and resource. The type list is relevant and not padded; there is no redundant or verbose content.

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 though an output schema exists, the description omits key contextual details: prerequisite material existence, distinction between material/shader trees and geometry/compositor trees, and where to find the complete type list. An agent can make a basic call but may fail without those implicit assumptions.

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 adds a useful list of common `type` values, but it leaves `material`, `name`, and `location` semantics unexplained (e.g., that material is a material name, location is a 2D coordinate). This is partial compensation only.

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 an explicit action ('Add a shader node') with a specific resource ('a material') and enumerates common valid node types. This clearly distinguishes it from sibling tools like delete_shader_node, connect_shader_nodes, and geometry/compositor node creation.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites (e.g., material must exist, node tree must be enabled), and no pointer to list_shader_node_types for the full type catalog. Usage is only implied by the tool name and verb.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('adds a UV map') but doesn't say what happens if the object isn't a mesh, whether an existing UV map with the same name is overwritten or auto-renamed (relevant given the 'UVMap' default), or whether the operation is reversible. Nothing is misleading, but behavior is essentially undisclosed.

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

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

The single sentence has no fluff and is front-loaded with the core action. But the brevity reads as under-specification rather than efficient compression: for a tool with no annotations and 0% schema coverage, this is too thin to be 'appropriately sized.'

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

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

The tool is simple (2 parameters, 1 required, output schema present), which reduces the burden, but the description still omits essential call information: the meaning of `name` is unexplained, collision behavior with existing UV maps is unknown, and no error conditions are noted. With no annotations and an empty parameter schema, these omissions leave an agent guessing.

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 loosely maps the `object` parameter by specifying the target is a mesh, but it never mentions the `name` parameter—its meaning, format, or 'UVMap' default. The added value over the bare schema is marginal (a single noun, 'mesh'), which is insufficient for two otherwise undocumented 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 uses a specific verb ('Add') with a concrete resource ('UV map') and target ('mesh object'), making the core action unambiguous. It doesn't, however, differentiate itself from the sibling `smart_uv_project`, which also produces a UV map on a mesh, so it earns a 4 rather than a 5.

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

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

There is no guidance on when to use this tool versus `smart_uv_project` (projection-based UV creation) or `get_uv_maps` (reading existing maps). No prerequisites are stated—e.g., that `object` must reference an existing mesh—and no error cases or alternatives are mentioned. The intended use is only implied by the tool name and one-line description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the obvious creation action and optional vertex assignment. It does not explain what happens if the group already exists, whether the object must already exist, or how the weight is applied to the listed vertices.

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

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

The description is a single concise sentence with no wasted words. However, conciseness is achieved by omitting important parameter context, so it is efficient but incomplete.

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

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

For a 4-parameter creation tool with no annotations and zero schema description coverage, this description is under-specified. It fails to mention the required 'object' parameter, gives no usage context, and leaves the weight semantics ambiguous. The presence of an output schema does not compensate for these gaps.

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, but it only lightly covers vertices and weight while omitting the required 'object' parameter entirely. It does not clarify that 'weight' is a single scalar applied to all assigned vertices or how the 'vertices' array relates to the object.

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

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

The description uses a specific verb and resource, 'Create a vertex group', and notes the optional assignment of vertices with a weight. It is clear about the basic operation, though it does not explicitly differentiate itself from siblings like assign_vertex_weights or get_vertex_groups.

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

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

There is no guidance on when to use this tool versus alternatives such as assign_vertex_weights or get_vertex_groups. No context is provided about prerequisites or whether this should be used before other vertex-group operations.

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?

Beyond the destructiveHint annotation, the description discloses a specific destructive consequence—objects become orphaned—and states that confirmation is required. This is meaningful behavioral context that helps an agent anticipate the side effects of calling the 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?

Three short, front-loaded sentences: action, consequence, and requirement. Each sentence adds distinct information 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 two-parameter destructive tool with an output schema and a destructiveHint annotation, this description covers the critical operation, side effect, and safety gate. No essential information is missing for a correct invocation.

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

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

The schema provides 0% description coverage, so the description carries the burden. It clarifies that confirm is required, overriding the schema's default false, but the required name parameter is only implied by the tool name rather than explained.

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 the operation as 'Delete a collection' with a specific resource and meaningful consequence. It differentiates itself from object/material deletion tools by naming collections and describing orphan behavior, so an agent understands exactly what this tool targets.

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?

Gives no guidance about when to choose this over related alternatives like batch_delete, move_to_collection, set_collection_visibility, or list_collections. The only actionable hint is 'Confirm required,' which addresses how to invoke the action rather than when to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action but doesn't disclose side effects, such as whether removing a node also disconnects its links, whether it fails silently if the node doesn't exist, or whether it affects the active node selection. The description is minimal and leaves these behaviors unspecified.

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

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

The description is a single, short sentence that is easy to parse and front-loads the action. It is appropriately concise for a simple tool, though it could add a bit more context without becoming verbose.

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

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

Given the tool's simplicity, the description is minimal but lacks important context. There is no mention of how the node is identified, what happens to connected links, or whether the compositor must be enabled. The output schema exists but doesn't compensate for the missing behavioral and parameter semantics.

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 only says 'Remove a compositor node' without explaining what the 'node' parameter should contain (e.g., node name, ID, or path). The schema only defines it as a string, so the description adds no semantic value beyond the parameter name. The agent must infer the expected format from context.

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 'Remove a compositor node' clearly states the verb (remove) and resource (compositor node), distinguishing it from sibling tools like create_comp_node, connect_comp_nodes, and set_comp_node_input. It is concise and unambiguous, though it doesn't explicitly mention the node tree context or that it operates on the current compositor node tree.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites like enabling the compositor, whether the node must exist, or how it relates to other node operations. The sibling list includes many node-related tools, but the description gives no context for choosing this one.

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 only states the removal outcome and does not mention destructive side effects, irreversibility, or whether connected geometry node links are also affected.

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

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

The description is a single sentence with no filler or repetition. It front-loads the action and target, making it easy to parse quickly.

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

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

For a destructive tool with no annotations and three required parameters, the description is too sparse. It lacks parameter details, prerequisites, and side-effect disclosure, even though an output schema exists for 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%, so the description must compensate by explaining the parameters, but it does not. The parameter names 'object,' 'modifier,' and 'node' give partial hints, but the description does not clarify what type of modifier is expected or how the node is identified.

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

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

The description uses a specific verb ('Remove') and identifies the exact resource ('a node') within the scoped context of 'a geometry node tree.' This distinguishes it from sibling tools like delete_shader_node and delete_comp_node, which operate on different node systems.

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

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

No guidance is provided about when to use this tool instead of alternatives such as delete_shader_node or delete_comp_node. There are also no mentions of prerequisites, such as the node existing in a geometry nodes modifier on the specified object.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Delete' without mentioning side effects, whether deletion is irreversible, how the index parameter affects which keyframe is removed, or how the tool behaves if no keyframe exists at the given frame. This matches a minimal mutation description that lacks important behavioral 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 a single, efficient sentence that front-loads the core action and scope. It avoids filler and redundant phrasing, achieving good conciseness, though it sacrifices detail that other dimensions require.

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?

Despite the presence of an output schema, the tool has four parameters with zero schema-level descriptions and no annotations, and the description explains only the 'frame' aspect. An agent would lack crucial information about how to specify the target object, data path, and keyframe index, making the description incomplete for correct invocation in non-trivial 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 for the undocumented parameters. It adds some meaning to 'frame' as the specific frame where deletion occurs, but it does not explain the required 'object' and 'data_path' parameters or the optional 'index' parameter, which likely disambiguates multiple keyframes at the same frame.

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

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

The description uses a clear verb ('Delete') and resource ('a keyframe') with a specific scope ('at a specific frame'), making the primary action obvious. It does not explicitly distinguish itself from siblings like clear_animation or set_keyframe, but the phrasing narrows the operation enough that an agent can infer it targets one keyframe rather than all animation.

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

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

There is no guidance about when to use this tool versus alternatives such as clear_animation (delete all keyframes), set_keyframe (create/update), or batch_delete. The description only states what the tool does, not when it should be selected, leaving the agent to infer usage from the tool name alone.

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

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

With destructiveHint already declared true, the description adds meaningful context beyond the annotation: the confirm requirement and the fact that it affects all object slots. This enriches the agent's understanding of the operation's side effects without contradicting the annotations.

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 short and front-loaded, with the core action first and the key requirement (confirm) and side effect (removes from slots) stated efficiently. No wasted words.

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 the essential destructive behavior and confirm requirement, but omits details such as error handling (e.g., what happens if the material does not exist) and the exact return value, even though an output schema exists. It is adequate but leaves some edge cases unaddressed.

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 only mentions the confirm parameter implicitly ('Confirm required') and says nothing about the 'name' parameter beyond its obvious purpose. Given zero schema coverage, this is a significant gap; the agent cannot infer parameter formats or constraints from the description.

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

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

The description states a clear verb-resource pair ('Delete a material') and adds a distinctive behavior ('Removes from all object slots') that separates it from sibling tools like remove_material. This is specific and 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 does not explicitly contrast with alternatives such as remove_material, but it does provide an important usage constraint ('Confirm required') that tells the agent a boolean must be set to true to proceed. This is helpful but not a full when-to-use versus when-not-to-use guide.

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 already declare destructiveHint=true, so the destructive nature is known. The description adds the confirmation requirement, which is useful behavioral context, but it does not clarify whether the delete is irreversible, what happens when confirm is false, or whether deletion cascades to children or associated data.

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

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

Two short sentences front-load the operation and target, with no filler. Every word contributes meaning.

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-parameter destructive tool with destructiveHint and an output schema, the description is nearly complete. The only notable gap is the ambiguous phrasing of 'Confirm required'—it does not explicitly state that confirm must be set to true to proceed.

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. 'By name' explains the name parameter, and 'Confirm required' gives the confirm parameter meaningful semantics beyond its default of false. It is minimal but does clarify both 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?

States a specific verb and resource: delete an object by name. This clearly distinguishes it from siblings like delete_collection and batch_delete by entity type and scope, and leaves no doubt about the operation.

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?

Implies the tool is for deleting a single object by name and requires confirmation, but it does not explicitly mention alternatives such as delete_collection or batch_delete, nor does it exclude cases where those should be used. The basic usage is inferable, but no explicit routing is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only the basic destructive action ('Remove a node') and does not disclose side effects such as breaking incoming/outgoing connections, whether removal is undoable, or whether the node must exist for the call to succeed.

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

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

The description is a single focused sentence with no filler. The action and target are front-loaded, and every word earns its place.

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

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

For a small two-parameter destructive operation, the description is minimally sufficient: an agent can infer the material and node parameters and what the tool accomplishes. However, it omits behavioral consequences like connection handling, which matters for a delete operation in a node graph, so it is 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%, so the description must compensate for missing parameter details. It does not explain what format 'material' and 'node' should take (names, IDs, paths, etc.) or how they are resolved. The parameter names are self-explanatory at a high level, but the description adds no semantic depth beyond the schema itself.

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

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

The description uses a specific verb ('Remove') and a clear resource ('a node from a material's node tree'), making the tool's function immediately obvious. It also implicitly distinguishes this from sibling tools like delete_geo_node or delete_comp_node by scoping to the material node tree.

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 one-liner implies the use case: call this when a node should be removed from a material's node tree. However, it gives no explicit guidance on when not to use it, nor does it mention related alternatives such as disconnect_shader_node for preserving links or simply unplugging the node.

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

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

With no annotations, the description carries the full burden of disclosing behavior. 'Disconnect' implies a mutation, but it does not describe side effects, whether disconnecting resets the input to a default, whether it is idempotent, what happens if the connection does not exist, or whether it affects other node connections.

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

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

The description is one short sentence with no filler or redundancy. It is front-loaded and easy to parse, though it is arguably too sparse for a tool with four required 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?

For a mutation tool with four required parameters and no annotations, the description is under-specified. It lacks context about prerequisites (e.g., a geometry nodes modifier must exist), how to identify the node and input, and whether an output schema describes a meaningful result. The agent would need to infer most operational details.

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 clarify the meaning of object, modifier, node, and input. It only mentions 'input on a geometry node,' leaving the other three parameters unexplained. It does not even state the expected format for identifying the input (e.g., name vs index).

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 action and resource: 'Disconnect an input on a geometry node.' It is not a tautology and gives enough information to identify the tool's domain (geometry nodes vs shader/compositor nodes). However, it does not explicitly differentiate from the sibling connect_geonodes beyond implying the opposite operation.

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

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

No guidance is provided about when to use this tool instead of connect_geonodes, set_geonode_input, or disconnect_shader_node. The intended usage is only implicit from the name and generic description, and no conditions or alternative routing are given.

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 burden of behavioral disclosure. It adds a minimal detail ('input socket') but does not state whether the operation is destructive, reversible, or if it affects other connections. The behavior is fairly obvious from the name, but the description does not elaborate on side effects or scope.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the core action efficiently, which is appropriate for a simple 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?

Despite the tool's simplicity, the description is incomplete. It does not clarify how to specify the 'input' parameter (by name or index), nor what the tool returns (even though an output schema exists). It also fails to mention that all three parameters are required, leaving the agent without enough information to use the tool reliably.

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 by explaining the parameters. It mentions none of them (material, node, input), leaving the agent to guess their meaning and format. The parameter names are somewhat self-explanatory, but the description adds no semantic value 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 states a clear verb ('Disconnect') and resource ('an input socket on a node'), which directly differentiates it from siblings like 'connect_shader_nodes' and 'set_node_input'. The tool name itself clarifies it operates on shader nodes, and the description adds the specificity of an input socket.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'connect_shader_nodes' or 'set_node_input'. There is no mention of prerequisites, scenarios, or exclusions, leaving the agent to infer the appropriate context from the tool name alone.

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

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

With no annotations, the description carries the behavioral burden, and it does state the core operation and return value. However, it does not disclose what happens when new_name is omitted, whether the new material is automatically assigned anywhere, or whether the original material is affected. For a simple duplication operation, this is minimally adequate but not richly transparent.

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