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?

With no annotations, the description carries the full burden. It usefully discloses the return shape ('Dict with the created constraint's name and type') and the object/bone scoping rule, but says nothing about failure modes (missing object/bone), idempotency, or whether the operation is reversible, which matters for a state-changing 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?

Front-loaded with the one-line purpose, then structured Args/Returns blocks. Every element earns its place; the enum list is long but necessary given 0% schema coverage. Slightly docstring-heavy formatting but not wasteful.

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

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

For a 4-parameter mutation tool with an output schema, the definition covers all inputs plus return shape. The only gap is behavioral detail (errors, prerequisites) that an agent would want before invoking a constraint-creation call.

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

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

Schema description coverage is 0%, so the description must compensate, and it mostly does: it explains object_name, bone_name (empty string for object-level constraints), the full constraint_type enum, and gives example property keys (target, subtarget, chain_count, influence). It adds clear meaning beyond the bare schema types.

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

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

States a specific verb and resource ('Add a constraint to an object or bone') and immediately clarifies the object-vs-bone scope. It does not name an alternative sibling, but no other constraint-adding tool exists in the sibling list, so the purpose stands on its own.

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 says what the tool does but never says when to reach for it versus adjacent tools like add_modifier or set_bone_property, nor does it state prerequisites such as needing an armature for bone constraints beyond a parenthetical. Usage context is left entirely to inference.

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

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

No annotations are provided, so the description carries the full burden. It states the curve must exist (implied mutation, adds state) and gives the return shape ('Dict with curve name and new point count'), which is useful behavioral context. However, it does not state whether the point is appended, inserted, or placed at an index, what happens if curve_name doesn't exist, or what units/coordinate space 'location' uses.

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

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

Front-loaded purpose sentence, then Args/Returns structure. No wasted prose. Slightly verbose in the Returns block for information already covered by the output schema, but efficient overall.

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

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

The output schema exists, so Returns is redundant but harmless. With no annotations, no schema descriptions, and an enum the description only partially reflects, the definition is adequate for a 3-param mutation but leaves gaps: no prerequisites (curve must exist, edit mode?), no error behavior, and an incomplete enum list that could mislead.

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

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

Schema coverage is 0%, so the description must compensate. It does: curve_name ('Name of the curve object to add a point to'), location ('3D location for the new point as (x, y, z)'), and handle_type explains the enum intent ('Handle type - AUTO, VECTOR, ALIGNED, or FREE'). The enum lists 4 of the 7 schema values (AUTOMATIC, FREE_ALIGN, TOGGLE_FREE_ALIGN omitted), a small mismatch, but the parameters are otherwise well documented.

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?

Clear verb+resource: 'Add a control point to an existing curve.' Distinguishes from siblings like create_curve (creates the curve) and set_handle_type (modifies existing handles). An agent can immediately identify the operation.

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

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

No when-to-use guidance, no exclusions, no named alternatives. The sibling set includes several curve tools (set_handle_type, subdivide_curve, smooth_curve, toggle_cyclic) and the description offers no routing logic. What remains is the constraint that the curve must already exist, which is implied rather than stated as a prerequisite.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the result is a 'Confirmation dict with fluid settings,' but omits essential mutational context: whether the object must be a mesh, what happens if a fluid sim already exists, required permissions, or whether the operation is reversible. For a write-style physics tool with zero annotation coverage, this is a significant gap.

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

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

The text is short and front-loaded, with the core purpose stated first and arguments/returns listed afterward. The Args/Returns structure is standard and readable, though the return line duplicates information already carried by the output 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?

The tool is simple and an output schema exists, so return-value explanation is not needed in detail. The description does well with parameters, but for a mutation tool with no annotations it is still thin on behavioral and prerequisite context, leaving an agent without guidance on side effects or required object state.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it defines object_name, explains that type maps to DOMAIN (container), FLOW (emitter), or EFFECTOR (obstacle), and clarifies that domain_type is GAS (smoke/fire) or LIQUID and only used with DOMAIN. That adds real meaning beyond the bare enum 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 states a specific verb and resource: 'Add a fluid physics simulation to an object.' It clearly identifies the tool's scope (fluid simulation) and separates it from cloth or rigid-body siblings by naming the simulation type. However, it never explicitly contrasts itself with adjacent physics tools like add_cloth_sim or add_rigid_body, so sibling differentiation is left to inference.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The description only lists arguments and a return value; it never explains under what conditions an agent should pick this tool over add_cloth_sim, add_rigid_body, or set_physics_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?

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, so the description carries the full burden. It discloses the non-destructive nature and implies stacking via 'modifier stack', and contrasts with booltool's immediate application. It does not cover prerequisites (e.g., object mode), side effects on existing modifiers, 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?

Well-structured with purpose first, a useful TIP, then args and returns. The enum list is repeated from the schema, adding unnecessary length, but overall it is appropriately sized 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?

Given no annotations and a present output schema, the description covers purpose, usage tip, parameter meanings, and return shape. It lacks details on object mode requirements or modifier interaction, but is sufficient for an agent with basic Blender knowledge to invoke it.

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 labels object_name and modifier_type and clarifies that name is optional, but the explanations are largely tautological with parameter names and the enum list duplicates the schema. It does not explain what each modifier type does.

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

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

States a specific verb and resource ('Add a modifier to a mesh object') and scopes it with 'non-destructive workflow'. The TIP explicitly differentiates it from the booltool_* siblings for boolean operations, so an agent can tell them apart.

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

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

Provides explicit when-to-use guidance for the BOOLEAN case, naming the alternative booltool_* tools and the condition (want non-destructive modifier stack). However, it offers no guidance for other modifier types or against siblings like subdivide_mesh or apply_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?

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?

No annotations are provided, so the description carries the full burden. It does disclose a concrete bound (max 1000000 particles), units for lifetime (frames), and the shape of the return value, but says nothing about side effects such as mutating the object's modifier stack or whether the new system becomes active/selected.

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?

Front-loaded one-line summary followed by tightly grouped Args and Returns sections, with no filler sentences. The Args block duplicates schema titles slightly but earns its place given the zero schema coverage.

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

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

An output schema exists, so the Returns note is redundant but harmless. For a mutation tool with no annotations, the description stops short of stating permissions, side effects, or failure modes, leaving meaningful gaps for an agent deciding whether it is safe to call.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every one of the four parameters is named and explained (mesh name, particle count with a hard cap, lifetime in frames, emission source with the enum values VERT/FACE/VOLUME). Only object_name's type expectation is left implicit.

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

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

States a specific verb and resource ('Add a particle system to an object'), which clearly separates it from read-side siblings like get_object_info. It does not explicitly contrast with delete_particle_system or set_particle_rendering, but the action is unambiguous.

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

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

No when-to-use guidance, no prerequisites (e.g. object must be a mesh, must exist, must be in object mode), and no mention of alternatives. The agent must infer that this is the creation step before set_particle_velocity/set_particle_rendering.

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

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

No annotations are provided, so the description carries the burden. It does disclose some behavior: what ACTIVE vs PASSIVE means and what the return value is. But it omits key operational facts for a mutation tool — whether an existing rigid body is overwritten, whether the object needs to be visible/selected, and any dependency or ordering 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?

Front-loaded one-line purpose followed by compact Args and Returns blocks; every line carries information and there is no filler. Slightly formulaic, but appropriately sized for a 5-parameter tool.

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

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

An output schema exists, so the Returns line is supplementary rather than required, and parameter coverage is thorough. The remaining gap is the absent when-to-use/alternative guidance, which matters given the many sibling physics tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all five parameters are documented with meaning, and the numeric ones include ranges (friction 0.0-1.0, restitution 0.0-1.0, mass in kg) plus the enum semantics for type. This is meaningfully richer than the bare schema.

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

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

States a specific verb+resource: 'Add a rigid body physics simulation to an object.' An agent immediately knows this is a physics-simulation setup tool. However, it does not distinguish itself from closely related siblings such as add_cloth_sim, add_fluid_sim, or add_particle_system, nor from set_physics_property.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., object must be a mesh, object must exist), and no exclusions or pipeline context. The Args block documents parameters but not usage conditions.

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

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

