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

With no annotations, the description fully handles transparency. It discloses that the switch triggers a rebuild, applies suppressions and dimensions, and returns the previous configuration name. However, it lacks details on side effects like reversibility or error conditions, so it's good 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 bilingual (Spanish and English), making it longer than necessary. It is front-loaded with the main action but the repetition reduces conciseness. The Args section is clear.

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 tool with one parameter and no output schema, the description covers purpose, side effects, use case, and return value. It is mostly complete, though it does not explain error handling or behavior for non-existent configurations.

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 parameter 'name' is described as 'Name of the configuration to activate', which adds some meaning but is minimal. Given 0% schema coverage, this is adequate but not detailed; it essentially restates the parameter's purpose.

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 activates a different configuration of the active document, distinguishes from sibling tools like create_configuration and delete_configuration, and mentions the rebuild effect and relation to build_variant_family.

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

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

The description provides a specific use case: verifying a variant built with build_variant_family before saving. It implies context but does not explicitly state when not to use the tool or 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?

No annotations are provided, so the description carries the full burden. It discloses that the mate is fixed, the angle is in degrees with right-hand-rule orientation, and that the solver may reject if entities are coplanar. It describes the return value (metadata including angle_deg). It does not mention authentication, rate limits, or side effects, but for a mate creation tool, the behavioral traits are adequately 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 bilingual text, a clear purpose statement, usage context, parameter notes, gotcha, and related tool. It front-loads the key information. While slightly verbose due to bilingual repetition, the structure aids readability and each section adds value.

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

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

Given 6 parameters (5 required), no output schema, and no annotations, the description covers the main behavioral aspects and constraints but lacks full parameter details (e.g., align, entity IDs). It does mention the return value. The gotcha and related tool add context. However, without schema coverage, the description could be more comprehensive for agent decision-making.

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 explains the angle_deg parameter (positive per right-hand-rule) and states 'Other args: same as add_concentric_mate,' which is helpful but vague. It does not describe align, component_name, or entity_id parameters. Thus, it adds partial value but leaves significant gaps.

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

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

The description clearly states the tool's purpose: 'Mate de ángulo — fuerza un ángulo fijo entre dos entidades' and 'Add an angle mate (fixed angular offset) between two entities.' It specifies the resource (angle mate) and the action (add). It distinguishes from sibling mates (e.g., concentric, distance) by focusing on angular relationships and providing typical use cases like chain-link articulation and hinge angles.

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

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

The description includes typical use cases (e.g., hinge angles, lever positions) and constraints (entities must be planar or axes). It warns against applying between two concentric cylindrical faces and mentions a gotcha about coplanar entities. It references a related tool (add_mate_by_face_position) but does not explicitly contrast with all sibling tools. The guidance is clear and practical, though not exhaustive.

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, but description fully discloses behavior: creates a single sketch and extrude_cut for all holes, non-parametric, returns feature info, explains reverse_direction as escape hatch, and scoping with target_bodies.

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 sections (summary, Args, Returns, Caveat, Example). Slightly redundant phrasing but overall effective and front-loaded. Could trim minor repetition for perfect conciseness.

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

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

Given the complexity (11 params, no output schema, no annotations), the description covers all parameters, return value, caveat, and provides an example. It is fully complete for an AI agent to invoke the tool correctly.

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

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

Schema coverage is 0%, but the Args section thoroughly explains each of the 11 parameters with constraints (e.g., circle_diameter_mm must be >0 and > hole_diameter, hole_count >=3, etc.) and defaults. Example demonstrates core parameters.

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

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

The description clearly states the tool creates a bolt circle with N holes using a single sketch and extrude cut. It distinguishes itself from feature-pattern alternatives like circular_pattern by noting it's sketch-based and works for any center position.

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 provides when to use (any center position) and when not (non-parametric, suggests create_reference_axis + circular_pattern for parametric counts). Also gives example for common 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?

No annotations are provided, so the description carries full burden. It describes the operation as mating planar entities, implying assembly modification. However, it does not disclose side effects, required permissions, error conditions, or behavior for non-planar entities. Minimal transparency beyond the basic operation.

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

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

Bilingual (Spanish/English) makes the description longer than necessary for an English-speaking AI. While the content is useful, it could be more concise by dropping the Spanish version. Sentences are clear and front-loaded with the core 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?

With 5 parameters, no output schema, and no schema descriptions, the description is incomplete. It lacks details on how to obtain entity IDs, what the 'align' parameter does, and expected return value. References to similar tools partially compensate but own content is insufficient.

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 does not explain individual parameters. It only notes same argument shape as add_concentric_mate, which is indirect. No details on component names, entity IDs, or the 'align' parameter. Fails to compensate for 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 it adds a coincident mate between two planar entities (faces or planes). It specifies typical uses like flange-to-plate and sub-assembly base plane. It distinguishes from siblings by referencing add_concentric_mate's argument shape and listing related tools, but does not explicitly differentiate from all mate types (e.g., angle, distance).

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 typical use cases (flange-to-plate, sub-assembly base plane). Mentions same argument shape as add_concentric_mate, guiding agents familiar with that tool. Lists related alternatives: add_mate_by_face_position (convenience without entity names) and stack_components (batch 3 mates). Lacks explicit when-not-to-use, but 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?

No annotations provided, so description carries full burden. Discloses locale sensitivity for entity names, align parameter, and return of mate metadata. However, lacks details on error handling or side effects (e.g., does it modify assembly state?). Still adds significant 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?

Well-structured with bullet points and bilingual content. Could be slightly more concise by omitting Spanish repetition, but front-loads core purpose and uses clear formatting.

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 5 parameters, required fields, typical usage, return value, and related tools. No output schema, but description adequately describes return as mate metadata. Complete for a mate tool with moderate complexity.

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

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

Schema coverage is 0%, so description compensates fully. Explains each parameter: component names from get_active_assembly_info, entity ID strings (locale-sensitive), and align values. Provides context beyond schema (e.g., copy verbatim note).

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 aligns axes of cylindrical/conical entities via a concentric mate. Provides specific verb ('alinea ejes' / 'align axes') and resource. Distinguishes from siblings like add_mate_by_face_position and stack_components.

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

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

Explicitly describes typical autoparts use cases (bolt+sleeve, sleeve+shaft, two bearings). Mentions related tools for alternative approaches, giving clear when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as whether the mate is destructive, if it can be removed, permission requirements, or behavior when over-constrained. It mentions 'Returns the created mate's metadata' but lacks detail on what that includes.

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 relatively concise but contains redundant Spanish and English text. The key information is front-loaded in the English portion. It is structured with an Args section and a Related line, making it scannable.

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

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

Given the tool has 6 parameters, no output schema, and moderate complexity, the description is incomplete. It does not explain the entity IDs, component names, or align parameter. The reference to add_concentric_mate assumes knowledge of that tool. No return value details beyond 'metadata'.

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%; the description explicitly only defines distance_mm (with unit) and refers to other arguments as 'same as add_concentric_mate,' providing minimal additional meaning. The align parameter with default is not explained, and entity/component parameters are not elaborated.

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 distance mate (fixed offset) between two entities, and provides specific use cases (parallel plate separation, bearing-to-bearing distance). It distinguishes from sibling mates like add_concentric_mate and add_angle_mate by focusing on fixed offsets.

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 typical use cases and explicitly lists related tools (add_mate_by_face_position, stack_components) that offer alternatives or convenience. However, it does not explicitly state when not to use this tool.

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

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

