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

With no annotations, the description carries full behavioral disclosure burden. It mentions the return type but lacks details on prerequisites (e.g., annotation must exist), side effects, or error conditions.

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, includes structured Args and Returns sections, and front-loads the primary purpose without extraneous 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?

The description is fairly complete, covering purpose, parameters, and return value. However, it could mention that the annotation must exist before adding a layer, given the context of sibling tools.

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

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

Despite 0% schema coverage, the description adds clear parameter descriptions ('Name of the annotation data block', 'Name for the new layer'), compensating for the schema's lack of detail.

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

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

The description clearly states the action ('Add a layer to an annotation') and the resource, distinguishing it from sibling tools like add_annotation_stroke and remove_annotation_layer.

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

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

The description explains the role of layers but does not provide explicit guidance on when to use this tool versus alternatives, such as add_annotation_stroke.

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, so description carries burden. Discloses new stroke creation, lack of per-point strength/opacity, max 10000 points, pressure range, and return type. Lacks mention of appending behavior or error handling, but sufficient for basic understanding.

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?

Concise and well-structured: purpose statement, note, parameter list, return type. Each sentence serves a purpose, no fluff. Front-loaded with primary 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?

Covers parameters, return, and key behavioral notes. Lacks error conditions (e.g., missing layer or invalid points) and does not confirm append vs. overwrite behaviour. Output schema exists but not provided; still, description sufficient for typical use.

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

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

With 0% schema description coverage, description fully compensates by explaining each parameter: annotation_name (data block name), layer_name (target layer), points (XYZ list with example and limit), pressure (range). Adds essential meaning beyond 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?

Clearly states it adds a stroke to an annotation layer, creating a new stroke with points. Distinguishes from siblings like add_annotation_layer (layer) and set_annotation_stroke_property (modify).

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?

Implied usage from name and description, but no explicit when-to-use or alternatives guidance. Could mention when to use this vs. add_annotation_layer or set_annotation_stroke_property.

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?

Discloses automatic edit mode entry and return value format. No annotations exist, so description bears full burden; it provides key behavioral context beyond the action.

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

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

Opening sentence clearly states purpose. Args/Returns structure is efficient, though including default values inline adds slight verbosity.

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?

Covers all main aspects: action, parameters, automatic behavior, and return value. Could mention error cases (e.g., armature not found) but is adequate for typical use.

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

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

Adds meaning beyond schema: describes armature_name, bone_name, head/tail as XYZ positions, and parent_bone as optional. Compensates for 0% schema description coverage.

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

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

The description clearly states it adds a bone to an armature and automatically enters edit mode. This distinguishes it from other add_* tools (e.g., add_modifier, add_constraint) which operate on different entities.

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

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

The description implies usage for adding bones to armatures but lacks explicit guidance on when to use versus alternatives, prerequisites (e.g., armature must exist), or when not to use.

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

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

With no annotations, the description must carry behavioral context. It only mentions adding simulation, with no details on side effects, prerequisites (e.g., object must be a mesh), or potential failures. The return type is vague ('confirmation dict').

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?

Description is short and to the point: one sentence for purpose followed by parameter descriptions. No excess words, though structure could front-load the purpose more clearly.

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?

Tool performs a complex operation (cloth simulation) but lacks details on object requirements, behavior if conditions fail, or comprehensive return information. Output schema is present but not shown, and return description is minimal.

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 description compensates by naming parameters and providing brief explanations: object_name as mesh object, quality with range (1-80), and mass in kg. This adds meaning beyond the schema's type and title.

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 'Add a cloth physics simulation to an object', using a specific verb and resource. It distinguishes from sibling tools like add_fluid_sim and add_rigid_body.

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. Siblings include many simulation and physics-related tools, but the description offers no context for selection.

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

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

With no annotations, the description carries the full burden. It explains the default stops (black at 0.0, white at 1.0) and the bounds for position and color. It does not mention potential limits or side effects, but for a non-destructive add operation, the transparency is adequate.

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

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

The description is well-structured but slightly verbose with the fire and rust examples. However, these examples are illustrative and not wasteful. Parameters are clearly listed with their meanings, and the return type is specified.

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 and the presence of an output schema, the description covers all necessary aspects: purpose, parameter details, usage context, and return value. No gaps remain for the agent to infer.

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

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

Since schema description coverage is 0%, the description fully compensates by explaining all four parameters: material_name, node_name, position (range 0-1), and color (RGB or RGBA, components 0-1, RGBA gains alpha 1.0). This adds critical meaning beyond the bare schema.

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

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

The description clearly states the tool adds a colour stop to a ColorRamp node, uses specific verb 'Add', and distinguishes from sibling tools like remove_color_ramp_element and set_color_ramp_element by focusing on the addition action. Examples (fire, rust) reinforce 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?

The description provides clear context for when to use the tool (shaping gradients by adding stops) and gives practical examples. It does not explicitly mention when not to use or alternatives, but the purpose is clear enough that an agent can infer appropriate usage.

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

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

No annotations are provided, so the description should fully disclose behavioral traits. It does not mention side effects, required permissions, or failure modes. The return value is described, but the tool's impact on the scene is not clarified beyond creation.

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 moderately concise but includes a helpful list of constraint types. It front-loads the purpose and then details parameters. Minor redundancy in specifying 'empty string for object-level constraints' could be integrated more succinctly.

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 core functionality and return value (output schema exists). However, it omits error handling, prerequisites (e.g., object must exist), or behavioral details like whether constraints can be added multiple times. For a tool with 4 parameters and no annotations, more context would improve usability.

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?

Despite 0% schema coverage, the description thoroughly explains each parameter: object_name, bone_name, constraint_type with a list of valid values, and properties as an optional dict. This adds significant meaning beyond the schema property names.

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

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

The description uses a specific verb ('Add') and identifies the resource ('constraint to an object or bone'). It lists constraint types and distinguishes between object-level and bone constraints, setting it apart from siblings like add_modifier or add_bone.

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

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

The description explains when to use object_name vs bone_name (e.g., 'Name of the object (armature for bone constraints)') and notes the bone_name default. However, it does not explicitly state when not to use this tool or mention 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?

With no annotations provided, the description fully shoulders the burden of behavioral disclosure. It notes the return value (dict with curve name and point count) but fails to disclose crucial traits such as validation of location, effect on existing points, undo behavior, or permission requirements.

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

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