With no annotations, the description carries the full burden but discloses little beyond the basic add operation and return shape. It does not mention prerequisites (e.g., material must exist, node tree must be active), error behavior, or whether the operation is reversible.

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

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

The description is front-loaded, uses structured Args and Returns sections, and avoids unnecessary prose. The Returns section is slightly redundant given the output schema, but it does not bloat the definition.

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

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

The tool is a simple mutation, and the description covers parameters and output. However, given no annotations and many sibling node-creation tools, it lacks usage context and behavioral details (e.g., prerequisites, side effects) that would help an agent invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does so for all three: material_name, node_type (with an example), and location (format and default). This meaningfully compensates for the empty schema descriptions, though it omits that node_type must be one of the enum 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 uses a specific verb+resource combo: 'Add a shader node to a material's node tree.' This clearly states what the tool does, but it does not distinguish itself from sibling tools like add_texture_node or add_geometry_node, which could also add nodes to trees.

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

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

No guidance is provided about when to use this tool versus alternatives. The description only lists arguments and return values, leaving the agent to infer context from the name and siblings.

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

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

No annotations 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?

No annotations are provided, so the description carries the full burden, and it delivers: it discloses the specific failure mode (swept rings interpenetrate on the inside of bends), the non-obvious fact that the result still reports watertight and manifold so ordinary mesh checks miss it, and the numeric threshold (1.5+) for a clean surface. It omits cost/performance characteristics, which keeps it from a 5.

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?