With no annotations, the description fully discloses that holes show as 'Cortar-Extruir' features, not Hole Wizard features, and notes no cosmetic threads and limitations like M12 not accepted for counterbore in v1.

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 sections for args, returns, caveats, and examples, but somewhat lengthy; however, every sentence adds value given the complexity.

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

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

With 8 parameters, no schema descriptions, no annotations, and no output schema, the description provides comprehensive coverage including return format, caveats, and two examples.

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 thoroughly explains all 8 parameters, including enum values, size constraints, mutual exclusivity of plane vs face_centroid_mm, 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 drills N holes at specified positions using ISO Metric standards, and distinguishes it from hole_wizard (single-hole vs multi-hole).

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 describes when to use (multi-position patterns where hole_wizard is impractical) and when not to (single hole with proper styling), and names hole_wizard as an alternative.

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

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

Despite no annotations, the description fully discloses the tool's composition and critical non-obvious behavior: reverse_direction=True for the extrude cut. Also explains orientation assumptions, return values, and warnings.

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

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

The description is long but well-structured with clear sections for workflow, args, returns, and caveats. Every sentence adds value, though it 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 the tool's complexity (6 params, orientation constraints, non-obvious extrude direction), the description is thorough. It explains all return values, including derived metrics and warnings, which is essential since no output schema exists.

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

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

All six parameters are described in detail with units, defaults, constraints, and context (e.g., standard DIN widths, derivation of keyway_start/end_x_mm). The schema coverage is 0%, so the description fully compensates.

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 tool adds a DIN 6885-style axial keyway cut into a shaft end. Provides specific verb and resource, distinguishes from sibling tools like build_stepped_shaft and the primitive chain.

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 states the tool operates on an active part with a shaft along world X, typically built with build_stepped_shaft. Provides a junior workflow example and explicitly tells when not to use (arbitrary orientation) with alternative.

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

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

With no annotations, the description carries full burden and excels: discloses that units control equation suffix and internal conversion, describes return dict fields, explains raw SW string format, and warns about reuse. No contradictions.

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

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

Well-structured with clear sections (purpose, args, returns, binding example, related). Contains dual-language text (Spanish/English) which adds some redundancy but remains 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?

Given the complexity and no output schema, the description covers all needed context: how to use, what it returns, how to bind dimensions, unit behavior, and concrete example. Complements sibling tools 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?

Despite 0% schema description coverage, the description adds comprehensive meaning: name restrictions (no quotes, =, comma, @) and convention, value numeric, units with allowed values and conversion details. Far exceeds schema minimal info.

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 global variable (equation) that sketch and feature dimensions can reference. It distinguishes from related tools by explicitly naming set_global_variable and modify_dimension as alternatives, and warns against reusing the same name.

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

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

Provides explicit when-to-use context (parametric parts like CSWA Tool Block) and when-not-to-use (do not call again for same variable). Explains how to bind dimensions by adding another equation and lists related tools for modification.

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 behavior: resolution of face positions based on normal vectors, coordinate frame details, defaults for Pieza-style parts, and explanation of mate_type, align, distance_mm. No contradictions or hidden behaviors.

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

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

The description is bilingual (Spanish then English) and well-structured with a clear Args list, example, and explanatory notes. It is slightly verbose but every sentence adds value. Could be trimmed but organization is excellent.

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 7 parameters, no output schema, and 0% schema description coverage, this description is highly complete. It explains all parameters, provides default behavior, gives a concrete example, and explains the coordinate system. No missing critical information.

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% schema description coverage, so the description must compensate. It does so thoroughly: each of the 7 parameters is explained in the Args section with defaults, allowed values, and context (e.g., coordinate frame for positions, default align). Adds significant meaning beyond schema.

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

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

The description clearly states the tool's purpose: creating a mate between two components using face positions. It specifies the verb (add_mate), resource (components), and distinguishes from sibling tools by using position keywords instead of face indices. The example solidifies 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 explains when to use this tool: as a convenience wrapper to avoid locale-sensitive face-index handling. It provides context about interpreting position keywords in local coordinate frame. However, it does not explicitly mention when not to use or alternatives like add_coincident_mate, though the convenience argument implies it.

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

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

No annotations, so description carries full burden. It explains lines must be adjacent, sketch must be in edit mode, chamfer is 45° equal-distance, internal API may fail, and returns metadata. Very 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?

Description is bilingual (Spanish/English), doubling length unnecessarily. Essential info is front-loaded but redundancy reduces conciseness.

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?

No output schema, but description says returns metadata. Covers prerequisites, gotchas, and parameter usage. Adequate for a simple tool, though output details could be richer.

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 clearly explains each parameter: line1_x_mm, line1_y_mm as a point on first line, line2 similarly, distance_mm as chamfer distance, and z_mm default. Adds significant value 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?

The description clearly states it cuts a sketch corner with a 45° equal-distance chamfer, replacing a vertex with an inclined line. It distinguishes from sibling tools like add_sketch_fillet (rounds corners) and chamfer (3D edge chamfer).

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 typical usage for CSWA Tool Block, prerequisites (sketch in edit mode, lines adjacent), and a gotcha with workaround. Distinguishes from 3D chamfer. Lacks explicit when-not-to-use but otherwise strong.

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

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

No annotations provided, so description carries full burden. It fully discloses behavior: driving dimension, auto-naming, dimension type inference based on point selection, value override forcing geometry update, text offset defaults, and return of dim name. No contradictions.

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

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

Description is well-structured with sections for purpose, arguments, returns, requirements, and gotchas. However, it includes both Spanish and English, making it slightly longer than necessary for an English-only agent.

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 6 parameters, 0% schema coverage, no annotations, and presence of output schema (not shown), the description covers all necessary aspects: function, parameters, usage flow, return value, prerequisites, and a gotcha. It is fully adequate for correct invocation.

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

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

Schema has 0% coverage, but description explains each parameter's purpose and usage: entity_x/y/z_mm as a point on the sketch entity, value_mm as desired dimension value that overrides geometry, text_offset_x/y_mm for cosmetic placement with 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?

Description clearly states the tool adds a driving dimension to a sketch entity at a given point with auto-naming. It implicitly distinguishes from siblings like add_sketch_relation and modify_dimension by focusing on dimension creation.

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

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

Explicitly states the sketch must be in edit mode and should be called after sketch creation and before closing. Provides a typical CSWA use case and a gotcha about dimension type inference. Does not mention when not to use or alternatives.

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

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

No annotations provided, so description carries full burden. It explains destructive behavior (replaces vertex with arc), that SW picks closest segment, and constraints (adjacent lines). Returns metadata. Good coverage for a simple 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?

Description is concise and front-loaded. The English portion is efficient, two sentences followed by a usage note and parameter explanations. 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?

With 6 parameters and no output schema, the description covers purpose, parameter semantics, prerequisites (edit mode), constraints (adjacent lines), and related tools. Sufficient for correct usage.

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

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