The description is a single paragraph with clear 'Args:' and 'Returns:' sections. It is concise with no superfluous words, though a more structured format (e.g., bullet points) could enhance readability.

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

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

Given that an output schema exists (context signals), the description need not detail return values. However, it omits prerequisites (curve must exist prior to calling) and potential side effects (e.g., modification of the curve object). This leaves gaps for an AI agent to safely invoke the tool.

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

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

Schema description coverage is 0%, but the description adds meaningful context: location is described as '3D location for the new point as (x, y, z)' and handle_type lists the options (AUTO, VECTOR, ALIGNED, FREE). This compensates for the barren schema, though defaults from the schema are not reiterated.

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 'Add a control point to an existing curve,' specifying the verb 'add' and the resource 'control point' on a curve. This distinguishes it from sibling tools like 'create_curve' (create new) and 'set_curve_property' (modify existing properties).

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

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

The description provides parameter details but lacks explicit guidance on when to use this tool versus alternatives. For example, it does not mention prerequisites (curve must exist) or when not to use (e.g., for modifying existing points, use set_handle_type). Usage is implied but not articulated.

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 provided, so the description bears full burden. It does not disclose behavioral traits like whether it replaces existing fluid sim, the nature of side effects, or required permissions. The return value is vaguely described as a confirmation dict.

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

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

The description is very concise: one sentence upfront, followed by a bulleted parameter list. No wasted words; every sentence adds value. Front-loads the main action.

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

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

Given three parameters and no annotations, the description covers parameter semantics and return type. However, it lacks details on prerequisites (e.g., object must be a mesh) and expected results. The presence of an output schema reduces burden, but the confirmation dict is not elaborated.

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

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

Schema description coverage is 0%, but the description compensates by explaining all three parameters: object_name as the object name, type with enumerated fluid roles, and domain_type with optional logic. It clarifies conditional use of domain_type, adding meaning beyond the schema's bare defaults.

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 adds a fluid physics simulation to an object. The verb 'add' and resource 'fluid physics simulation to an object' are specific. It distinguishes from siblings like add_cloth_sim or add_particle_system by targeting fluid simulation.

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

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

No guidance on when to use this tool versus alternatives. No scenarios or prerequisites are mentioned, such as what object types are valid or effects of reapplication.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states the action (add) and return value but does not mention side effects, permissions, or undo behavior. Adequate but not thorough.

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 with a clear header, Args, and Returns sections. Every sentence adds value with no 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 tool has a simple function (add a node) and an output schema. The description covers the return value (dict with name and type) and the parameters adequately, making it complete for this context.

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

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

The schema coverage is 0%, so the description compensates by explaining each parameter: modifier_name finds the node group, node_type provides examples, location specifies XY position. Good detail for selecting and invoking.

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

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

The description clearly states the verb 'Add' and the resource 'a node to a geometry nodes modifier's node group'. It distinguishes from sibling tools like add_shader_node and add_texture_node by specifying geometry nodes specifically.

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

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

The description implies usage for geometry nodes modifiers but does not explicitly state when to use this tool over alternatives or any prerequisites. No exclusion criteria 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?

No annotations provided. The description states 'non-destructive workflow' and returns a confirmation dict, but does not detail side effects, prerequisites, or what happens on failure. It offers basic behavioral transparency but lacks depth.

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 well-structured: a one-line summary, a TIP paragraph, parameter descriptions, and return info. Every sentence adds value, and the main purpose is front-loaded.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description covers key aspects: core function, parameters, return type, and usage guidance for a specific case. It could mention error handling or object existence prerequisites, but overall sufficient.

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

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

Schema coverage is 0%, so description must add meaning. It describes object_name, modifier_type (with list of valid types), and name (optional custom name). This adds value beyond the schema, though it could specify formatting constraints for modifier_type.

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

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

The description clearly states 'Add a modifier to a mesh object (non-destructive workflow).' It specifies the action (add), resource (modifier to mesh object), and differentiates from sibling tools like booltool_auto_* which handle boolean modifiers immediately.

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 includes a TIP that guides when to use add_modifier vs booltool_auto_* for BOOLEAN type, explicitly stating 'Only use add_modifier with BOOLEAN when you want a non-destructive modifier stack.' This provides clear context and 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?

Describes the tool's effect (adds multiresolution modifier for sculpting) but lacks disclosure of behavioral traits such as increased vertex count, potential performance impact, or that the operation is destructive. No annotations provided to offset this.

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?

Concise docstring with front-loaded purpose. Parameter section is succinct but adds little beyond schema. No wasted sentences, though could be more 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?

Missing usage context (required mode, mesh requirement) and does not guide selection among sibling modifier tools. Output schema exists but return values are not elaborated; description is minimal for a simple tool.

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

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

Schema coverage is 0%, so description must add meaning. The description provides range for 'levels' (1-6) but repeats schema info for 'object_name'. Fails to mention default value (2) or any validation beyond range.

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?

Clearly states the action (Add), resource (Multiresolution modifier), and purpose (for sculpting detail). The verb+resource combination distinguishes it from generic siblings like 'add_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 guidance on when to use this tool versus alternatives like 'add_modifier', or what prerequisites exist (e.g., must be in object mode, mesh must be selected). Missing exclusions or 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 burden. It discloses the mutation (adds a system), return type, and some constraints (max count, emission source options). But it omits behavioral details like whether it overwrites existing systems, required object mode, or failure conditions.

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 with no extraneous words. It uses a clear list format for parameters and a separate line for returns, making it easy to scan.

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

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

Given the tool's complexity (4 parameters, no output schema), the description covers key aspects: add particle system to mesh, parameter explanations, return type. It lacks prerequisites (e.g., object mode) and does not clarify behavior if the object already has a particle system.

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 define parameters. It explains object_name as 'mesh object', count with max 1000000, lifetime in frames, and emit_from with allowed values (VERT, FACE, VOLUME). This adds significant meaning beyond schema titles and defaults.

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 ('particle system to an object'), specifying the target object type ('mesh object'). It distinctly differentiates from siblings like delete_particle_system and set_particle_rendering.

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

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