Front-loaded with the core purpose, then rationale, then Args and Returns. Every sentence contributes, though the middle explanatory paragraph is slightly verbose for a tool whose name is already descriptive.

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

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

Even though an output schema exists, the description usefully explains the returned fields and their interpretation thresholds (min_clearance_ratio below 1.0 self-intersects, aim for 1.5+). Combined with full parameter semantics and the failure-mode context, an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 0%, so the description must compensate and does: it defines path_points as the ordered centreline in [x,y,z] form, radius as the outer profile radius to be swept, and resolution as samples between points that must match the sweep call. Meaning is added well beyond the schema's bare 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?

States a specific verb and resource ('check whether a path can carry a profile of a given radius, without building it') and immediately distinguishes itself from the sweep operation it precedes. An agent knows this is a validation tool, not a construction tool, without opening the schema.

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

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

Gives explicit invocation timing ('Call this before sweeping, or to find where an existing path needs widening') and couples its resolution parameter to sweep_profile_along_path so the check matches the eventual sweep. It stops short of naming an alternative to use instead when the check fails, but the when-to-use context is clear.

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

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

With no annotations, 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 carries the full behavioral burden. It explains that transforms are frozen and become the new basis, but it does not disclose irreversibility, required permissions, or how object data is affected beyond that implied effect. This is a mutation tool with significant safety/profile gaps.

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

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

The description is structured with a clear opening sentence followed by Args and Returns sections. It is front-loaded and not bloated, though the repeated 'Apply ... transform' phrasing is slightly repetitive.

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

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

An output schema exists, so the description need not explain return values. It covers the operation and all parameters adequately for invocation, but it lacks usage context and safety/irreversibility details that would make it complete for a transform-mutating tool.

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

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

Schema description coverage is 0%, so the description must document parameters. It lists all four parameters, explains each boolean toggle ('Apply location/rotation/scale transform'), and gives defaults, which meaningfully compensates for the empty schema descriptions.

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

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

The description states a specific verb and resource: 'Apply (freeze) transforms on an object.' It also explains the effect ('making current transforms the new basis'), which distinguishes it from setters like set_location or set_rotation. However, it does not explicitly name or contrast with any sibling tool, so the distinguishing is implicit rather than explicit.

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

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