Schema has 0% description coverage; description adds meaning for all 5 required params: explains that line1_x_mm/line1_y_mm are points on first line near corner, similarly for line2, radius_mm is fillet radius, z_mm is Z-coordinate default 0. Fully compensates for 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 it rounds a sketch corner with a tangent arc between two adjacent lines, replacing the vertex. It includes a typical use case (CSWA Tool Block R3) and distinguishes from siblings add_sketch_chamfer and fillet.

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 context: sketch must be in edit mode, lines must be adjacent, and gives a typical use case (R3). Mentions related tools. Lacks explicit when-not-to-use but is informative about requirements.

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 effect (fully defined, stops drifting), no rebuild until next exit, and which relations take 1 or 2 points. Missing error conditions or behavior if relation already exists. With no annotations, carries burden 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?

Well-structured with bilingual intro, Args, Returns, and context. Slightly redundant due to dual languages, but front-loaded with essential info and no wasted sentences.

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 0% schema coverage, no annotations, and no output schema, description covers purpose, parameters, return value, and usage context. Missing error handling or validation details, but adequate for most uses.

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

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

With 0% schema coverage, description fully explains both parameters: relation values and entity_points_mm format (list of points). Adds meaning beyond schema by specifying number of points per relation type.

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

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

Description clearly states it adds geometric constraints to sketch segments, lists specific relations, and explains its role in making sketches fully defined. It distinguishes from sibling tools like add_sketch_dimension and add_sketch_fillet.

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 usage context: typical CSWA workflow, when to use (after drawing, before extrude), and requires sketch in edit mode. Implicitly differentiates from dimensioning and filleting but lacks explicit 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, description fully discloses behavior: not parametric, creates sub-edges, modifies the part, returns a feature object with chamfered edges count, and explains default handling of circular edges. No contradictions.

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

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

Well-structured with context paragraph, bulleted args, return info, caveat, and examples. Front-loaded with purpose. Slightly verbose but every section adds value; minor trim could improve conciseness.

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 lack of annotations and output schema, description covers all necessary aspects: when to use, parameter details, return structure, side effects, interaction with other tools, and practical examples. Complete for correct invocation.

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

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

Schema has 0% description coverage, but description provides rich detail for all 5 parameters: defaults, typical values, edge cases (e.g., circular edges skip min_edge_length_mm), and the purpose of include_arcs for round parts. Fully compensates for schema 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?

Clearly states it chamfers every edge (linear and circular) in one call, designed for autoparts edge breaks per ISO 13715. Distinguishes from sibling tools like chamfer (requires selection) and fillet_all_edges by combining list_edges + filter + chamfer.

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

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

Explicitly says when to use (universal deburring for autoparts), gives examples (standard deburr, single body, linear-only), warns about non-parametric nature and interaction with fillet_all_edges, and recommends using only one edge-break tool per part.

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 responsibility. It discloses multiple behavioral traits: loop validation before SW calls, leaving the sketch open, exact mode to prevent drift, fallback behavior, and call atomicity. This is thorough and honest.

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

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

The description is long but well-structured with bilingual sections, bullet points, and clear examples. It could be slightly more concise, but the complexity of the tool justifies the length. Front-loads key 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 6 parameters, nested segment objects, and no output schema, the description covers all necessary aspects: input format, behavior, return shape, notes on atomicity, and related tools. It is 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 input schema provides only type and title for parameters (0% schema description coverage). The description compensates fully by explaining each parameter: plane (aliases), segments (detailed format with coordinate examples), close (auto-closing behavior), exact (exact mode vs inference, drift trade-off), name_hint (unused), and variables (parametric evaluation). This adds significant meaning beyond the schema.

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

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

The description clearly states the tool builds a closed profile from an ordered list of segments in one call, contrasting with creating multiple primitives. It specifies validation, leaving sketch open, and targets specific use cases like the CSWA Tool Block. This distinguishes it from siblings like create_line/create_arc.

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 a typical use case and references related tools (add_sketch_relation, extrude_sketch). However, it does not explicitly state when to avoid using this tool (e.g., when you need individual primitives or open profiles). The guidance is clear but lacks explicit 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?

The description mentions that segment coordinates and depth_mm accept string expressions over variables, which is a key behavioral detail. However, with no annotations, it does not disclose side effects (e.g., whether it requires an active sketch), destructive potential, or error handling.

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

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

The description is two sentences with a concrete example, no redundant text. It is concise but could be slightly more structured (e.g., listing key parameters).

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

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

With 8 parameters, no output schema, and no annotations, the description leaves major gaps. It does not explain the purpose of most parameters (exact, merge, plane, end_condition) or the return value. A user would need extensive trial and error.

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 is the sole documentation for 8 parameters. It only explains segments and depth_mm's expression capability, leaving plane, exact, merge, variables, end_condition, and reverse_direction completely undocumented. This is insufficient.

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

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

The description clearly states the tool builds an exact closed profile and extrudes it as one composite. This differentiates from build_closed_profile (profile only) and build_revolved_profile (revolved), though not explicitly. The purpose is specific and actionable.

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 build_closed_profile or extrude_sketch. The only usage hint is about size variants using a new variables dict, which is helpful but insufficient for tool 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 fully discloses the composite nature, bore being 'through_all', reverse_extrude behavior, return structure, and caveats, providing comprehensive behavioral 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?

Well-structured with clear sections (purpose, workflow, args, returns, caveat, example), front-loaded purpose, and no wasted sentences.

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

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

For a tool with 8 parameters, no output schema, and no annotations, the description comprehensively covers all aspects: parameter details, behavior, caveats, return info, and an example.

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 Args section adds detailed explanations for all 8 parameters, including constraints (e.g., bore_diameter_mm must be >0 and < outer_diameter_mm), which is absent in the schema (0% coverage). This significantly aids 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 clearly states it creates a cylindrical boss with optional through bore, provides a junior workflow example, and distinguishes from sibling tools by specifying the composite operation for a flange boss.

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

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

The description includes a junior workflow example and advises when to use bore_target_bodies to restrict bore scope, and mentions using extrude_cut separately for blind bores. However, it could be more explicit about when to use this tool versus other build 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 provided, so description carries full burden. It discloses the orientation contract (L-profile in Front plane, extrusion direction, bolt hole drilling direction), that it creates multiple features, returns a dict with feature info, and a caveat about sharp inside corner. This is highly 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 somewhat long but highly structured with sections for Args, Returns, Geometry, Caveat, Example. It is front-loaded with a clear one-liner. Every section adds value, so it earns its length.

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

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

With 8 parameters and no output schema, the description covers everything: return dict details, geometry orientation, parameter constraints, a caveat, and an example. It is complete for an agent to invoke the tool correctly.

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

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

Schema coverage is 0% (no descriptions in schema). The description adds detailed explanations for each parameter: constraints (e.g., leg lengths must be > 2×thickness), defaults, and meanings (e.g., 0 = no bolts). This compensates fully for the schema gap.

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

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

The description clearly states it builds an L-shaped bracket with bolt holes, using specific verbs and resource. It distinguishes from siblings by noting it wraps multiple operations into one call, providing a unique value proposition.

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 extensive usage context: typical use case (autoparts bracket), a junior workflow example, physical dimensions, constraints, and an example. It doesn't explicitly state when not to use it, but the context is rich and clear enough for an agent to decide.

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?