The description provides clear context on when to use the tool (adding a particle system) and includes constraints like maximum count and emission source types. However, it does not explicitly state when not to use alternatives such as modification 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 partially covers behavior by explaining ACTIVE vs PASSIVE types and parameter ranges, but fails to mention side effects like replacing existing physics, object type requirements, or performance implications.

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

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

The description is well-structured with Args and Returns sections, each sentence is informative, and there is no redundant information. Could be slightly more concise by omitting the Return line if output schema is provided, but still effective.

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

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

While the description covers parameters and return intent, it lacks mention of prerequisites (e.g., object must exist and be selected), potential errors, or interaction with other physics systems. The return value is only vaguely described as a 'confirmation dict'.

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

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

Schema description coverage is 0%, but the description compensates by explaining each parameter with purpose, units (kg, coefficient), and valid range (0.0-1.0 for friction and restitution), adding significant 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 clearly states the verb 'Add' and the resource 'rigid body physics simulation to an object', making it distinct from sibling tools like add_cloth_sim or add_fluid_sim.

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 over alternatives; the description does not mention prerequisites or scenarios, leaving the agent to infer usage from the name alone.

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

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

The description explains the function and return value but does not disclose potential side effects, error conditions, or prerequisites (e.g., material must exist). With no annotations, the burden is on the description, and it partially meets it.

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

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

The description is a concise docstring with clear purpose, Args, and Returns sections. It is front-loaded and every sentence adds value.

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

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

The description covers input parameters and return value, and there is an output schema. However, it does not mention prerequisites or connection to sibling tools, leaving minor 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?

Schema coverage is 0%, but the description fully explains each parameter in the Args section, including type, default, and an example for node_type. This adds substantial meaning beyond the schema.

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

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

The description clearly states 'Add a shader node to a material's node tree,' specifying the verb (add), resource (shader node), and target (material's node tree). This distinguishes it from siblings like add_geometry_node or add_texture_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 does not provide guidance on when to use this tool versus alternatives like connect_shader_nodes or set_material_property. It lacks explicit context for usage scenarios or prerequisites.

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 full burden. It states that the node is added and connected, but does not disclose whether existing nodes are overwritten, if the material must already exist, or other side effects. Missing important behavioral context 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 highly concise: one sentence for the action, followed by a clear Args list. No redundant information, front-loaded with purpose.

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

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

Given tool simplicity and presence of output schema, the description covers the main points but lacks mention of prerequisites (e.g., material must exist) and behavior if node already exists. Adequate but not fully complete.

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

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

The description adds specific meaning to parameters beyond the schema: material_name is name of material, image_path must be absolute and exist on disk, label defaults to 'Image Texture'. Schema coverage is 0%, so description compensates well.

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

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

The description clearly states the verb 'Add' and the resource 'image texture node', and specifies it connects to Principled BSDF Base Color. This distinguishes it from generic siblings like 'add_shader_node' and provides a specific action.

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

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

The description implies usage when you want to add an image texture node, but it does not explicitly state when to use this tool versus alternatives (e.g., add_shader_node for other node types). No guidance on prerequisites or when not to use.

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

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

With no annotations, the description fully bears the burden. It lists the checks performed and mentions return details (counts, sample indices capped at 50). It does not explicitly state it is read-only or describe side effects, but the analysis nature is clear.

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

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

The description is well-structured with an intro, list of checks, return info, and Args. It is concise but could be slightly more streamlined 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?

Given the tool's simplicity (one parameter, output schema exists), the description adequately covers what it does and returns. It does not mention error conditions or performance, but overall is complete for this tool.

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

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

The only parameter, object_name, is explained in the Args section as 'Name of the mesh object to analyze.' This adds clear meaning beyond the schema's title and type, compensating for 0% schema description coverage.

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

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

The description clearly states it analyzes mesh topology quality and returns a structured defect report, listing specific defect types (non-manifold edges, loose vertices, etc.). This is specific and distinguishes it from sibling tools.

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

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

The description implies usage for mesh quality checking but does not explicitly state when to use this tool versus alternatives or provide any exclusions. No alternatives are mentioned.

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

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

With no annotations, the description must convey behavioral traits. It mentions 'making its effect permanent', implying a destructive or irreversible action, but does not clarify side effects like whether the modifier is removed after application or if the original object data is altered permanently.

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 efficiently conveys the core action, including a note on return type. However, it could be more concise by removing the docstring format, but overall it is well-structured with 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 tool has an output schema, but the description does not provide enough context about error conditions, prerequisites (e.g., modifier and object must exist), or what happens if the modifier is already applied. The minimal description leaves many gaps for agent understanding.

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

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

The input schema has 2 string parameters with no descriptions (0% coverage). The description only restates the parameter names without adding any meaning, constraints, or examples. It fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the verb 'apply' and the resource 'modifier to an object' with the specific outcome 'making its effect permanent'. It distinguishes from sibling tools like 'add_modifier' which adds a modifier without applying it permanently.

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 'add_modifier' or 'remove_modifier'. There is no mention of prerequisites or conditions for applying a modifier.

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

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

No annotations are provided, so the description must bear the full burden. It only states that transforms are applied/frozen, without disclosing side effects like irreversibility, impact on child objects, constraints, or animation data. 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 concise: a one-line summary followed by a clean parameter list. Every sentence is informative, with no redundancy or filler. It is well-structured 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?

The description explains the core operation and parameters, and the output schema is noted. However, it lacks essential operational context such as required object mode, effect on animation, undo capability, and prerequisites. This makes it adequate but not fully complete for safe and effective use.

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

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

Schema description coverage is 0%, requiring the description to compensate. The docstring clearly explains each parameter's purpose (e.g., 'location: Apply location transform.') and defaults. This adds meaningful context beyond schema titles and default 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 'Apply (freeze) transforms on an object, making current transforms the new basis.' It uses a specific verb ('apply/freeze') and resource ('object transforms'), distinguishing it from sibling tools like 'set_location' or '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?

The description provides no guidance on when to use this tool vs alternatives such as 'set_location' or 'apply_modifier'. It does not mention prerequisites, modes, or typical use cases, leaving the agent without context for proper invocation.

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

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

No annotations are provided, so the description must disclose behavior. It only mentions returning a confirmation dict, but does not clarify whether the material replaces existing ones, adds to a slot, or modifies the object's material list.

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, using a standard docstring format. However, for a simple tool it is acceptable but not highly 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?