The description gives the operation and parameter defaults but no guidance on when to use this tool versus alternatives such as set_location, set_rotation, set_scale, or apply_modifier. There is no explicit context, prerequisite, or exclusion.

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?

No annotations are provided, so the description carries full behavioral burden. It does not say that baking is a heavy/long-running write operation, whether it overwrites an existing bake, or whether physics must already exist on the object — all material facts 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?

Front-loaded with the core action in one sentence, and the Args block is clean. The 'Returns: Confirmation dict' line is mildly redundant given an output schema exists, but it costs little.

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

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

For a destructive-ish, potentially slow simulation bake with no annotations, the description covers arguments adequately but omits operational context (duration, overwrite behavior, prerequisites). The output schema does relieve it of return-value detail.

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

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

Schema description coverage is 0%, so the description must compensate, and it does document both parameters, including the non-obvious semantics that an empty physics_type bakes all physics on the object. The enum values themselves are self-descriptive and left to the schema, which is acceptable.

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

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

States a specific verb and resource ('Bake a physics simulation for an object'), which is clearly distinct from sibling mutation tools like add_cloth_sim or set_physics_property. It does not, however, contrast itself with those siblings, so an agent must infer when baking is the right call versus adding or configuring physics.

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

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

No when-to-use guidance, no prerequisites (e.g., that physics must already be attached to the object), and no mention of related tools such as set_physics_property or add_particle_system. The only usage hint is the inferred effect of leaving physics_type empty.

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 behavioral burden. It discloses that the operation mutates mesh geometry and returns a confirmation dict, but says nothing about destructiveness, reversibility/undo, whether it needs edit mode or a selected/active object, or how it interacts with existing modifiers.

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?

Front-loaded one-sentence statement of purpose, followed by a compact args list and a one-line return note. The per-parameter lines partly restate the schema, but they are short and readable, so nothing is wasteful enough to penalize heavily.

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

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

For a 4-parameter mesh-editing tool, the description covers purpose, scoping, all parameters, and the return shape, and an output schema exists so return values need no elaboration. The remaining gap is contextual preconditions (edit mode, active object) given the absence of 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 description coverage is 0%, so the description must compensate and largely does: it explains object_name, width, the 1-100 range on segments, and the meaning plus default of the ALL/CURRENT enum. Only the units/semantics of width (absolute vs relative) remain unstated, a small residual gap.

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

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

The first line gives a specific verb and resource ('Bevel all edges of a mesh'), which distinguishes it from neighboring tools like dissolve_edges, bridge_edge_loops, or inset_faces. Minor friction: 'all edges' sits awkwardly next to a selection parameter that can restrict the operation to a subset, but the intent is unambiguous.

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

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

Explicitly tells the agent how to scope the operation: 'ALL' vs 'CURRENT', and directs it to the select_* sibling tools to make a selection first. It stops short of naming other bevel-like alternatives or stating when a bevel is the wrong choice, so it is clear context without exclusions.

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

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

No annotations, so the description carries the load, and it does disclose the key trait: this is a non-destructive modifier workflow that does NOT handle selection or cutter cleanup automatically. It also states the return shape. It stops short of saying whether the cutter is hidden/consumed or whether the modifier is applied, which matters for a mutation tool with zero annotation coverage.

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?

Front-loaded with the core purpose, then a clearly marked NOTE routing to alternatives, then Args and Returns. Well structured and skimmable; the NOTE is slightly verbose in repeating all four sibling names but earns its place as routing guidance.

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, the return-value explanation is redundant but harmless. Together with usage routing and per-parameter documentation, the definition is nearly complete; the only real gap is lifecycle behavior of the cutter object, which is not 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?

Schema description coverage is 0%, and the description compensates by documenting all three parameters, notably clarifying that target_name is the 'target/cutter object' — meaning beyond the bare schema title. The enum values for operation are restated from the schema, so the gain is uneven but the cutter semantics are genuinely additive.

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

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