In the absence of annotations, the description thoroughly discloses behavior: it compiles to an op-list and executes as a batch with deferred redraw, all-or-nothing rollback, and single approval. It also describes the return value (execute_batch result plus compiled_ops and summary) and error handling (clear error for invalid DSL).

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

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

The description is front-loaded with the main purpose and examples. However, it is somewhat lengthy due to the list of methods and bilingual content. It could be slightly more concise, but the structure is clear and 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 tool's complexity (DSL with many methods and options), the description is comprehensive: it explains the grammar, supported methods, edges function, scope options, and fallback behavior. It provides enough context for an agent to use the tool correctly without additional clarification.

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 provides meaningful information for each parameter: script is 'la expresión fluida' with examples, dry_run compiles without affecting SolidWorks, and rebuild triggers a rebuild on batch close. This compensates well for the schema's lack of 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 that it builds a part from a fluent build123d-style script in one call. It specifies the closed grammar and compilation to op-list, distinguishing it from individual geometry tools like create_rectangle or extrude_sketch.

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

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

The description explains when to use this tool versus alternatives: explicitly advises against using it for sketch-on-face (use create_sketch_on_face instead), and mentions fallback to execute_batch or loose tools for invalid DSL. It provides examples and lists supported methods.

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 behavior: opens parts in series read-only, extracts metadata, no network, incremental, and rebuild option. No contradictions.

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

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

Two well-structured paragraphs with front-loaded purpose. Every sentence adds value, 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?

Despite no output schema, the description lists return fields. For a tool with 3 parameters and simple behavior, it is complete.

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

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

Schema coverage is 0%, so description fully explains each parameter: folder (recursive, ignores temp files), rebuild (re-reads all), max_parts (limit). Adds significant meaning.

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

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

The description clearly states the tool indexes a folder of .SLDPRT parts into a local catalog, distinguishing it from sibling tools that focus on modeling 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?

Provides clear context on incremental vs rebuild mode and advises running when SolidWorks is idle, but does not explicitly list when to avoid using the tool.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions 'drawing-grounded through holes' but does not explain if the operation is destructive, whether it requires an active document, or other side effects. The description is minimal on behavior beyond the obvious creation 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 brief with two sentences. The first sentence states the overall action, and the second sentence provides key usage details. No extraneous words, and the most important 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?

Given the tool has 14 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the return value, prerequisites, or how parameters like thickness or plane affect the result. For a complex tool, more context is needed.

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 clarifies hole_positions_mm, bolt_circle_diameter_mm, bolt_count, origin coordinates, width, and height. However, many parameters (plane, thickness_mm, angle_offset_deg, reverse_direction, bolt_circle_center_*) are not mentioned, leaving gaps.

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

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

The description clearly states the tool builds a rectangular plate and drills through holes, specifying two hole placement methods (explicit positions or bolt circle). It distinguishes itself from sibling tools like add_bolt_circle or build_rectangular_pocket by combining plate creation with hole patterning in one 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 mentions two usage modes (explicit positions vs bolt circle) but does not explicitly guide when to use this tool over alternatives like building a plate and holes separately. The context is clear but lacks exclusions or targeted usage advice.

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 effect of reverse_direction, end_condition, and target_bodies in detail, including edge cases like cutting into air. It also mentions the return type (Cut-Extruir Feature info).

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 purpose statement, workflow example, parameter list, and usage example. It is slightly long but each sentence adds value. The front-loading with the Spanish purpose and junior workflow is effective.

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

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

Given the tool's complexity (9 parameters, 5 required, no output schema, no annotations), the description is highly complete. It covers purpose, parameter semantics, behavioral details, and provides a concrete example. It leaves little ambiguity for an AI agent to select and invoke the tool correctly.

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

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

The schema provides no descriptions (0% coverage), so the description must compensate. It provides thorough explanations for all 9 parameters, including constraints (e.g., width_mm > 0), defaults, and coordinate system context for center_x_mm and center_y_mm. The example also illustrates usage.

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: 'Hacer un vaciado rectangular en una sola operación' (Make a rectangular pocket in a single operation). It distinguishes itself from sibling tools like extrude_cut, create_rectangle, and create_sketch by combining these operations.

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

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

The description includes a junior workflow example showing how to use the tool, and implies it is a shortcut for create_sketch + create_rectangle + extrude_cut. However, it does not explicitly state when not to use it or mention alternatives, though the 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?

The description outlines the steps (creates axis, builds closed profile, revolves) and mentions the 'safe chain' concept, but does not clarify potential side effects (e.g., whether existing geometry is modified) or any required permissions. Since no annotations are provided, the description carries the burden, and while it gives some behavioral insight, gaps remain.

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 at four sentences, front-loaded with the primary action, and each sentence adds meaningful information (steps, usage context, capability). No unnecessary 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 complexity (9 parameters, no output schema, no annotations), the description is insufficient. It lacks details on parameter formats, return values, error conditions, and how it integrates with the overall part model. The agent would struggle to invoke this tool reliably without additional knowledge.

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

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

The input schema has 9 parameters with 0% description coverage, yet the tool description only mentions 'segments' and 'variables' indirectly. It does not explain the format of the required 'segments' array, the meaning of 'plane', 'angle_deg', 'axis_reference_1/2', or other parameters. This is a critical gap for an AI agent to use the tool correctly.

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

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

The description clearly states the tool builds an axisymmetric profile via a safe chain, specifying it for turned parts with ordered line/arc segments. It differentiates from siblings like build_closed_profile or revolve_sketch by calling itself the 'preferred path' for this specific use case.

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 indicates when to use the tool ('preferred path for turned parts...') and mentions variable expressions for variants, but does not explicitly state when not to use it or provide alternatives. The guidance is implied rather than explicit, which could leave ambiguity for an AI agent.

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. Describes internal composed workflow, return metadata, and parameter effects (merge, angle). Caveats about orientation and transitions add transparency. Could be more explicit about safety (additive vs destructive), but acceptable.

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 summary, workflow, args, returns, caveats, and example. Front-loaded with purpose. Every sentence adds value; 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?

Given 4 parameters, no output schema, and no annotations, the description covers all necessary aspects: argument constraints, return values, caveats for orientation, transitions, and tapering. Includes an example for clarity. Complete for agent selection and invocation.

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

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

Schema provides no parameter descriptions (0% coverage). Description compensates by explaining each parameter: diameters and lengths constraints (1-20, >0, same length), angle_deg default and use for sectors, merge behavior. Adds meaning beyond 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?

Clearly states the tool creates a stepped multi-diameter shaft in one call, with examples and distinction from primitive sketch tools. The title and description align with the name.

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

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

Provides explicit when-to-use guidance via junior workflow example and caveats that tell when alternative tools (revolve_sketch) should be used. Also lists limitations (square shoulders, no taper, fixed orientation).

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 for behavioral disclosure. It thoroughly explains that the tool composes extrude_sketch and extrude_cut, that the tap is a 'Cortar-Extruir' feature (not a hole-wizard), and that no cosmetic threads are added. It also describes default behaviors, constraints, and return values. This is highly transparent.

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

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