Given the presence of an output schema (inferred from context signals), the description could rely on it, but still lacks details on prerequisites, side effects, or error scenarios. Many sibling tools exist but no comparative context is provided.

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 phrasing ('Name of the target object', 'Name of the material to assign') which is already implied by the schema titles. Without compensation, the description fails to enrich parameter understanding.

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 ('assign') and identifies both resource ('material') and target ('object'), clearly distinguishing it from sibling tools like 'create_material' or 'set_material_color'.

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 prerequisites, when to use vs alternatives, or conditions that might cause failure (e.g., material or object does not exist). The description simply states the action.

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

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

With no annotations provided, the description must disclose behavioral traits. It does not mention if baking is destructive, whether it modifies the object permanently, or if prior physics setup is required. The return 'Confirmation dict' is vague.

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 main action. Parameter descriptions follow a clear format. It could be more concise but is 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?

For a baking tool, the description lacks context about prerequisites (e.g., object must have a physics simulation), effects (e.g., creates keyframes), and error states. The output schema exists but the description doesn't leverage it. Overall, minimally adequate.

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 adds meaning. It explains object_name as 'Name of the object with physics' and physics_type with default behavior ('if empty, bakes all physics'), providing context beyond the schema titles.

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 'Bake a physics simulation for an object', which is a specific verb+resource. It distinguishes from sibling tools like set_physics_property or add_rigid_body by focusing on the bake action.

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

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

No guidance is given on when to use this tool versus alternatives, nor any prerequisites or exclusions. The description solely states what it does without 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?

Discloses that it bevels all edges and returns a confirmation dict. Without annotations, it provides core behavior but lacks details about failure conditions or 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?

Very concise: one-line action followed by a bulleted list of parameters. No unnecessary text.

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

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

Covers parameters and return value. However, missing context such as whether the object must be in edit mode or if it works on multiple objects. Generally adequate for a simple tool.

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

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

Adds meaning beyond schema by describing each parameter and providing a range for 'segments' (1-100). Schema coverage is 0%, so the description compensates well.

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

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

The description clearly states the tool's action ('Bevel all edges of a mesh') and the resource (edges of a mesh), which is distinct from sibling tools like subdivide_mesh or dissolve_edges.

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

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

No guidance on when to use this tool vs alternatives, nor any prerequisites or context (e.g., requires edit mode or existing mesh).

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?

Discloses non-destructive nature and that auto tools handle cleanup, but does not detail modifier stack behavior or selection implications. No annotations, so description carries burden; still informative.

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 well-structured paragraphs: purpose and usage note first, then parameter list. No redundant sentences, front-loaded with key info.

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?

Covers purpose, when to use, parameters, and return type. Output schema exists, so return details are sufficient. Complete for a tool with 3 params and no annotations.

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 no descriptions (0% coverage). Description adds full semantics for all 3 parameters: object_name, target_name, operation with valid values. Adds significant meaning beyond 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?

Clearly states it performs a boolean operation using a modifier, specifying verb and resource. Differentiates from sibling booltool_auto_* tools by noting they handle destructive booleans.

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?

Explicitly says when to use this tool (non-destructive modifier workflow) and when to use alternatives (destructive booleans: use booltool_auto_* tools). Provides clear 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?

Discloses key behaviors: the target object is removed after the operation, and it falls back to native boolean modifier if the Bool Tool extension is not installed, with a warning in the response. This adds context beyond the operation itself. However, it does not mention potential prerequisites or constraints.

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 well-structured. It leads with the purpose, then explains fallback behavior, followed by parameter and return descriptions. Every sentence adds value without redundancy.

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

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

Given that an output schema exists, the description adequately summarizes the return value. It covers the operation, fallback, and parameter meanings. However, it could mention prerequisites (e.g., objects must be mesh) or potential side effects for full completeness.

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

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

The description explains each parameter in the Args section: object_name is the object to cut from, target_name is the cutter object that will be removed. This adds meaning beyond the schema, which only has titles and types. The schema description coverage is 0%, so the description compensates well.

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

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

Clearly states it performs a boolean difference by subtracting the target object from the main object. The name and description make the purpose evident, but it does not explicitly differentiate from sibling tools like booltool_auto_union or boolean_operation, which could cause confusion.

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. The description implies it is for subtraction, but does not state when not to use it or mention alternatives like booltool_auto_intersect or the generic boolean_operation.

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?

Without annotations, the description fully explains the operation: the target object is removed, and there is a fallback mechanism (Bool Tool extension vs native boolean modifier) with a warning in the response. This covers key behavioral traits beyond the schema.

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

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

The description is very concise, with a front-loaded purpose statement and structured bullet points for arguments and returns. Every sentence adds value without redundancy.

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

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

With an output schema present and the description detailing the return (confirmation dict with warning), the tool is well described. Minor omissions like prerequisites or error conditions are not critical given the 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?

The schema has 0% description coverage, but the description provides clear docstrings for both parameters: object_name is the main object, target_name is the intersecting object (and will be removed). This adds significant meaning beyond the parameter names.

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

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

The description clearly states 'keep only the overlapping volume of two objects', providing a specific verb (intersect) and resource (two objects). The tool name and description distinguish it from siblings like booltool_auto_difference and booltool_auto_union.

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 its use for intersection operations and notes that the target object is removed, which serves as a caution. However, it does not explicitly state when to use it over alternatives, but the context of sibling tools makes it clear.

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

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

With no annotations, the description discloses key behaviors: target object is removed, fallback to native boolean with warning. This provides necessary transparency about destructive effects and dependency, though details like reversibility or material handling are absent.

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

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

The description is efficiently structured with a title line, explanation, args, and returns. Every sentence adds value without redundancy, making it quick to parse.

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

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

Given the tool's simplicity (2 parameters, no output schema needed due to its presence), the description covers purpose, parameters, behavior, fallback, and return value. It is complete for effective agent use.

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

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

Schema description coverage is 0%, but the description compensates by defining both parameters: object_name as the object to slice and target_name as the cutter (noting it will be removed). This adds crucial meaning beyond the schema titles.

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 'split' and the resource 'main object using the target as a cutter', and distinguishes itself from sibling boolean operations (difference, intersect, union) by specifying it creates two pieces from the intersection.

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

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