States a specific verb+resource (boolean operation between two objects) plus the mechanism (using a modifier), and explicitly differentiates itself from the booltool_auto_* siblings by naming them. An agent can tell exactly which tool fits which situation.

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

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

Gives explicit when-not guidance ('For destructive booleans, prefer the booltool_auto_* tools') with all four alternatives named, and states the condition that selects this tool ('non-destructive boolean modifier workflow'). No inference required.

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 and does: it defines each defect semantically, discloses the 50-sample index cap, explains the error returned when the toolbox extension is disabled, and distinguishes print_blocking defects from advisory ones like overhangs. Safety-relevant behavior (read-only check, no mutation) is implied clearly.

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?

Front-loads purpose and defect rationale, then Args/Returns; each section earns its place, though the bulleted defect explanations and extension note make it longer than strictly minimal. Structure is clear and navigable.

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 7-parameter tool with a non-trivial domain, the description covers purpose, defect semantics, parameter meanings, error behavior, sampling limits, and return shape. Even with an output schema present, the extra description of print_blocking vs advisory adds necessary context.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it enumerates the SOLID/INTERSECT/DEGENERATE/THICKNESS/SHARP/OVERHANG/NONPLANAR values, states radians and gives a 45-degree FDM example for overhang_angle, and explains unset defaults for every optional angle/threshold. This is far beyond what the JSON schema provides.

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

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

States a specific verb+resource ('check whether a mesh will 3D print') and immediately differentiates from the sibling analyze_mesh_quality, naming the exact defect classes that pass that tool but fail here. An agent can tell the two apart without opening a schema.

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

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

Explicitly frames when to use this over analyze_mesh_quality, explains the checks option (omit/empty list runs all), documents the extension prerequisite, notes the error path when disabled, and points to suggest_extensions for checking its state. Alternatives and conditions are spelled out.

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 are provided, so the description carries the full behavioral burden. It says the return is a 'Confirmation dict,' but it does not disclose whether conversion is destructive, whether it replaces the original object, what data may be lost, or what side effects occur.

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-loads the core purpose before a structured Args/Returns block. It is efficient, though the 'Returns: Confirmation dict' line is somewhat redundant given the output schema.

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

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

For a conversion tool with no annotations, the description is incomplete about behavioral effects such as whether the original object is modified or replaced. The output schema covers return values, but key mutation and safety context is missing.

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

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

Schema description coverage is 0%, and the description adds little beyond the schema. The allowed target values it lists are already present as an enum, and `object_name` is described only as 'Name of the object to convert' with no further detail. It does not mention the default target of MESH or clarify required versus optional arguments.

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

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

The first sentence states a specific verb and resource: 'Convert an object to a different type.' It is clear what the tool does, but it does not differentiate from the sibling `convert_curve_to_mesh`, which is a more specific conversion 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 no guidance on when to use this tool versus alternatives such as `convert_curve_to_mesh` or `create_curve`. It also omits any prerequisites or exclusions for performing a conversion.

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 carries the full burden. It signals a write operation via 'Create' but says nothing about side effects: which collection the curve lands in, whether it becomes the active/selected object, or whether any existing state is touched. The Args/Returns text is documentation of structure, not behavioral traits.

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

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

The purpose is front-loaded in the first sentence and the docstring-style Args/Returns block is compact. The Returns section is mildly redundant given an output schema exists, but nothing is bloated.

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

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

With an output schema present, the return description is not strictly needed, and parameters are covered by the description. But for a mutation tool with zero annotations, the description omits the context an agent needs to call it correctly — target collection, mode requirements, and post-creation selection state.

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 names all three parameters and gives meaning for each (type enum choices, optional name, location as x/y/z), which adds real value over the bare schema. It stops short of edge cases such as whether location is absolute or relative to the cursor.

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

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

States a specific verb and resource ('Create a new curve object'), which is unambiguous on its own. However, in a sibling set that includes create_object, create_text, and convert_curve_to_mesh, the description does nothing to distinguish when a curve rather than a generic object is wanted.

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

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