The description is well-structured with a clear sentence, workflow paragraph, bulleted args, return info, caveat, and examples. However, it is somewhat verbose; some details could be streamlined. Given the lack of schema descriptions, the verbosity is justified, but it could be tightened slightly.

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

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

With 10 parameters, no output schema, and no annotations, the description covers all essential aspects: parameter constraints, default behaviors, return structure, caveats, and example invocations. It also mentions the standard autoparts context. The agent has sufficient information to use the tool correctly.

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

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

Schema description coverage is 0%, but the description compensates fully. Each parameter is explained with units, allowed values (including enumerated thread sizes), defaults, and constraints (e.g., outer_diameter_mm must be > 0 and > tap-drill diameter). It even lists ISO tap-drill diameters. This adds significant meaning beyond the input schema.

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

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

The description clearly states that the tool builds a threaded boss (cylindrical boss with centered tap hole). It distinguishes from sibling tools like build_flange_boss and hole_wizard by mentioning that for cosmetic threads, one should use hole_wizard directly. The verb 'build' and the resource 'threaded boss' are 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 guidance: it references a 'Junior workflow' and gives example calls. It also includes a caveat explaining when not to use this tool (for cosmetic threads, use hole_wizard instead). This clearly differentiates when to use this tool versus alternatives.

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

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

No annotations provided, so description carries full burden. It describes the composition of multiple steps, partial failure caveat, and no auto-rollback. Also explains return values. Slightly lacking details on save behavior but overall 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?

Well-structured with purpose, workflow, args, returns, caveat, and example. Slightly verbose but every sentence adds value. Not overly concise but effective.

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

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

Given the complexity (composite tool, 5 parameters, safety concerns), the description covers purpose, parameters, returns, and a caveat. Could mention prerequisites like feature existence, but overall complete enough.

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 thoroughly: feature_name, dimension_name, variants mapping, parent_config (empty for root), activate_at_end (must be a key of variants). Adds significant meaning beyond schema.

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

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

The description clearly states the tool creates a family of configurations by changing a single dimension. It includes a concrete example and distinguishes from sibling tools like create_configuration and modify_dimension.

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

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

Provides a clear workflow example and explains when to use (changing one dimension). However, it does not explicitly state when not to use or mention alternatives, though the context implies batch creation.

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: read-only, images sent to Claude API, no redaction, temp file persistence, requirement for open document, error on unknown view, and no-op parameter. Comprehensive for a tool with no annotations.

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

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

Well-structured with sections (purpose, warning, cadence, args, returns, caveats, example). Slightly verbose with bilingual content but each sentence adds value.

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

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

Comprehensive coverage including purpose, usage patterns, parameter details, return format, privacy/security, file handling, and example. Fully compensates for missing annotations and 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?

Explains all three parameters beyond schema: valid view names, default, error behavior; with_dims as no-op for future compatibility; section parameter with detailed effect and offset sign. Compensates for 0% schema coverage.

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

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

Clearly states the tool renders active part or assembly to PNG screenshots for visual verification. Specifies read-only nature and distinguishes from mutation tools.

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

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

Provides explicit guidance on when to use (checkpoints/end of build) vs. not (after every feature), with alternatives like cheap signals and verify_build_report. Includes privacy warning and debugging 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?

With no annotations, the description carries full burden. It discloses failure modes (via fillet reference), batch-all-identical-edges rule, default values, parameter constraints, and return value. Very 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?

Well-structured with clear sections and example, but slightly verbose. Could be trimmed without losing meaning.

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

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