The description explains the tool's behavior (cutter removed, two pieces created) and fallback mechanism, but does not explicitly contrast with alternatives like booltool_auto_difference or boolean_operation. Usage context is clear but not directly compared to siblings.

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

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

With no annotations, the description fully discloses that the target object is consumed (destructive), the fallback behavior to native boolean modifier if Bool Tool is missing, and that a warning may be included in the response.

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

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

The description is well-structured with separate sections for usage, args, and returns, and each sentence is informative. It is concise but could be slightly tighter 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?

Given the tool's simplicity (2 string params, output schema exists), the description covers purpose, behavior, parameters, return value, and fallback mechanism, making it complete for an agent to use correctly.

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

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

The description explains both parameters: object_name is the main object to keep, target_name is the object to merge in, adding significant meaning beyond the bare schema titles. With 0% schema coverage, the description provides all parameter semantics.

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

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

The description clearly states it performs an auto boolean union to merge two mesh objects into one, specifying the target is consumed. This distinguishes it from sibling booltool variants (difference, intersect, slice) and other mesh operations.

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

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

It explains the tool is useful for permanently joining meshes so parts don't float away, providing a clear use case. However, it does not explicitly contrast with alternatives like 'boolean_operation' or 'join_objects'.

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 full burden. It discloses that faces are created, but lacks details on mutation, side effects, or error conditions. The prerequisite is mentioned, but not all behavioral traits are covered.

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

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

The description is well-structured with a short summary followed by a docstring-style breakdown. It is informative without being overly verbose, though could be slightly more concise.

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

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

Given 3 parameters, no annotations, and an output schema (implied by Return description), the description covers prerequisites, parameter ranges, and return value. Use cases are listed. It lacks error conditions or detailed postconditions but is largely complete for this tool.

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

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

Schema coverage is 0%, so description must explain parameters. It does so effectively: object_name (mesh object with selected loops), segments (range 1-1000), profile_shape_factor (range -1.0 to 1.0, with meaning of values). This adds significant 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 clearly states the tool's purpose: 'Bridge two edge loops to create connecting geometry.' It uses specific verbs ('bridge') and resources ('edge loops'), and distinguishes itself from sibling tools (e.g., grid_fill, fill_faces) by its unique 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?

The description provides explicit prerequisite: 'Select two edge loops on a mesh before calling this.' It also lists use cases: 'connecting separate mesh parts, creating holes between surfaces, or building tube-like geometry.' However, it does not mention when not to use or suggest alternative 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 provides some behavioral context: it explains the conditional output (file or base64) and default dimensions. However, it does not disclose whether the render is synchronous, if it requires the UI, 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 concise and front-loaded with the main action, followed by clear parameter descriptions. It avoids fluff, though it could be more structured (e.g., bullet points) for readability.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description covers the core functionality and return value. It is largely complete for a rendering tool, though it omits image format and edge cases.

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

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

The input schema has 0% description coverage, but the description explains all three parameters: filepath (behavior when empty), width and height (defaults). This adds meaning beyond the schema's titles and defaults.

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 renders the viewport to a file or base64, specifying the resource and verb. However, it does not explicitly differentiate from the sibling 'get_viewport_screenshot', which likely has similar functionality.

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 (e.g., get_viewport_screenshot). There are no prerequisites, when-not-to-use, or context-specific instructions, leaving the agent without usage clarity.

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 effect (remove all animation data) and confirms a return value, but does not specify whether this deletes keyframes, drivers, or actions, nor if the operation is reversible. The description is adequate but lacks depth for a destructive action.

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

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

The description is very short and front-loaded with the purpose. It efficiently covers the argument and return value in two lines. However, for a one-parameter tool, it could be slightly more structured (e.g., separating args and returns clearly), but overall it is concise and to the point.

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 incomplete. It omits error scenarios, the exact scope of animation data cleared (e.g., f-curves vs. drivers), and the structure of the confirmation dict. For a destructive operation, more context on what is removed and any side effects 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?

Schema description coverage is 0%, yet the description adds no meaning beyond the schema: 'object_name: Name of the object.' is essentially a tautology of the parameter title. It does not clarify naming conventions, format, or source (e.g., Blender object name). This fails to compensate for the schema's lack of documentation.

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

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

The description uses the specific verb 'remove' and clearly states the resource 'all animation data from an object'. This distinguishes it from sibling tools that deal with individual keyframes or animation paths, such as delete_keyframe or create_animation_path.

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

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

The description provides no guidance on when to use this tool versus alternatives like delete_keyframe for selective removal. It does not mention prerequisites (e.g., object must have animation) or when not to use it, leaving the agent to infer usage from the purpose 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, description must disclose effects; it only says 'connect two nodes' without detailing constraints (socket compatibility, overwriting existing connections, permanent modification).

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 plus clean Args list; main purpose stated upfront, no redundant information.

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

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