There is no when-to-use guidance, no prerequisites (e.g. object mode vs edit mode, required scene/collection), and no routing to alternatives such as create_object or convert_curve_to_mesh. The agent must infer all selection logic.

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 supplied, so the description carries the full disclosure burden. It does state the return shape ('Confirmation dict with light name and properties'), which helps, but it never says which scene or collection the light lands in, whether it becomes selected/active, or what permissions are needed for a mutation.

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?

Front-loaded one-line purpose followed by a compact Args/Returns block; each line carries information. Slightly more boilerplate than necessary, but nothing wasted.

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

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

An output schema exists, so the Returns line is redundant rather than filling a gap. For a mutation tool with no annotations and no output-schema-based side-effect info, the description should say more about where the light is created and its default state, so it is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning — and it delivers: it enumerates all five parameters, the enum values for type, and the defaults for name, location, energy, and color. Minor gap is that it doesn't specify the length/format constraints on color and location beyond 'as [x, y, z]'.

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

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

States a specific verb and resource ('Create a new light in the scene'), which is unambiguous and distinct from the many read/delete siblings. It does not, however, distinguish itself from the closely related create_light_rig, so an agent gets no explicit help choosing between the two.

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 when-to-use guidance, no prerequisites, and no mention of the sibling create_light_rig as an alternative. The agent must infer the context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the operation creates multiple lights and returns their names, but says nothing about whether created lights are parented/grouped, whether an existing rig is replaced or duplicated, permissions, or reversibility (delete_light exists as the inverse).

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?

Front-loaded one-line purpose followed by documented args and returns; the docstring structure is clean and every line contributes. Slightly verbose as a Google-style docstring for such a simple tool, but no wasted prose.

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

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

For a 3-param creation tool with an output schema present, the description covers purpose, all param semantics, and the return shape, so the agent has what it needs to invoke correctly. It stops short only on behavioral edges (grouping, idempotency, replacement of existing rigs).

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

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

Schema description coverage is 0%, so the description must compensate, and it does well: it names the enum options (THREE_POINT, STUDIO, RIM, OUTDOOR), explains target as the object the rig points at, and gives the intensity default (1000). Minor gap: it doesn't state intensity units.

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

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

States a specific verb+resource ('Create a pre-built lighting rig') and even parenthetically clarifies it makes multiple lights arranged for preset setups, which distinguishes it from the sibling create_light. An agent can immediately tell this composes a rig rather than a single light.

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 when/when-not guidance and no mention of alternative siblings (create_light, set_light_property, list_lights). The description never says when to prefer a pre-built rig over manually placing individual lights, so an agent must infer the use case.

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 the full behavioral burden. It does disclose useful traits: name is auto-generated when empty, and each transform parameter has a default. However, it says nothing about where the object lands (active collection?), whether it becomes selected/active, error behavior on invalid enums, or whether the operation is undoable.

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?

Front-loaded one-line purpose followed by compact Args/Returns blocks. The enum listing is slightly redundant with the schema but keeps the description self-contained, and no sentence is wasted.

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

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

An output schema exists, so the Returns section is somewhat redundant, though harmless. For a 5-param mutation tool with no annotations, the description is nearly complete; only the side effects of creation (selection state, target collection) are unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it gives units for rotation (radians), the required shape/format for vector params ('3-element list/tuple'), defaults for location and scale, and the meaning of an empty name. This adds real meaning beyond the bare schema types.

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

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

States a specific verb+resource ('Create a primitive object in the scene') and the 'primitive' qualifier distinguishes it from sibling creators like create_text, create_curve, create_armature, or create_polygon_prism. An agent can identify this as the entry point for adding generator-based primitives without opening the schema.

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

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

Usage is implied by the name and description (this is the tool for adding a primitive), but there is no explicit when/when-not guidance and no sibling is named. With dozens of create_* siblings in the list, a sentence like 'use create_text/create_curve for non-primitive geometry' would have materially helped routing.

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

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

No annotations are provided, so the description carries the full burden. 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.