Covers usage, parameters, return value, and industry context. Lacks details on error handling and edge cases, but overall comprehensive given complexity (7 params, no 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?

Adds substantial meaning to most parameters (e.g., edge_midpoints_mm from list_edges, distance_mm typical values, angle_deg default). However, 'edge_circles' parameter is not explained, and schema coverage is 0%.

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 'bevel one or more edges (distance + angle)' with specific verb and resource. Distinguishes from sibling 'fillet' via explicit reference.

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 extensive guidelines: references fillet for identical rules, offers example, lists standard autoparts use cases, and mentions deferred types. Explicitly tells when to use and 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 reveals that the tool mutates the part, requires a reference axis, returns a new Feature with a name, and explains how count includes the original. It covers key behaviors like angle defaults and spacing options, though it could mention side effects (e.g., whether it modifies existing features).

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

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

The description is well-structured with a one-line summary, use cases, prerequisites, detailed parameter list, and examples. It is slightly verbose (e.g., repeated explanation of total_angle_deg in both text and example), but the organization makes it easy to parse.

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

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

Given 6 parameters, no output schema, and no annotations, the description is exceptionally complete. It includes prerequisites, parameter details, return value, and multiple examples covering common scenarios (bolt circle, partial arc). No major gaps are evident.

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 fully compensates by explaining all 6 parameters: feature_names (exact names from get_active_part_info), axis_name (from create_reference_axis), count (>=2, includes original), total_angle_deg (default 360, partial arcs), equal_spacing (True/False meaning), and reverse (direction). Examples clarify usage.

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 'repeat features around an axis' and lists standard autoparts uses (bolt circles, fan blades, etc.). It does not explicitly contrast with sibling tools like linear_pattern or mirror_feature, but the name and examples make the purpose unambiguous.

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

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

The description provides a clear prerequisite ('Always preceded by a create_reference_axis call') and explains when to use equal_spacing=False for 'every 30 degrees' cases. It lacks explicit exclusion of alternatives (e.g., when to use add_bolt_circle instead), but the examples illustrate typical usage patterns.

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 scope (Mexican-Spanish only), caveats (regional differences, ambiguous terms), version constraints (v1 fixed vocabulary, v1.1 extensible), and the exact return structure including a fallback for missing terms.

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 somewhat long but well-structured with sections for purpose, caveats, and example. The first sentence establishes purpose immediately. Every sentence adds value; however, minor trimming could enhance conciseness.

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 (single parameter, no output schema, no annotations), the description adequately covers all necessary aspects: purpose, input, output structure (with fields and example values), and usage context. It is self-contained and 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 single parameter 'term' lacks schema description (0% coverage), but the description explains it is case- and accent-insensitive and expects a Spanish/Spanglish autoparts term. An example is provided. Slightly more detail on expected format would push to 5.

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 resolves informal Mexican-Spanish autoparts terms into curated geometric archetypes, alternatives, and disambiguation questions. This distinctively sets it apart from sibling tools that perform CAD modeling operations.

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

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

The description explicitly tells the agent to call this tool 'when a user uses an informal autoparts term and before proposing a plan', referencing Phase 2/Layer 2. It gives an example ('rin') and details the disambiguation flow.

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 fully bears the burden. It discloses default behavior (refuses dirty docs), force behavior (silent discard), underlying API verbs (CloseDoc vs QuitDoc), return dict fields, raised errors, and an example. This is highly transparent.

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

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

The description is well-structured with Args, Returns, Raises, and Examples sections. It is slightly verbose due to bilingual (Spanish/English) content, but every sentence adds value. The English part alone is clear and 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 no output schema, the description covers return fields, errors, parameter semantics, and examples. It fully explains behavior, prerequisites, and edge cases, 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?

Schema_description_coverage is 0%, so the description must compensate. It explains the single 'force' parameter in detail: default false raises error if dirty, true discards changes. It also warns about using force only when doc is disposable and notes the underlying API distinction.

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 closes the active SolidWorks document, with a specific verb and resource. It distinguishes from siblings by contextualizing its role in iterative build/save/close flows, contrasting with save_as failure when windows pile up.

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 describes when to use: in iterative build/save/close flows. Provides default behavior (refuses if dirty) and force=True usage with a warning. Includes an example flow showing canonical usage and a force-close example, offering clear guidance.

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

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

No annotations are provided, so the description carries the full burden. It clearly states the tool does not mutate SolidWorks and returns tool names and parameters. However, it lacks details on error handling (e.g., missing drawing_spec_id), rate limits, or return format specifics.

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

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

The description is extremely concise: two sentences that front-load the core purpose, then add behavioral context and supported archetypes. Every sentence adds value 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?

Given the single parameter, lack of annotations, and no output schema, the description could be more complete. It states supported archetypes but does not mention prerequisites (e.g., a recorded DrawingSpec), behavior for unsupported archetypes, or the format of the returned plan. Some gaps remain.

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

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

The input schema has 0% description coverage (no parameter descriptions). The tool description does not compensate: it only mentions 'stored DrawingSpec' indirectly, with no explanation of what drawing_spec_id is, how to obtain it, or its format. This is a critical gap given the low schema coverage.

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

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

The description clearly states the tool's function: 'Compile a stored DrawingSpec into an ordered FeaturePlan.' It uses a specific verb and resource, and distinguishes itself from siblings like run_feature_plan by noting it is 'Advisory only' and does not mutate SolidWorks.

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

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

The description explicitly states when to use this tool ('Advisory only' for planning without execution) and lists supported archetypes. However, it does not explicitly state prerequisites (e.g., requiring a previously recorded DrawingSpec) or when to avoid using it in favor of alternatives.

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

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

With no annotations, the description fully explains behavior: angle convention, direction flag's counter-intuitive effect, return value, and caveat. No behavior is left unspecified.

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

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

Well-structured with sections, though somewhat verbose. Every sentence adds value, but could be slightly trimmed. Still very effective.

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

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

Given no annotations, no output schema, and complex behavior, the description is fully complete—covers arguments, returns, use cases, examples, and prerequisites.

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

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

Schema coverage is 0%, but the description compensates by detailing every parameter, including constraints (radius positive, angles different) and aliases. Examples illustrate usage.

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 draws a center-defined arc on the active sketch, distinguishing it from siblings like create_circle and create_slot.

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

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

It provides explicit when-to-use guidance (slot end-caps, fillets, profiles) and when-not-to (use create_circle for full circles). Also mentions prerequisite (active sketch via create_sketch).

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 behavioral traits: requires an active sketch, the circle geometry is non-parametric (modify_dimension cannot resize), and rebuilding from a fresh part is needed for resizing. It also mentions return values, providing complete transparency.

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

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

The description is well-structured with a clear main sentence, parameter details, example, and caveats. The bilingual caveat adds length but serves multilingual users. Overall efficient and front-loaded with the core 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 5 parameters, no annotations, no output schema, and low schema coverage, the description covers purpose, parameters, usage, behavioral traits, and alternatives comprehensively. The return value indication and example complete the 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 has 0% description coverage, but the description thoroughly explains each parameter: cx_mm/cy_mm as center point, radius_mm as radius with positivity constraint, and long-form aliases. It clarifies that only one name per axis should be passed, adding essential meaning beyond the schema.

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

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

The description clearly states the tool draws a circle on the active sketch with a specific verb and resource. It distinguishes from the sibling tool add_bolt_circle by suggesting the latter for multiple holes, enhancing clarity.

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

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

The description provides clear context for usage, including an example, parameter constraints, and a recommendation to use add_bolt_circle for bolt patterns. However, it does not explicitly state when not to use the tool, but the context is sufficient.

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, but description adds crucial behavioral context: creating a configuration activates it (changes active config), and it is idempotent. The 'Gotcha' section highlights a live-verified side effect.

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 sections (description, args, gotcha, related tool), front-loaded with purpose. Slightly long but not verbose.

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

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

Given no output schema and no annotations, the description covers the tool's purpose, side effects, parameter semantics, and alternatives. Fully adequate for agent to select and invoke correctly.

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

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

Schema coverage is 0%, so description compensates by explaining each parameter: name is unique and idempotent, parent is for derived configs, description is optional. Adds meaningful context 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?

The description clearly states 'Crear una configuración nueva en la pieza o ensamble activo' with specific verb and resource. It distinguishes from sibling tool build_variant_family by explaining when to use that alternative.

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 provides when to use build_variant_family instead of create_configuration, and mentions idempotency for name. Gives clear context for 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?

Discloses return value (geometry endpoints+length), non-parametric nature of sketch, and that modify_dimension only affects extrusion depth. No annotations provided so description carries full burden; could mention if line can be edited by other means.

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, args, return, usage, caveats. However, includes redundant bilingual text (Spanish and English) for the same caveat, making it longer than necessary.

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

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

Covers prerequisites (active sketch), return value (geometry), param semantics, and key limitation (non-parametric). No output schema but return described. Sufficient for a simple line 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?

0% schema coverage, so description compensates by explaining x1_mm/y1_mm as start point, x2_mm/y2_mm as end point, units in mm, and sketch-local frame. Adds meaningful context 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?

Clear verb 'Draw' and resource 'line on active sketch'. Distinguishes from sibling tools like create_rectangle, create_arc by specifying it's for lines.

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 states prerequisite (active sketch via create_sketch), use case (building block for non-rectangular profiles before extrusion), and limitation (not parametric, must rebuild for resizing). Provides alternative 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 provided, so description carries full burden. Describes that rectangle is added to most recent sketch, returns geometric properties, and includes caveats about non-parametric dimensions (modify_dimension cannot resize). Could be slightly more explicit about error behavior if no active sketch.

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 sections (Args, Returns, Example, Caveats, Related). Concise but includes necessary details. Slightly verbose due to bilingual caveat, but still 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?

With no output schema, description mentions return of geometric properties (width and height). Covers prerequisites, usage, and limitations. Lacks exact return format but sufficient 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?

Schema coverage is 0%, but description fully explains parameters: two corner coordinates (x1_mm, y1_mm and x2_mm, y2_mm). Provides an example tying parameters to real-world usage, adding meaning beyond the schema.

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

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

The description clearly states it draws a corner-defined rectangle on the active sketch, specifying the resource (rectangle) and action (create). It distinguishes from sibling tool 'build_rectangular_pocket' which combines sketch and cut.

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 mentions requirement for an active sketch via 'create_sketch first'. Provides related tool 'build_rectangular_pocket' as an alternative for rectangular pockets. Gives clear context for when to use this tool.

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

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

No annotations provided, so description carries full burden. Discloses behavior: two modes, world-axis mapping, and limitations of single-reference. Lacks error handling details but is otherwise 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?

Well-structured with headings, table, and example. Somewhat long but every sentence adds value. Slight room for trimming.

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?

Complete for a tool with 2 params, no output schema, and no annotations. Covers all aspects: modes, usage, output format, example, and internal 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?

Compensates for 0% schema coverage with detailed parameter explanations, including naming conventions and examples. Clearly explains reference_name and reference_2 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 creates a reference axis from two planes or a single feature. It distinguishes the two modes and provides a use case, differentiating it from sibling tools like create_reference_plane.

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 explains when to use each mode: two-plane recommended for v1, single-reference limited. Provides a use case for circular_pattern and warns about limitations of single-reference mode.

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 behavioral disclosure burden. It explains that the plane is parallel to a source, offset is signed (zero rejected), positive/negative direction meanings, and return value (name, parent, offset). It also mentions testing for negative offsets, providing confidence in behavior.

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

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

The description is well-structured with headings and bullet points, front-loading the purpose. However, it is somewhat verbose (e.g., Spanish UI names and a cryptic testing note). For a complex tool, it's acceptable, but minor trimming could improve conciseness.

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 output schema, and no annotations, the description is exceptionally complete. It covers all modes, parameter details, return value, use cases, and even provides code examples with list_faces integration. An agent has everything needed to use the tool correctly.

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

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

Schema coverage is 0%, so the description must fully explain parameters. It does so thoroughly: offset_from lists allowed plane names (English and Spanish), offset_mm explains sign and zero rejection, face_centroid_mm is described as a 3-element array from list_faces. Examples illustrate usage, meeting the high burden.

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

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

The description clearly states the tool creates a reference plane parallel to a default plane or face, distinguishing two modes (default-plane and face mode). It explicitly contrasts with sibling tools like create_reference_axis and mentions deferred methods, making the purpose 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 when-to-use guidance for each mode: default-plane for rib offsets and fixture-clearance planes; face mode for counterbore-on-flange-top and hole patterns. It also specifies when not to use (angled/through-3-points are deferred) and includes a caveat, leaving no ambiguity 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?

No annotations are provided, so the description bears full responsibility. It discloses that the sketch is left in 'EDIT mode', returns the sketch name and resolved plane name, and includes important caveats about document type.

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: purpose first, then argument details, then return value, then caveat. Every sentence adds value; 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?

For a single-parameter tool with no output schema, the description fully explains the return values, post-conditions (EDIT mode), and necessary context (part document). It also mentions subsequent steps, making the tool's role in a workflow clear.

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 for plane_name. The description adds extensive detail: lists the allowed values (front/top/right, plus Spanish equivalents), notes case sensitivity, and specifies lowercase English. This fully compensates for the schema gap.

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

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

The description clearly states 'Start a new sketch on a named reference plane.' It uses a specific verb ('Start') and resource ('sketch on named reference plane'), distinguishing it from similar tools like create_sketch_on_face which creates on a face.

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

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

The description explicitly states the prerequisite: 'requires a part document (not assembly). Open a fresh part via SW UI before calling.' It also provides a sequence of use: create_sketch -> create_rectangle -> extrude_sketch, giving clear when-to-use guidance.

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

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

No annotations provided, so description carries full burden. It discloses behavior like default extrude direction (into body), axis mapping non-intuitive behavior, failure modes, and requirement for face visibility.

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, front-loaded with a clear summary, then detailed sections for arguments, returns, gotchas, failure modes, and example. Every sentence adds value; appropriate length for complexity.

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?

Complete for a complex tool with no output schema: describes return values (name, face_centroid_mm, body_name, sketch_axis_mapping with schema), common uses, gotchas, failure modes. No gaps.

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

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

Despite 0% schema description coverage, the description extensively elaborates on both parameters (selector and face_centroid_mm) with syntax, closed schema, and mutual exclusivity, fully compensating.

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 starts a new sketch on a body face, distinguishing from create_sketch (default planes only). It specifies the verb 'start' and resource 'sketch on a body face', and contrasts with sibling tool.

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 (face on existing body) vs create_sketch (default planes). Includes guidance on selector vs face_centroid_mm, gotchas about extrude direction and axis mapping, and failure modes.

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 discloses the slot geometry, the parametric constraint (non-driving dimensions), and the active sketch requirement. It does not mention return value or side effects like sketch closure, but the major behavioral trait (non-parametric) is well covered.

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

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

The description is verbose, including bilingual text (Spanish and English) which adds redundancy. While the content is valuable, it could be more concise. The key information is front-loaded, but the Spanish repetition detracts from conciseness.

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, no output schema, and no annotations, the description covers geometry, parameter semantics, usage context, and a critical behavioral caveat (non-parametric dimensions). It lacks error conditions or return value, but these are partially expected without output schema. Overall 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 coverage is 0%, so description must explain parameters. It does so with a docstring-like list: x1_mm, y1_mm, x2_mm, y2_mm as center-line endpoints and width_mm as slot width. This adds meaning beyond the bare schema titles and compensates for lack of parameter descriptions.

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

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

The description clearly states 'Draw a straight slot on the active sketch' and explains the geometry (rounded-rectangle with semicircular end-caps). It distinguishes this tool from sibling sketch tools like create_rectangle or create_circle by specifying the slot shape and common autoparts use.

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 a concrete usage example (adjustable bolt slots) and explicit caveats: requires active sketch and the parametric limitation that modify_dimension cannot resize width/endpoints. It doesn't explicitly contrast with alternatives but implies specialized slot creation.

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, but the description fully discloses the safe nature of configuration deletion (pure metadata, no cascade), preconditions, and return value, ensuring the agent understands the behavior.

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

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

Well-structured with front-loaded purpose, constraints, and use case. Slightly lengthy due to bilingual text, but each sentence adds value.

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

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

Given no output schema, the description explains the return value ('deleted configuration name') and covers all relevant aspects: purpose, preconditions, safety, and example use cases. Completeness is high for a simple deletion 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?

Only one parameter 'name' with schema coverage 0%, but the description clarifies 'The configuration to delete', which adds meaning beyond the schema title. Slightly lacking format details but sufficient for a single parameter.

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

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

The description clearly states 'Delete a configuration from the active document' and explicitly distinguishes itself as the ONLY deletion tool in v1 MCP, unlike sibling tools that include other 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?

Provides explicit use case (cleanup of obsolete trim variants) and prerequisites (configuration exists, not active, not only one), along with an alternative action (activate a different configuration 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 provided, so the description carries the full burden. It discloses that the COM driver degrades to feature-tree dims and through/depth may be None. It also warns about locale sensitivity for the feature_name parameter, providing essential behavioral context beyond a simple read operation.

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

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

The description is well-structured with a brief intro, return fields, usage context, and parameter details. It is fairly long but each sentence adds value. Slightly more concise formatting could improve readability, but it is not verbose.

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

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

Given only one parameter, no output schema, and no annotations, the description is highly complete. It explains return values, differences in execution contexts (add-in vs COM), and parameter specifics, fully covering what the agent needs to use the tool correctly.

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

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

The input schema has 0% coverage (no description for the parameter). The description compensates fully by explaining that 'feature_name' must be the exact name from get_active_part_info, verbatim, locale-sensitive, and never translated. This adds critical meaning beyond the schema.

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

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

The description clearly states the tool 'read a built feature's definition' and lists specific return fields (name, type, found, through, depth_mm, internal, source). It is specific and distinguishes from siblings like get_feature_inventory or get_active_part_info by focusing on describing a single feature's definition.

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 context by stating it is 'used by verify_build_report to tell a through-hole from a blind one and read its depth'. It also explains the rich path vs COM driver degradation. However, it does not explicitly state when not to use this tool or mention alternatives, though the 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?

No annotations provided, so description covers all behavioral aspects: no rebuild, effect on other tools, return value (editing=True), and caution about sketch staying open. Also mentions specific future behavior (SW 2026 ES). No contradictions.

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

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

Bilingual text adds length, but each sentence adds value. Front-loaded with purpose, then usage, argument, return, warnings, and related tools. Minor redundancy due to translation but still effective.

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

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

Despite no annotations or output schema, the description covers all essential information: purpose, usage, parameter, return, behavior, warnings, and related tools. Nothing significant is missing.

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

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

The schema has 0% description coverage, but the description adds the parameter's meaning: exact sketch name with an example ('Croquis1'). This fully compensates for the lack of schema description.

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

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

The description clearly states the verb (reopen/edit), resource (sketch), and scope (without rebuilding). It distinguishes from siblings like create_sketch and modify_dimension, making the tool's purpose unambiguous.

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

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

Explicit when-to-use (editing existing sketch) and when-not-to-use (alternatives like modify_dimension for dimensions). Includes a typical CSWA use case and warns that the sketch remains open until a consuming operation closes it.

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

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

With no annotations provided, the description fully discloses behavioral traits: it suppresses redraw, feature tree, and rebuild during processing, performs one rebuild at the end, and enforces all-or-nothing semantics with rollback on failure. It also details the verify parameter options and advises against per-feature rendering. The return structure for both success and failure is described, providing complete 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 structured with a main explanation, an English summary, an Args section, and additional notes on semantics and return values. It is comprehensive but not overly verbose, though it could be slightly more concise. The key concept is front-loaded, and the organization aids 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 no output schema, the description thoroughly covers return values, error handling, and behavioral aspects. It provides all necessary information for correct usage, including restrictions on operations and the all-or-nothing rollback mechanism. The sibling tools list includes many individual low-level operations and composite builders, and this tool's description clearly positions it as the batch primitive complementing those.

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, so the description carries full burden. It adds crucial semantics: ops must be an array of objects with 'tool' (protocol operation name) and 'args' (matching exact parameter names), and clarifies which operations are allowed. verify is explained with its 'summary' vs 'none' options, and rebuild is described regarding rebuild suppression. This far exceeds the schema's minimal information.

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

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

The description clearly states that the tool executes an ordered list of low-level operations in a single pass, following a 'compile once, build once' approach like build123d. It distinguishes from separate calls by emphasizing efficiency gains, and explicitly states that it cannot invoke arbitrary API or composite build_* operations, making its purpose very specific and distinct 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 provides explicit guidance: use this tool instead of N separate calls for efficiency, ensure each operation is a protocol operation (not composite or perception/IO), and avoid nesting batch calls. It explains the parameters rebuild and verify with appropriate defaults and recommendations. However, it does not explicitly state when not to use it beyond the restrictions, which is sufficient for an advanced tool.

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

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

No annotations provided, so description carries full burden. It clearly states prerequisites (active sketch, intersecting material), failure behavior (sketch reopened), and caveats (bug with reference planes in up_to_surface). Returns a Feature with name, type, dimensions.

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 sections (Args, Returns, Caveat, Failure recovery, Example, Related composites) and front-loaded with the core action. It is somewhat verbose given the complexity but remains organized and readable.

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 9 parameters, no output schema, and complex interactions, the description covers all necessary context: failure modes, edge cases, parameter dependencies, return value, and even a known bug workaround. It is thoroughly complete.

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

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

Schema description coverage is 0%, but the description provides detailed explanations for all 9 parameters, including meaning, defaults, interactions (e.g., depth_mm ignored for certain end_conditions), and workarounds. This far exceeds the baseline expectation.

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 cuts material from a part, exiting the active sketch. It provides specific verb+resource ('cut material from the part') and distinguishes from siblings like extrude_sketch (adds material) by contrast in examples.

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 extensive guidance on when to use each end_condition with examples (bolt holes, slots, etc.) and mentions related composites (build_rectangular_pocket, add_bolt_circle). It does not explicitly state when not to use this tool vs alternatives but covers usage context well.

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

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

With no annotations, the description fully carries the burden. It discloses the sketch is closed after extrusion, the feature is a new solid, the effect of reverse_direction on face-anchored sketches, merge behavior, and the return type (Feature with name, type, dimensions). It also warns about open/self-intersecting profiles and automatic re-opening on failure.

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

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

The description is well-structured with headings (Args, Returns, Caveat, Failure recovery, Example) and is front-loaded with the main action. While every sentence adds value, it is somewhat lengthy; minor trimming could improve conciseness 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 no output schema, the description details the return value (Feature with name, type, dimensions). It covers prerequisites (closed profile), failure modes (reopening), and provides two examples showing typical usage and advanced multi-body case. Complete for a 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 compensate. It thoroughly explains each parameter: depth_mm (positive), end_condition (blind vs. through_all with note that depth_mm ignored), reverse_direction (default direction and gotcha for face-anchored sketches), and merge (default True, when to use False for multi-body). Examples illustrate usage, adding significant meaning beyond the schema.

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

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

The description clearly states the tool exits the active sketch and extrudes it as a boss (solid) feature. It distinguishes itself from siblings like build_flange_boss (which combines sketch and extrude) and explicitly mentions other related tools (revolve_sketch, sweep_sketch, shell_part) and a missing feature (loft).

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

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

The description provides explicit guidance on when to use the tool: after creating a sketch with at least one closed profile. It details failure recovery (sketch reopens on failure) and offers alternatives (e.g., use build_flange_boss for combined sketch+extrude, not for loft). It also explains parameter nuances like merge=False for multi-body workflows.

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 failure modes (midpoint mismatch, radius too large), non-parametric nature, batching advice to avoid body name shifts, and propagation behavior (tangent_propagation). No contradictions.

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

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

The description is front-loaded with purpose and key usage, followed by structured sections: selector explanation, args, returns, failure modes, caveats. Every sentence adds value, and the length is justified by the tool's complexity.

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

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

Given no output schema, the description covers inputs, failure modes, and caveats adequately. It lacks details on the return object beyond name and type, and omits the 'edge_circles' parameter. Slight incompleteness for a complex 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 the description adds extensive semantics for most parameters: typical radius values, selector schema, edge_midpoints usage, edge_indices format, tangent_propagation effect. However, the parameter 'edge_circles' (present in schema) is not mentioned in the description, leaving a gap.

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

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

The description clearly states 'fillet (round) one or more edges, constant radius' with specific verb and resource. It distinguishes from sibling 'fillet_all_edges' by focusing on specific edges and explains alternative edge addressing methods (selector, edge_midpoints, edge_indices).

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

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

The description provides explicit guidance on when to use selector vs edge_midpoints vs edge_indices, including recommendations (e.g., 'selector recommended') and exclusions (e.g., variable-radius deferred). It also explains mutual exclusivity of selector and edge_* args.

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