Covers basic purpose and parameter definitions; lacks context on valid values, error handling, and behavioral expectations despite having an output schema.

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 clarifies that from_socket/to_socket are indices, but does not specify ranges or how to obtain them. Basic meaning added, but not rich.

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 clearly states the action ('connect two nodes'), the specific resource ('in a geometry nodes modifier's node group'), and distinguishes from siblings like add_geometry_node (which adds nodes) and get_node_tree (which retrieves the 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 on when to use versus alternatives, prerequisites (e.g., existing node group, modifier), or conditions under which connection is valid.

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 provided, so description carries full burden. It does not disclose whether existing connections are overwritten, socket compatibility checks, error handling, or side effects. The return value is vaguely 'Confirmation dict' without structure.

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 structured with a clear one-line summary and docstring arguments. However, the docstring is somewhat redundant with the initial sentence. Still, it is front-loaded and 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 5 required parameters and no schema descriptions, the description is too brief. It lacks information on error conditions, return value details, and prerequisites. The tool's complexity is not fully addressed.

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

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

Input schema has 0% description coverage. The docstring repeats parameter names (e.g., 'material_name: Name of the material.') but adds no meaningful detail about valid values, format, or constraints beyond the schema's title.

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 'Connect' and resource 'shader nodes in a material's node tree'. It distinguishes from siblings like 'add_shader_node' (adds nodes) and 'disconnect_shader_nodes' (disconnects).

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. Missing prerequisites such as nodes must exist, sockets must be compatible, or that the material must be created first.

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 available, so the description must convey behavioral traits. It does not disclose whether the conversion is destructive, if the original curve remains, or any side effects. The return description is vague ('Dict with the converted object name').

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

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

The description is very short and front-loaded with the main action. However, it omits critical usage and behavioral details, so it is not fully earning its place despite its 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 is a simple conversion with one parameter and an output schema, the description should cover what happens to the original object, selection state, or error conditions. It does not, leaving gaps for an AI 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 description for parameter 'curve_name' simply restates its name ('Name of the curve object to convert') with no additional meaning beyond the schema's title and type. With 0% schema coverage, it adds minimal value.

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 'Convert a curve object to a mesh object,' which is a specific verb+resource pair. It distinguishes the tool from siblings like 'convert_object' by specifying the exact conversion type. This is a precise purpose statement.

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 (e.g., 'convert_object') or what prerequisites are required (e.g., object must be a curve). The description lacks any contextual hints for appropriate use.

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 provided, so description must disclose behavioral traits. It states returns a confirmation dict but does not clarify whether the conversion alters the object in place or creates a new one, nor side effects (e.g., on materials or modifiers). Risk of unexpected 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?

Description uses a structured docstring with Args and Returns sections, clearly separating parameter description from return info. It is slightly verbose for a simple conversion, but all information is relevant and easy to parse.

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

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

Given the complexity of object conversion (handling materials, data, scene hierarchy), the description is minimal. It mentions return type but not failure conditions or object selection method. With an output schema present, the return info is adequate, but behavioral details are missing.

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

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

Schema has 0% description coverage, so description compensates by listing valid target types (MESH, CURVE, etc.) beyond the schema's default. However, the object_name parameter lacks additional context (e.g., how to reference an existing object). The target list is explicit and helpful.

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 clearly states 'Convert an object to a different type.' It specifies the action (convert), the resource (object), and the outcome (type change). The target parameter lists exact values (MESH, CURVE, etc.), making the tool's function distinct from siblings like 'convert_curve_to_mesh' which handle specific conversions.

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?

Description implies usage for general type conversion but provides no explicit guidance on when to prefer this over specific tools like 'convert_curve_to_mesh' or limitations (e.g., which object types are convertible). Lacks context on prerequisites 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?

With no annotations provided, the description must disclose behavioral traits. It only states the tool creates a Follow Path constraint and returns a confirmation dict. It does not reveal potential side effects (e.g., whether keyframes are added, if existing constraints are affected, or if the object's transform changes).

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 for purpose, followed by Args and Returns sections. No unnecessary words, and the main action is front-loaded. Every sentence earns its place.

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

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

Given the tool simplicity (2 params, no annotations) and that an output schema exists, the description is adequate but not thorough. It explains the core function but omits details like whether the path must be a curve type, or that the Follow Path constraint requires additional setup (e.g., keyframes for offset).

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

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

The description provides brief explanations for both parameters in the Args section, adding meaning beyond the property names. Schema description coverage is 0%, so the description partly compensates. However, it lacks details on type validation (e.g., must be existing objects) or formatting.

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 makes an object follow a path using a Follow Path constraint. It specifies the action (Make an object follow a path) and the resource (object and path curve). This is distinct from sibling tools like 'add_constraint' or 'insert_keyframe', which are more general.

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

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

The description does not provide any guidance on when to use this tool versus alternatives like 'add_constraint' or other animation tools. No prerequisites, exclusions, or context for use are mentioned.

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

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

With no annotations, the description carries full burden. It discloses that the name is optional and auto-generated, and clarifies annotations are not 3D objects. However, it does not mention side effects, permissions, or limitations (e.g., maximum count, persistence). Adequate for a simple creation tool but not fully transparent.

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

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

The description is concise with a clear structure: purpose sentence, explanatory paragraph, then Args/Returns sections. Every sentence adds value; no redundant or irrelevant information. Front-loaded and 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?

For a single-parameter tool with an output schema, the description sufficiently covers purpose, parameter, and return value. It lacks details on how the annotation interacts with other tools (e.g., layers, strokes) but that may be handled by sibling tool descriptions. Slightly incomplete but adequate.

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, so the description must compensate. It explains the 'name' parameter: optional, auto-generated if empty. This adds meaningful context beyond the schema, helping the agent understand the parameter's purpose and behavior.

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 an annotation data block, explains it as viewport overlays for marks/notes/guides, and distinguishes it from Grease Pencil objects. This is a specific verb+resource with good context and differentiation from sibling tools like add_annotation_layer.

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

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

The description explains what annotations are and how they differ from Grease Pencil, but it does not explicitly state when to use this tool versus alternatives like add_annotation_layer or add_annotation_stroke. No guidance on prerequisites or non-use cases. Adequate but lacks explicit differentiation.

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. The description only states creation without disclosing behavioral traits such as scene context, naming conflicts, or side effects. This is 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?

The description is concise with two sentences plus a structured Args/Returns block. Every sentence adds value, and the essential information is front-loaded.

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

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

For a simple creation tool with an output schema mentioned, the description is largely complete. It explains parameters and return format, but could mention the scene context or default object behavior.

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

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

The schema has 0% description coverage, but the tool description provides parameter explanations (name and location) with defaults and meanings, adding significant value beyond the schema's type-only definitions.

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 'Create a new armature object', using a specific verb and resource. It distinguishes from sibling create_ tools by naming the object type.

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 explicit when-to-use or when-not-to-use guidance. It implies usage only for creating armatures but lacks comparisons to alternatives like parent_mesh_to_armature.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It only states creation and parameter details, missing prerequisites, side effects (e.g., overwriting existing cameras), or return behavior beyond a confirmation dict.

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

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

The description is well-structured with Args and Returns sections. However, the Args list partially duplicates parameter names from the schema, making it slightly verbose. Still clear and organized.

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

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

Given 4 parameters and no annotations, the description covers parameter semantics and return type. Missing context includes which scene the camera is added to, potential errors, or updates to the active camera. Adequate but not comprehensive.

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

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

Schema coverage is 0%, but the description compensates fully by explaining each parameter with defaults and units (e.g., 'XYZ Euler rotation in radians', 'Focal length in mm'). This adds significant meaning beyond the empty schema.

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

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

The description clearly states 'Create a new camera in the scene' with a specific verb and resource. It distinguishes from sibling tools like create_light or create_object by specifying 'camera'.

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

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

The description implies usage for creating cameras but provides no explicit when-to-use or when-not-to-use guidance, nor does it compare with alternatives like set_camera_property.

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

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

With no annotations provided, the description must carry the full burden. It states the tool creates a collection and optionally nests it, but does not disclose potential side effects (e.g., behavior if parent doesn't exist) or permission requirements. Minimal but not misleading.

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, with a one-sentence summary followed by structured Args and Returns sections. Every part earns its place, no superfluous text.

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

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

Given the tool's simplicity, the description covers creation, nesting, parameters, and return value. The output schema is present, so return format is handled. Complete for an agent to use effectively.

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?

Both parameters are explained: 'name' is the new collection's name, 'parent' is optional and defaults to root. This adds meaning beyond the schema, which only has types and defaults. Schema coverage is 0%, so description compensates well.

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

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

The description clearly states 'Create a new collection, optionally nested under a parent collection.' It identifies the specific action (create) and resource (collection), and distinguishes from siblings like 'delete_collection' or 'move_to_collection'.

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

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

The description explains the optional nesting feature, providing clear context for when to use this tool. However, it does not explicitly mention when not to use it or name alternatives like 'move_to_collection' for existing collections.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It only says 'Create a new curve object' without explaining side effects (e.g., object is added to the active collection), permissions needed, or whether it can overwrite existing objects.

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 four sentences with no fluff: one main sentence, args listed concisely, and a returns line. It front-loads the core action and efficiently conveys parameter 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?

While the description covers the basic purpose and parameters, it lacks context such as where the curve is created (e.g., active scene/collection) and does not mention the default type (BEZIER). The presence of an output schema is noted but not detailed in the description. With no annotations, more behavioral context would improve completeness.

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

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

The input schema has 0% description coverage, but the tool description provides meaningful explanations for all three parameters: type (with enum list), name (optional), and location (3D coordinates). This adds significant value beyond the bare schema titles and defaults.

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 'Create a new curve object' and enumerates the supported curve types (BEZIER, NURBS, or PATH). This differentiates it from sibling tools like add_curve_point (which modifies existing curves) and create_object (generic object 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 implicitly sets usage context by listing arguments and return type, but it does not explicitly state when to prefer this over alternatives (e.g., create_object) nor provide exclusion criteria (e.g., prerequisites like having an active scene).

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

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

With no annotations, the description carries full behavioral burden but only states the basic action and return value. It does not disclose potential side effects (e.g., creating a new node tree), failure conditions (e.g., object not found), or whether it replaces an existing modifier.

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, using a one-sentence purpose and clear parameter explanations. No unnecessary information.

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

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

Given the tool's simplicity (2 params, no annotations, includes return description), the description covers the core functionality and param meanings adequately. However, it lacks mention of prerequisites like object existence.

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 explains both parameters (object_name and name) with their purposes and default values, adding value beyond the schema which has 0% coverage. It compensates well for the missing schema descriptions.

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

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

The description clearly states 'Create a Geometry Nodes modifier on an object', specifying the verb and resource, which effectively distinguishes it from siblings like add_modifier (generic) and add_geometry_node (adds node to 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, such as add_geometry_node for adding nodes to an existing tree, or set_geometry_node_input for modifying inputs. Neither context nor exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool creates a light and returns a confirmation, but does not mention side effects like overwriting existing lights or required scene 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 well-structured with clear sections (Args, Returns) and front-loaded purpose statement. Slightly verbose but effective.

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

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

While the description covers purpose, parameters, and return, it lacks details like coordinate system for location, color range, and energy unit. Given the output schema exists, the return description is adequate.

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 fully compensates by listing each parameter, its type, default values, and format (e.g., 'type: Light type. One of: POINT, SUN, SPOT, AREA'). This adds crucial information beyond the bare schema.

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

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

The description clearly states the action ('Create a new light in the scene') and identifies the resource (a light). It distinguishes from sibling tools like 'create_light_rig' by specifying it creates a single light, not a rig.

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_light_property' or 'create_light_rig'. The context of use is implied but not clarified.

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?

Describes basic behavior (creates multiple lights, intensity, target) but lacks specifics on side effects, default placement, or behavior when target is invalid. No annotations to offset.

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 plus parameter list and return value description. Front-loaded, no redundancy, every sentence adds value.

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

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

Covers key aspects: creation of multiple lights, intensity, targeting. Lacks details on precise rig layout or return schema, but adequate for a straightforward tool.

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

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

With 0% schema description coverage, the description adds meaning by listing allowed values for type and explaining target and intensity. Could be more precise about 'point at' behavior.

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?

Clearly states it creates a pre-built lighting rig with multiple lights, distinguishing it from singular light creation tools like create_light. The description specifies common setups and lists types.

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 usage for standard lighting setups via the rig types, but does not explicitly state when or when not to use it, nor compare with alternatives like create_light or set_light_property.

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

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

The description only states it creates a material and returns a confirmation dict, but does not disclose what happens if the material name already exists, if it requires an active object, or any side effects. Since annotations are absent, the description should provide more 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 concise with a clear purpose sentence followed by a structured Args/Returns section. No unnecessary words, though the Args section is redundant with the schema.

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

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

Despite having an output schema, the description lacks completeness for a creation tool. It does not mention duplicate handling, prerequisites, or impact on the scene, leaving significant gaps for an agent to use 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?

With 0% schema description coverage, the description adds minimal value beyond the parameter name: 'name: Name for the new material.' It does not provide constraints, format, or examples.

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 'Create a new material with a Principled BSDF shader node', providing a specific verb and resource, and distinguishes it from siblings like 'create_principled_material' by specifying the shader node type.

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 vs alternatives like 'assign_material' or 'create_principled_material'. There are no prerequisites or context for when this tool is appropriate.

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

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

No annotations are provided, so the description carries full burden. It describes the creation action and return value, but lacks details on side effects (e.g., selection, collection placement, naming conflict behavior). It is adequate but not exhaustive.

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

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

The description is well-structured as a docstring with clear sections for args and returns. It is appropriately sized and front-loaded with the main purpose. Every sentence is relevant, though minor redundancy in listing types could be trimmed.

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

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

Given 5 parameters, no annotations, and an output schema, the description covers the parameters and return value well. It could mention that the object is added to the active collection or scene, but overall it provides sufficient context for an AI agent to use the tool correctly.

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

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

Schema coverage is 0%, meaning the schema provides no descriptions. The description adds full parameter semantics: explains each parameter's purpose, defaults, and constraints (e.g., rotation in radians, scale defaults to (1,1,1)). This adds significant value beyond the raw schema.

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

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

The description clearly states 'Create a primitive object in the scene' and lists specific primitive types, which distinguishes it from sibling tools like create_camera or create_light. However, it does not explicitly contrast with other creation tools, so it is very clear but not perfectly differentiated.

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. The description implies it is for primitive objects, but given many sibling creation tools (e.g., create_camera, create_curve), it should provide more explicit when-to-use instructions.

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 explains the tool creates a prism with specified parameters and returns object info, but doesn't disclose side effects (e.g., whether it modifies existing objects) or permissions. Adequate but not exhaustive.

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 well-structured, with clear sections for args and returns. Every sentence serves a purpose, including practical examples. 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?

Given the tool's 7 parameters and the presence of an output schema, the description covers the core functionality, parameter meanings, and return value. It lacks error conditions or constraints beyond ranges, but it is sufficiently complete for typical use.

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

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

Schema description coverage is 0%, but the description compensates by explaining each parameter: sides (range 3-64), radius (>0), depth (>0), name (optional), location (XYZ), rotation (XYZ radians), scale (XYZ). This adds meaning beyond the raw schema.

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

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

The description clearly states 'Create an N-sided regular prism' and gives concrete examples like hex sockets and octagonal columns. It distinguishes from round cylinders, making the tool's purpose very 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 provides explicit usage scenarios (e.g., 'for a hex socket cutter on an M3 button-head screw, use sides=6') and contrasts with round cylinders. However, it does not explicitly exclude alternative tools or describe when not to use it, leaving room for improvement.

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. It discloses all parameters, defaults, and ranges, and states the return format. However, it does not mention side effects (e.g., whether it replaces an existing material, whether it is added to a specific object, or if it requires an active object). Basic transparency is present but missing behavioral context beyond the parameters.

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

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

The description is structured as a concise docstring with first-line summary, Args section, and Returns section. While the Args list repeats parameter information already in the schema, it is justified given 0% schema coverage. The first sentence effectively front-loads the purpose. Minor redundancy with schema titles is acceptable.

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 10 parameters, no annotations, but an output schema, the description explains all parameters and return format. However, it omits important context such as whether the material is automatically assigned to an object, whether it replaces existing materials, or if there are prerequisites like an active mesh object. This leaves the agent needing to infer missing usage requirements.

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 systematically lists each parameter with default values, ranges, and semantic explanations (e.g., 'metallic: Metallic value 0.0-1.0', 'transmission: Transmission weight'). This adds meaning beyond the schema titles and types, though could be slightly more explicit about the color list format (e.g., RGBA values between 0 and 1).

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

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

The description clearly states 'Create a fully configured Principled BSDF material in one call,' using a specific verb (create) and resource (Principled BSDF material). Among sibling tools like 'create_material', this distinguishes itself by specifying the shader model and the 'fully configured' aspect.

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

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

The description implies usage for creating a Principled BSDF material but does not explicitly state when to use this tool versus alternatives like 'create_material' or 'assign_material'. No when-not-to-use guidance or context about prerequisites (e.g., needing an active object with a material slot) 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?

Despite no annotations, the description fully discloses the created graph, the return value (including ignored_params), and connectivity behavior. It explains which parameters affect which patterns and provides practical examples.

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

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

The description is well-structured and informative, though slightly lengthy; however, every sentence adds value, and the parameter list is necessary given the lack of schema descriptions.

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

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

Given the tool's complexity and the presence of an output schema (implied by the return dict description), the description covers all necessary aspects: purpose, usage, parameter behaviors, and return values, leaving no 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?

With 0% schema description coverage, the description adds thorough meaning for all 10 parameters, including defaults, ranges, pattern-specific behavior, and visual effects like banding and scale suggestions.

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 builds a complete procedural texture as a material in one call, distinguishes it from hand-wiring and image textures, and compares favorably to siblings like create_material and create_principled_material.

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

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

It explicitly prefers this over hand-wiring, explains when procedural beats image textures, and suggests calling list_procedural_patterns() to see available patterns. It also details parameter applicability per pattern.

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?

Despite no annotations, the description fully discloses behavioral traits: explains why shader nodes fail, that image is packed in blend file, cost scales quadratically with size, seed reproducibility, and blank field when count is 0.

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

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

Well-structured with a clear title sentence, usage context, then a clean args list. Every sentence adds value without redundancy. Highly efficient use of space.

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

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

Given no annotations but an output schema described, the description covers all necessary context: use case, limitations, parameter details, side effects, and return value. No gaps remain.

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

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

With 0% schema coverage, the description comprehensively explains all 7 parameters, adding details like 'runes' for pattern, max size 2048, cost scaling, blank field for count=0, seed reproducibility, and RGBA for colors.

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 generates image textures for patterns shader nodes cannot express, specifically for discrete marks like runes. It distinguishes from create_procedural_material by explaining the fundamental limitation of shader nodes.

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 explicit when-to-use and when-not-to-use guidance, naming the alternative tool create_procedural_material for non-discrete patterns. Also notes that the image is packed into the blend file and no file is written to disk.

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 mentions a return value but does not disclose what happens if the scene already exists, default settings, or potential 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 very short and front-loaded, with no wasted words. However, the use of an Args/Returns style is slightly non-standard for MCP tool descriptions.

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 only one parameter and an output schema exists (not shown), so the description is somewhat complete. However, missing behavioral details like response to duplicates or constraints reduce completeness.

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

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

Schema description coverage is 0%, but the description adds minimal meaning by stating 'name: Name for the new scene.' This partially compensates but lacks details like validation rules or formatting.

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 'Create a new scene.' with a specific verb and resource. It distinguishes from sibling tools like delete_scene, list_scenes, etc.

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. There is no mention of prerequisites, when not to use it, or comparison with related tools like create_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 provided; the description mentions a return dict and default font behavior but doesn't disclose side effects or prerequisites like required mode.

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