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

With no annotations provided, the description carries the full behavioral burden. It discloses the creation/extrusion workflow, units in millimetres, the returned feature name, the depth dimension handle 'D1@<name>', and the dimensions structure for set_dimension. It does not mention preconditions like needing an active part, but the main behavioral contract is clearly stated.

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

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

The description is compact and front-loaded: the first sentence states the core action and method, while the second provides only high-value details about units and return values. Every sentence earns its place with no redundant wording.

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

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

Given the simple primitive shape, four parameters, and no output schema, the description is nearly complete: it covers operation, units, return values, and an integration hint for set_dimension. It could be more explicit about the active-part requirement, but the essential call context is present.

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 usefully explains that dimensions are in millimetres and maps width/height to the sketch and depth to the extrusion. However, the optional 'name' parameter is not explicitly described, and the meaning of the returned 'dimensions' array is mentioned only as output context.

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

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

The description names a specific verb and resource: 'Add a rectangular block', then details the construction method (sketch width x height, extrude by depth). This clearly distinguishes it from sibling primitive tools like add_disc, add_cylinder, and add_extruded_profile.

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

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

Usage context is implied by the 'rectangular block' phrasing, so an agent can infer it is for box-like solids. However, there is no explicit guidance on when to prefer this tool over alternatives like add_extruded_profile, nor any mention of exclusions or prerequisites.

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

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

With no annotations, the description carries the transparency burden. It discloses the mutating nature ('Chamfer edges of the current part'), the return value, and the dependency on list_edges for edge indices. It stops short of stating side effects such as irreversibility or failure behavior when edges are invalid or exhausted.

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

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

The description is compact and front-loaded: the core action appears in the first sentence, followed by essential edge-value semantics and the return summary. Every sentence adds useful information with no filler.

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

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

For a three-parameter CAD mutation with no output schema, the description covers the required distance, accepted edge selectors, the dependency on list_edges, and what is returned. It lacks only edge-case details such as behavior without an open part or with empty edge selections, which are unlikely to be blockers 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 coverage is 0%, so the description must compensate, and it does for two of the three parameters: it explains that distance_mm is the chamfer distance in millimeters and fully specifies the edges parameter with 'all', axial shortcuts, and list_edges indices. The optional name parameter is not explained, but it is a minor labeling field with a schema default.

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

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

The description uses a specific action ('Chamfer edges') and identifies the exact resource ('the current part'), plus the fixed 45° angle and mm distance. This clearly distinguishes it from sibling operations like add_fillet, so an agent can select it without inspecting the schema.

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

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

The edge-selection paragraph and the reference to list_edges provide practical context for when and how to invoke the tool. However, it does not explicitly state when to prefer this over alternatives such as add_fillet, nor does it state exclusions or prerequisites beyond 'current 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?

No annotations are provided, so the description carries the burden. It discloses a key behavioral trait: the axis is determined by the cylindrical face nearest to (center_x_mm, center_y_mm), and `feature_name` defaults to the last feature. However, it doesn't mention whether the operation is destructive, requires a rebuild, or what happens if no cylindrical face is found. These are gaps, but the disclosed axis-selection behavior is valuable.

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

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

The description is compact and front-loaded. The first sentence states the core behavior, the second explains the axis selection heuristic, and the third gives a practical example. Every sentence earns its place with no fluff.

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

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

For a 4-parameter tool with no output schema and no annotations, the description covers the essential semantics and provides a usage example. It doesn't specify error cases (e.g., no cylindrical face found) or whether the pattern is associative/parametric, but the core information needed to invoke the tool correctly is present.

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 meaning of `count` (repeat count around 360°), `center_x_mm`/`center_y_mm` (used to find the nearest cylindrical face), and `feature_name` (defaults to last feature). This adds significant meaning beyond the raw schema, which only provides types and titles.

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

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

The description clearly states the tool's function: repeating a feature `count` times around 360° about an axis. It specifies the resource (feature), the operation (repeat/pattern), and the key parameters (count, center coordinates). It also distinguishes itself from the sibling `add_linear_pattern` by explicitly describing a circular pattern around an axis.

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: 'Bolt circle: drill a centre hole + one bolt hole, then pattern the bolt hole.' This implies when to use the tool and how to set it up. It doesn't explicitly state when not to use it or name alternatives like `add_linear_pattern`, but the circular-vs-linear distinction is clear from the name and description.

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

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

There are no annotations, so the description must carry the behavioral burden. It discloses the construction method, the special full-cone case, and that the tool returns mass properties with a volume formula. It omits placement/orientation and failure behavior, but the core behavioral profile is clear.

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

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

The description is compact and front-loaded: the main action appears first, followed by the key parameter case, return value, and prerequisite. Every sentence adds useful information with no filler or redundancy.

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

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

Given no annotations, no output schema, and no schema-level parameter descriptions, the description covers the essential call context: what the tool creates, when the shape is a cone vs. frustum, what it returns, and the need for a new part. It could add placement/orientation and numeric validity constraints, but an agent can likely invoke it correctly as written.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by explaining top_diameter_mm = 0 and giving a volume formula that ties height, bottom radius, and top radius together. The optional name parameter and the rb/rt notation are not detailed, but the required geometry is interpretable.

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

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

The description states a specific verb and resource: it creates a cone/frustum by revolving a trapezoidal profile 360°. This directly distinguishes it from sibling tools like add_cylinder, add_disc, and add_revolved_profile.

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 gives an explicit prerequisite ('Use new_part first') and clarifies the cone vs. frustum distinction via top_diameter_mm = 0. It does not explicitly name sibling alternatives or say when to prefer add_cylinder, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden. It explains the cut geometry, the coaxial flat-bottom pocket, the through-thickness clearance shank, the coordinate system sharing add_box's system, and that mass properties are returned. This gives the agent a solid behavioral model, though it doesn't mention prerequisites like an active part or irreversibility.

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

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

The description is compact and front-loaded. The first sentence states the core action, the second explains the geometry and use case, and the third adds the constraint and coordinate system. Every sentence adds value; there is no filler.

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

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

Given the lack of annotations and output schema, the description covers the essential context: what is created, where, how, common use, parameter relationships, coordinate system, and return value. It could be more explicit about active-part requirements and when a simpler hole tool should be used, but it is largely complete for invoking 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 compensate. It does: clearance_diameter and cbore_diameter are semantically explained as clearance shank and counterbore pocket, cbore_depth is described, x_mm/y_mm are tied to the +Z face, and the constraint 'cbore_diameter must exceed clearance_diameter' is explicitly stated. Only the optional name parameter is not described, which is acceptable.

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

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

The description opens with a specific verb and resource: 'Cut a counterbored screw hole on the +Z face at (x_mm, y_mm).' It clearly distinguishes this from generic hole tools like add_hole or add_hole_on_face by describing the counterbore geometry, making it unambiguous what operation is performed.

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 usage context: it is for cap-head screws or heat-set inserts that need to sit flush/recessed, common for 3D-printed parts. It does not explicitly name alternatives or state when not to use it, but the use case is concrete enough to guide selection.

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

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

No annotations are present, so the description carries the burden. It discloses that the tool returns mass properties including the volume formula, and hints at state requirements with 'Use new_part first.' However, it does not describe side effects on the current part, placement/axis orientation, or failure behavior.

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

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

Three short sentences, purpose first, no filler. 'The first revolve-based primitive' adds positioning context but is somewhat vague; overall it is efficient.

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

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

For a creation tool with no annotations and no output schema, it leaves important gaps: default axis/orientation, units, placement, and behavior when no part exists. It covers purpose, prerequisite, and return value, but not enough for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it only gives a volume formula using r while the schema parameter is diameter_mm. It does not explain diameter_mm, height_mm, or the optional name parameter beyond their names.

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

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

States a specific action ('Create a cylinder by revolving a profile 360° about an axis') with the resource and construction method. It is clear, though it does not explicitly differentiate from sibling add_revolved_profile beyond calling itself 'the first revolve-based primitive.'

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 prerequisite ('Use new_part first') and implies it is the primitive form of revolve, but does not state when to choose it over add_revolved_profile or other primitives like add_disc/add_cone. No exclusions or alternative conditions are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states the geometry, the centered-at-origin placement, the +Z extrusion direction, the flat face orientations, the return of mass properties, and the prerequisite of new_part. This is strong transparency for a creation tool.

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

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

The description is compact and front-loaded, with no filler. The geometric definition comes first, followed by composition guidance and the prerequisite, and every sentence earns its place.

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

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

For a simple three-parameter creation tool with no annotations or output schema, the description covers orientation, face placement, composition with other tools, return value, and the required first step. Very little is missing that an agent needs to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It implies that diameter_mm controls the circle and thickness_mm controls the extrusion, but it never explicitly names these parameters or explains the optional name default. This is partial but not complete compensation for the missing schema descriptions.

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

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

The description opens with a specific verb and resource: 'Create a disc/puck/flange: a circle extruded along +Z, centred at the origin.' This makes the tool's core function unambiguous and distinguishes it from sibling extrusion tools by specifying orientation and placement.

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 gives clear usage context: 'Use new_part first' and explains that the flat ±Z faces make add_hole and add_circular_pattern compose with it for bolt circles. It does not explicitly contrast with alternatives like add_cylinder, but the provided context is enough to guide selection.

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

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

With no annotations, the description carries the behavioral burden and does substantial work: it discloses auto-closure of the polygon, first-plane coordinates, extrusion by depth_mm, and return behavior with a volume formula. It does not mention edge cases like self-intersecting polygons or extrusion direction, but the disclosed behavior is meaningful.

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

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

Three focused sentences with no filler. The core action and input format are front-loaded, and the secondary details (auto-closing, coordinate plane, returned mass properties) each earn their place.

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

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

Despite having no output schema and no annotations, the description covers the key facts an agent needs: input format, units, closure behavior, coordinate system, and return value. Minor gaps remain around the name parameter and extrusion direction, but the description is reasonably complete for this tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains points_mm as '[[x,y], ...] in mm', notes the polygon is auto-closed, and clarifies depth_mm as the extrusion amount, including how it affects volume. The optional name parameter is not explained, but the required parameters are well covered.

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

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

The description opens with a specific verb and resource: 'Extrude a closed polygon into a solid', followed by concrete input syntax. It distinguishes itself from siblings by emphasizing polygon/prismatic shapes (vs. splines or primitive boxes) and explicitly references add_box for coordinate conventions.

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 clear usage context: 'Unlocks arbitrary prismatic shapes (brackets, profiles, polygons)' tells an agent when this tool is appropriate. It does not explicitly name alternatives such as add_extruded_spline or state when not to use it, but the context is strong enough for routing.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the spline is auto-closed, that volume is measured rather than analytic, and that mass properties are returned. It also notes the prerequisite of new_part. These go beyond the schema and give useful 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?

Three sentences, no fluff. The first sentence states the action and inputs, the second differentiates from a sibling, and the third covers a key behavioral note and return value. Every sentence earns its place.

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

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

No output schema exists, so the description must explain returns; it does ('Returns mass properties'). It also notes the measured volume. It lacks details on potential errors or edge cases, but for a creation tool with clear prerequisites and behavior, it is reasonably 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 the description must compensate. It explains the format of points_mm ([[x,y], ...] in mm) and that depth_mm is the extrusion depth. It does not describe the optional name parameter, but that is minor. The main required parameters are well explained.

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

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

States a specific verb+resource: extrude a smooth CLOSED spline through points. It clearly distinguishes itself from the sibling add_extruded_profile by specifying the smooth curve nature, and mentions the inputs and output. An agent can immediately understand what it does and how it differs.

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 direct contrast with add_extruded_profile ('Like add_extruded_profile but...') and gives examples of use cases (cams, rounded outlines, aesthetic bosses). Also instructs 'Use new_part first.' It doesn't explicitly list when not to use other tools, but the main alternative is clearly differentiated.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the operation applies to the current part, uses a single constant radius, and returns the number of filleted edges and resulting mass properties. It does not mention irreversibility or failure modes, but the key side effects and outputs are visible.

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

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

Three sentences cover purpose, edge syntax, and return value with no fluff. The most important selection semantics are front-loaded immediately after the one-line 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?

For a mutating CAD tool with no output schema and no annotations, this is nearly complete: purpose, edge modes, defaults, and return behavior are all present. The only gap is the absence of any note about the optional name parameter or explicit prerequisites beyond 'current part'.

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 the non-obvious edges parameter syntax ('all', x/y/z, explicit indices) and notes that radius is in mm. Only the optional name parameter is left undocumented.

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

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

The description opens with a specific verb ('Round') and resource ('edges of the current part'), and clarifies that it uses one constant radius in mm. It is clearly distinct from the sibling add_chamfer by operation intent, but it does not explicitly name alternatives, so sibling differentiation is implicit rather than explicit.

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

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

The edge-selection instructions and the reference to list_edges imply a practical workflow for operating on an existing part. However, it does not state when to prefer this over add_chamfer or other modification tools, nor does it give prerequisites or exclusions.

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

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

With no annotations, the description carries the transparency burden. It discloses the through-thickness behavior ('runs straight through the thickness'), the orientation relative to the profile face, the coordinate system with an example, and the fact that mass properties are returned. It does not cover prerequisites or failure behavior when a part is absent, but the essential runtime behavior is clear.

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

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

Two sentences, front-loaded with the main action and geometry, with supporting coordinate detail kept to a second sentence. No filler.

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

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

For a simple hole primitive, the description covers geometry, orientation, coordinate frame, and return value, and the optional name has a schema default. The exact mass-properties payload is unspecified because no output schema exists, and no alternative-selection guidance is given, leaving minor gaps.

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

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

Schema coverage is 0%, so the description must compensate. It adds real meaning to x_mm and y_mm ('share add_box's system... centre of a 40x20 profile is x=20, y=10'), but diameter_mm receives no constraints or unit clarification beyond its name, and the optional name parameter is ignored.

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

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

The description names a specific operation ('Cut a circular through-hole') and locates it in the part geometry ('at (x_mm, y_mm), through the part's depth axis'). The 'through-hole' and 'depth axis' wording distinguishes it from sibling hole variants like add_counterbore_hole and add_hole_on_face even without naming them.

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

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

Usage context is implied by the geometry described: a circular through-hole along the depth axis in the same coordinate system as add_box. It never states when to choose this over add_counterbore_hole/add_hole_on_face or notes prerequisites such as a part already existing.

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

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

With no annotations, the description carries the full burden of explaining behavior. It clearly states the tool drills a through-hole, requires the center to lie on the face, and returns mass properties. It does not discuss failure modes or in-place modification details, but the primary operational effect is explicitly disclosed.

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

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

The description is compact and well-structured: main action first, then parameter semantics, then use cases, then output. Every sentence adds necessary information without redundancy or filler.

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

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

The description is nearly complete for a tool with no output schema or annotations: it explains what is drilled, where the hole is centered, how faces are specified, what use cases it supports, and what it returns. It could be more complete by naming add_hole as an alternative and describing error behavior when the center is not on the face, but the core invocation needs are covered.

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

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

Schema description coverage is 0%, so the description must compensate. It defines the face values, states that coordinates are global and in mm, and adds the 'must lie on that face' constraint. It does not explicitly document the diameter parameter, though the schema's 'diameter_mm' name makes it reasonably self-explanatory.

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

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

The description opens with a precise verb-plus-resource statement: 'Drill a through-hole on ANY planar face'. It then defines the exact face identifiers and coordinate constraint, making the operation unambiguous. This clearly differentiates it from generic hole tools like add_hole by emphasizing face selection and global 3D positioning.

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 concrete use cases: 'Enables side holes and bolt circles on cylinder end-faces'. It tells an agent when this tool is valuable. However, it does not explicitly name sibling alternatives or state when not to use it, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool returns mass properties and that feature_name defaults to the most recently added feature, which is useful. However, it does not mention that the operation modifies the part, what happens on invalid feature names, or any potential side effects, leaving gaps in transparency.

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

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

The description is compact and efficient: a one-sentence purpose statement followed by parameter details. It front-loads the core operation and every sentence contributes useful information—no filler, digressions, or redundant repetition of the tool name.

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

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

Given 4 parameters, no annotations, and no output schema, the description covers all parameters and explicitly states the return value (mass properties). It is largely sufficient for an agent to call the tool correctly. However, it omits explicit statements about model mutation and failure conditions when no feature exists, which would be valuable for full completeness.

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

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

Schema description coverage is 0%, so the description is the sole source of parameter meaning. It explains all four parameters: count (times), spacing_mm (distance apart), direction (with examples like '+x'/'-x'+y'), and feature_name (with default behavior). This adds substantial semantic value beyond the bare schema, making correct invocation feasible.

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

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

The description clearly states a specific operation: 'Repeat a feature `count` times, `spacing_mm` apart, along a direction.' It names the resource (feature) and key parameters (count, spacing, direction). The linear nature and direction format (+x/-x/+y) implicitly distinguish it from the sibling add_circular_pattern, 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?

The description provides parameter usage hints (direction format, feature_name defaulting to most recently added feature) but does not explicitly state when to use this tool versus alternatives like add_circular_pattern. It lacks any exclusions, prerequisites, or guidance on when not to use it, leaving the agent to infer usage from the name and context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains coordinate system, units, profile ordering, twist avoidance, ruled vs smooth blending, return value, and prerequisite. It does not detail failure modes or explicitly state that the operation is additive, but the name and 'add' imply that.

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

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

The description is compact and front-loaded; the first sentence states the core operation, and subsequent lines add only necessary constraints, alternatives, and return behavior. There is no filler or redundant restating of the schema.

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

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

For a complex loft operation with no schema descriptions, annotations, or output schema, the description covers input format, constraints, behavior, alternatives, return type, and prerequisite. The only missing piece is the exact structure of the returned mass properties, which is a minor gap.

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

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

Schema coverage is 0%, but the description fully documents both required parameters: profiles_mm as nested coordinate arrays in Front-plane coordinates, and heights_mm as +Z offsets with length, ordering, and start constraints. The optional name parameter is not described, but it has a default and is low-risk.

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

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

The description opens with a specific verb and resource: 'Loft (blend) 2+ closed polygon profiles on parallel planes stacked along +Z.' It clearly states what the tool does and distinguishes it from siblings by naming alternatives for round shapes. This is far more informative than a tautology.

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

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

The description explicitly says to use add_revolved_profile/add_cone for round shapes and instructs 'Use new_part first,' providing both an exclusion and a prerequisite. However, the phrase 'non-rotational transitions' is slightly confusing because round shapes are typically rotational, so the guidance is not perfectly unambiguous.

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

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

With no annotations provided, the description carries the full behavioral burden and meets it well. It discloses the verification step ('result is measured back from the geometry after the rebuild and rejected if it is not what was asked'), the flip behavior to resolve mirror-side solutions, and the special face selection syntax ('+y:inner'). These go beyond basic operation and give the agent accurate expectations about tool behavior and validation.

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 concise paragraphs. The first sentence delivers the core purpose immediately, and the second paragraph efficiently enumerates parameter semantics without redundancy. Every sentence adds a distinct piece of information—no filler, no repetition, and no unnecessary detail. The structure is front-loaded with the main action.

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

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

Given the tool's complexity (7 parameters, 4 required) and zero existing annotations or output schema, the description is remarkably complete. It covers all parameter semantics, explains the special face selection mode, describes the mate-type options, and warns about the verification behavior. There is no obvious missing operational context that an agent would need to call it correctly, though it doesn't mention error handling or prerequisites (such as components already being present in the assembly), but those are arguably implied.

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 parameter descriptions are entirely absent (0% coverage), so the description must compensate, and it does thoroughly. It explains the meaning and format of comp_a/comp_b, face_a/face_b (including direction and inner/outer cavity syntax), mate_type with enumerated values, distance_mm usage, and flip. It even gives concrete examples like 'Bed-1'. This fully clarifies the parameters beyond the bare type definitions.

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

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

The description opens with a clear, specific verb-resource pair: 'Mate a planar face of one component to a planar face of another.' It distinguishes itself from all sibling tools (only mating tool among many additive geometry tools) and immediately establishes what the tool does. The scope is precise and action-oriented.

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?

While the description explains how to use parameters in detail, it does not explicitly state when to prefer add_mate over alternatives like set_component_transform, nor does it give exclusions (e.g., 'not for non-planar faces' or 'use only when you need a mate constraint'). The usage context is implicit but not contrasted with other tools, so the agent must infer when this is the right choice.

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 carries the burden of behavioral disclosure. It states that the profile is auto-closed, that it is spun by angle_deg (default 360°), that r=0 yields a solid while offset yields a ring/torus, and that the profile may not cross the axis. It also notes the return of mass properties and the prerequisite of new_part. This is rich behavioral context for a modeling 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 concise yet comprehensive, structured as a lead sentence followed by focused paragraphs on the profile format and behavioral constraints. Every sentence adds value—no fluff. The key purpose is front-loaded, and the prerequisite and return info are placed logically. It achieves completeness without verbosity.

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

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

For a revolve tool with no output schema and no annotations, the description covers all essential aspects: geometry, parameter formats, constraints (may not cross axis), behavior (auto-close, angle), return value (mass properties), and prerequisite (new_part). An agent has everything needed to call it correctly. The only minor omission is the name parameter, but that's a non-essential default.

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 the parameters entirely. It thoroughly defines profile_mm with units, coordinate meaning (r = distance from axis, z = position along axis), and auto-closing behavior. It also explains angle_deg with its default. The name parameter is trivial and not explicitly covered, but the core parameters are fully clarified beyond the raw schema.

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

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

The description opens with a clear statement of the action ('Revolve a closed (radius, height) profile about the axis at radius 0') and specifies the resource (a profile) and axis. It distinguishes itself from extrusion and simple primitive tools by explaining the revolve concept and the effect of profile offset (solid vs ring/torus), making it easy for an agent to select this tool over siblings like add_extruded_profile or add_cylinder.

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

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

The description gives explicit usage context: 'Use new_part first' indicates a prerequisite, and the explanation of r=0 vs offset profiles tells the agent when this tool is appropriate for solid shafts/vases vs rings/toruses. It does not explicitly list alternative tools or when not to use it, but the behavioral distinctions from extrusion are clear enough to guide selection.

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

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

With no annotations, the description carries the full burden, and it does so well: it explains how the rib grows toward toward_mm until meeting the part, how thickness is applied, and that it returns mass properties. It doesn't mention prerequisites like an active part or failure modes, but it discloses the key behavioral and return characteristics.

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

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

The description is well-structured and front-loaded with the purpose, then parameter semantics, then return behavior. Each sentence provides distinct value, and the mass-properties formula earns its place because it tells the agent what result to expect.

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 param descriptions, and no output schema, the description is remarkably complete for a CAD primitive tool. It covers the geometry, all key parameters, and the return. Minor gaps are the lack of an explicit prerequisite that a part must be open and no discussion of failure conditions if the rib never meets the part.

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

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

Schema description coverage is 0%, yet the description explains almost every meaningful parameter: start_mm/end_mm as [x,y] endpoints, z_mm as plane height, toward_mm as the fill direction, and thickness_mm as the rib thickness. It also ties coordinates to add_extruded_profile, which helps an agent understand the expected format.

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

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

States a specific verb and resource: adds a straight stiffening rib/gusset in a plane parallel to the Front plane. The geometric detail and the mention of 'rib/gusset' differentiate it clearly from generic extrusion or sweep siblings.

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

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

Usage is implied by the clear domain language ('stiffening rib / gusset'), and the coordinate reference to add_extruded_profile gives some context. However, it does not explicitly state when to prefer this over alternatives like add_extruded_profile or add_swept_profile, nor does it mention exclusions.

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

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

With no annotations, the description carries the full burden. It discloses that the tool modifies geometry (hollows the part) and returns mass properties, which is important context. However, it does not mention destructive nature (permanent modification), potential side effects like altering existing features, or error conditions. It adds some value beyond the schema but has gaps.

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

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

The description is concise (two sentences) and front-loads the core operation. It efficiently explains the open_face parameter in the second sentence. No wasted words, though it could be slightly more structured, but it's appropriately sized for 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?

The description covers the primary operation and parameter semantic, but lacks details on return format (even though output schema is absent), prerequisites (e.g., must be a solid part), and edge cases like multiple faces or non-cuboid shapes. For a tool with 2 parameters and no output schema, it is functional but misses some completeness.

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

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

The schema description coverage is 0%, so the description must explain parameters. It does: open_face is clearly described with possible values and meanings, and thickness_mm's purpose is implied by 'wall of thickness_mm'. The description provides meaning that the schema lacks, making it highly valuable for correct parameter 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 states a specific verb ('Hollow') and the resource ('current part'), and clarifies that it transforms the part by creating a wall of given thickness. It also explicitly defines the open_face parameter's effect, making the tool's purpose unambiguous. This distinguishes it from sibling modeling tools like add_box or add_shell's related 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 implies usage for hollowing operations but does not specify when to use this versus alternatives like cut_profile or add_hole. It lacks explicit context about part requirements (e.g., must be a solid with at least one face) or scenarios where a different tool is more appropriate. However, it does convey the core operation clearly enough for an agent to infer basic usage.

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

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

With no annotations provided, the description carries the disclosure burden and does so well: it states that the profile is auto-generated perpendicular to the path, explains bend_radius_mm behavior, and discloses that the tool returns mass properties. It does not discuss invalid-path behavior or explicit side effects beyond creation, but the prerequisite and creation semantics are clear.

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

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

The description is front-loaded with a one-sentence capability statement followed by a compact parameter block. Every sentence adds useful information and there is no filler or repetition of schema details.

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

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

For a 4-parameter creation tool with no annotations and no output schema, this description covers all essential operational knowledge: purpose, construction plane, path format, profile generation, bend behavior, return value, and prerequisite. An agent has enough information to call and interpret 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%, so the description must compensate, and it does for the meaningful parameters: path_mm is explained as an [x, y] centreline in mm, diameter_mm as outer diameter, and bend_radius_mm as required on turns and unnecessary for straight 2-point paths. Only the self-explanatory name parameter is left to the schema and default.

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

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

The description names a concrete operation: 'Sweep a circular profile (pipe/tube/rod) along a 2D path on the Front plane.' It clearly distinguishes itself from the generic add_swept_profile sibling by specifying the circular cross-section, and it identifies the target resource and relevant dimensions.

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 clear context and a prerequisite: it is for circular-profile sweeps along a Front-plane 2D path, and 'Use new_part first' tells the agent the required setup. It does not explicitly name alternatives such as add_swept_profile for non-circular profiles, but the circular-profile wording implies when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It explains coordinate systems, path start constraint, bend rounding, volume calculation, and that it returns mass properties. It also implies the operation adds to the current part (via 'Use new_part first'). Missing are potential side effects on existing geometry or error conditions, but the detail provided is substantial for a CAD tool.

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

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

The description is concise yet information-dense, with each sentence delivering essential value. It opens with the core purpose, then systematically details parameters and behavior with examples. No filler or redundancy; the structure is logical and front-loaded.

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

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

For a complex swept-profile tool, the description covers the critical elements: coordinate systems, path start requirement, bend handling, volume formula, return value, and prerequisite. It does not mention whether the path must be closed or open, or discuss non-self-intersecting profiles, but these may be secondary. The mention of 'Returns mass properties' compensates for the lack of an output schema. Overall, it is sufficiently complete for an agent to call the tool correctly in most cases.

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

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

Schema coverage is 0%, so the description must explain all parameters. It does so comprehensively: profile_mm is described with its plane, axes orientation, and centering; path_mm is described with plane, start heading, and perpendicularity; bend_radius_mm is explained as rounding path corners. Name is trivial and self-explanatory. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool sweeps a closed profile along a 2D path, specifying the exact geometry and coordinate conventions. It distinguishes itself from sibling tools like add_extruded_profile (straight extrusion) and add_swept_pipe (round pipe) by explicitly targeting non-round extrusions along a path, leaving no ambiguity about its purpose.

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

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

The description provides clear usage context by stating when to use it ('For non-round extrusions along a path') and a prerequisite ('Use new_part first'). It doesn't explicitly name alternatives or when NOT to use it, but the 'non-round' qualifier and the detailed path/profile constraints effectively guide selection among siblings. The start-origin requirement is an important usage constraint.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the thread runs into the material, is right-handed, has validation against SolidWorks' thread profiles, and returns mass properties plus thread dimensions. It does not discuss reversibility or side effects, but it gives a solid picture of what the operation does.

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 dense but every sentence earns its place: purpose first, then parameter semantics, then usage prerequisites, then return value. There is no filler or repetition of schema titles.

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

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

For a 7-parameter tool with no annotations and no output schema, the description covers the essential context: coordinate convention, length direction, handedness, external/internal prerequisites, and return information. An agent has enough to call it correctly without additional inference.

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

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

Schema description coverage is 0%, so the description must compensate, and it does thoroughly. It explains the size format with examples and validation, the coordinate meaning (centre of the circular edge), the internal boolean (hole vs rod), and length_mm. Only 'name' is left to the schema, and its default makes it self-explanatory.

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

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

The description names a specific verb ('Cut'), a specific resource ('a real, printable ISO metric thread'), and the mechanism ('SolidWorks' own Thread feature'). This clearly distinguishes it from siblings like add_hole and cut_profile, which are different operations on different geometry.

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 clear usage context: where the thread starts, how far it runs, and the prerequisites for external versus internal threads (nominal diameter for rods, pre-drilled minor diameter for holes). It does not explicitly name alternative tools or state when not to use it, but the conditions are concrete and actionable.

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

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

With no annotations, the description carries the behavioral burden and does well: it defines the unit (mm^3), excludes touching faces with a concrete example, and explains the meaning of count == 0. It stops short of stating whether the tool is read-only or how strict the overlap tolerance is, but the core behavior is clear.

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

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

Three short, well-structured sentences lead with the main purpose, add the critical touching-face exclusion, and end with the count interpretation. Every sentence earns its place and no unnecessary details are included.

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 zero-parameter analysis command, this is complete: an agent knows what is returned (overlapping component pairs and volumes), how to interpret count, and what edge case (touching faces) is deliberately excluded. No output schema exists, but the description covers the essential return contract.

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 tool has zero parameters and the schema accurately reflects that, so there are no parameter semantics to document. The description still adds value by describing the output semantics (per-pair overlap volume and clash count), which is useful in the absence of an output schema.

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

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

The description opens with a specific verb and resource: 'Report component pairs whose solids overlap, with the volume in mm^3.' This clearly identifies it as an interference/clash analysis tool and separates it from the creation/getting siblings such as add_box or get_mass_properties, which do not report pairwise overlaps.

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 implies this is the tool to use for clash detection and gives an interpretative rule (count == 0 means clash-free), but it never explicitly states when to call it versus alternatives or what conditions apply, such as requiring an open assembly or a prior rebuild.

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

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

With no annotations provided, the description carries the full burden. It clearly states the primary behavior—closing without saving—which implies unsaved changes are lost. It also mentions 'export/save first if needed' as a caution. It doesn't disclose potential prompts or reversibility, but for a close operation the key behavior is transparent. A 4 is appropriate.

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

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

The description is a single, compact sentence that front-loads the action and includes the key caveat. Every word earns its place; no wasted language. Perfectly 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?

For a simple close tool with one optional parameter and no output schema, the description covers the main action and the save caveat. It doesn't describe what happens after closing (e.g., no return value) but that's not essential. It adequately covers the essential context for an agent to invoke it correctly. Score 4.

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

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

The schema has one boolean parameter 'save' with default false and no description. The description's phrase 'without saving' explains the default behavior but does not clarify what happens if save=true (e.g., whether it saves before closing). Since schema coverage is 0%, the description should compensate more fully, but it provides partial meaning. Score 3.

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

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

The description states a clear action ('Close') and specific resource ('current part or assembly'), and explicitly distinguishes itself from save operations by adding 'without saving'. This is a specific verb+resource that clearly differentiates from siblings like save_part and open_part.

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: it closes without saving, and advises to 'export/save first if needed', which implies when not to use this tool (if you need to save). It doesn't name alternative tools explicitly but gives a practical condition. This is clear context without explicit exclusions, earning a 4.

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 discloses key behaviors: auto-closed polygon, blind cut by default, through cut when depth_mm is omitted, and return of mass properties. It does not mention side effects on existing geometry or undo behavior, but enough is disclosed for a mutating shape 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 compact and front-loaded: main action first, then parameter format, then behavior/use cases and return value. Every clause adds information; no filler.

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

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

For a mutating modeling operation with no annotations or output schema, the description covers inputs, depth behavior, use cases, and return type. It lacks detail on coordinate frame origin or relationship to sibling cut tools, but is sufficient for basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It defines points_mm format precisely ('[[x,y], ...] in mm') and explains depth_mm semantics (blind vs through). The name parameter is not described, but it has an obvious default and is minor.

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 names the operation 'Cut', the geometry ('polygonal pocket/slot'), the face ('+Z face'), and the input format. It clearly states the use case 'For pockets, slots, cutouts' but does not explicitly differentiate from sibling tools like cut_profile_through_plane or cut_slot, so not a 5.

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

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

Implies when to use: for cutting pockets/slots/cutouts from the +Z face, with blind vs through controlled by depth_mm. However, it gives no explicit alternatives or when-not guidance, leaving the agent to infer relative to cut_profile_through_plane, cut_slot, or additive extrude tools.

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

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

With no annotations provided, the description carries the full disclosure burden. It usefully reveals the point-on-face constraint, blind/through behavior, and mass-properties return, but it does not disclose mutational impact, reversibility, cut direction, or validation 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 compact and front-loaded, with no filler. Each sentence contributes operational information about geometry, parameters, use case, or return 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 and no annotations, the description covers the core call intent but leaves several operational details ambiguous, such as point ordering, profile validity rules, cut direction relative to the face, and the exact structure of the returned mass properties.

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

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

The schema has 0% description coverage, so the description adds essential meaning: points_mm are 3D points in mm, face uses '+x'/'-x' style values, and depth_mm controls blind versus through behavior. The optional name parameter is not explained, but it is low-risk and has a sensible default.

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

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

States a specific action and resource: cuts a polygon pocket/slot on any planar face, with explicit face syntax and side-pocket/cutout use. It is distinguishable from similar siblings like cut_profile_through_plane and cut_slot, though it does not name them explicitly.

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

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

Provides a clear intended scenario ('For side pockets/cutouts') and explains when to cut blind versus through by omitting depth_mm. It does not list exclusions or name alternative tools, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explains that the cut is symmetric, extends through all geometry in both directions when depth_mm is omitted, and is centered when depth_mm is supplied. It also states the return value: 'Returns mass properties.' This is clear, though it does not explicitly warn that the operation removes material or requires an active part.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, followed by parameter semantics, behavioral details, use cases, and return information. Every sentence adds useful information without redundancy.

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

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

The description covers the essential invocation details: coordinate conventions, point placement, depth behavior, and return value. Given the lack of annotations and output schema, this is strong, though a note about prerequisites such as an active part or existing body would make it fully complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It defines plane values with axis equations, specifies points_mm as 3D points lying on the chosen plane, and explains depth_mm behavior including the omitted case. This adds substantial meaning beyond the bare input schema.

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

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

The description clearly identifies the operation: 'Cut a polygon sketched on a reference plane, symmetric about that plane.' It also explains the geometric meaning of the three named planes. It does not explicitly differentiate this tool from sibling cut tools by name, though the symmetric through-plane behavior implies a distinction.

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 a concrete use case: 'For shapes seen from the side: wedges, windows, symmetric recesses.' It also describes the two depth modes, which helps an agent choose how to invoke the tool. However, it does not mention alternatives or when not to use this tool versus sibling cut operations.

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

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

With no annotations, the description carries the behavioral burden and does so well: it explains blind versus through cuts based on depth_mm, clarifies coordinate/orientation semantics, and states that mass properties are returned. It does not mention prerequisites or reversibility, but core cut behavior is transparent.

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

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

The description is compact and front-loaded, starting with the operation and face, then defining geometry parameters, then covering depth behavior and return value. Every sentence carries necessary information with no filler.

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

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

For a tool with no annotations and no output schema, the description covers the essential geometry, defaults, and return behavior. It is slightly incomplete only in not stating the prerequisites (e.g., an active part or face context) and not differentiating from overlapping cutting tools, but an agent can invoke it correctly from the provided details.

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

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

The input schema has 0% description coverage, so the description must compensate. It meaningfully defines every functional parameter: x_mm/y_mm as the center, length_mm as centre-to-centre, width_mm as slot width, angle_deg with 0=+X, and depth_mm as blind depth or through when omitted. Only the trivial name parameter is left to inference.

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

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

The description names a specific verb ('Cut') and resource ('straight slotted hole (obround) on the +Z face'), identifying exactly what the tool does. This distinguishes it from related sibling tools like cut_profile or add_hole without requiring the agent to inspect schemas.

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

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

The description implies when to use the tool: whenever a straight slotted hole on the +Z face is needed. However, it does not explicitly compare to alternatives such as cut_profile_on_face or add_hole, nor does it state when not to use it, leaving some selection guidance to inference.

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

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

With no annotations, the description must disclose behavior. It mentions silent execution, file verification, and size reporting, which is useful. However, it does not address overwrite behavior, failure handling (e.g., invalid extension), or permissions. The tessellation behavior is well explained, but side effects beyond file creation are omitted.

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

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

The description is concise, with purpose in the first sentence and behavioral details following. The tessellation paragraph is structured logically. No filler or redundancy, though the file_format omission leaves a slight structural gap.

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 5 parameters, no output schema, and no annotations, the description covers purpose, behavior, and most parameters, but omits file_format semantics, overwrite/conflict behavior, and error handling for unsupported extensions. It is adequate but not fully complete.

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

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

Schema coverage is 0%, so the description must explain parameters. It explains quality, deviation_mm, and angle_deg in context, and implies path via 'format from extension'. However, it does not explain the file_format parameter at all, which is ambiguous (override vs. derived). Coverage is partial, not fully compensatory.

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

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

States a specific verb (export) with a clear resource (current part or assembly) and enumerates the target formats (STEP/STL/IGES/Parasolid/3MF). It distinguishes itself from save_part (native format) and other modeling tools. The purpose is unambiguous 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?

The description implies when to use (when exporting to a neutral CAD format) but does not explicitly contrast with alternatives like save_part or provide exclusion criteria. It gives clear context for tessellation parameters but no explicit 'use this instead of X' guidance, leaving some inference to the 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 are provided, so the description carries the full burden. It clearly discloses the return content (min/max/size in mm), and the verb 'Get' with zero parameters strongly signals a non-mutating query. It does not mention prerequisites like having an assembly open, but that is a minor omission for such a simple getter.

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

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

The description is a single, front-loaded sentence with no filler. Every element—verb, resource, scope, output, and units—is meaningful, and the most important scoping detail ('whole assembly') appears early.

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 zero parameters, no annotations, and no output schema, the description covers everything needed to invoke the tool correctly and understand its result. It states what is returned and in what units, making it complete for an operation of this simplicity.

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

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

The tool has zero parameters)Skip: schema coverage is 100% by default, so the baseline is 4. There are no parameter semantics to add beyond what the description already provides.

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

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

The description uses a specific verb ('Get'), a clear resource ('bounding box of the whole assembly'), and specifies the output fields and units (min/max/size in mm). It is immediately distinguishable from the sibling tool 'get_bounding_box' by the 'whole assembly' scope.

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

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

The description implies the tool is for the whole assembly rather than individual parts, but it does not explicitly compare against 'get_bounding_box' or state when one should be preferred. The usage context is reasonably clear from 'whole assembly', but no exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool returns min/max/size values in millimeters, which is the key behavioral output. It does not mention side effects or behavior when no part is loaded, but 'get' implies a read-only operation and the core return semantics are clear.

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

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

A single sentence that front-loads the action and immediately provides the essential output details. There is no filler and every clause 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?

For a zero-parameter getter with no output schema, the description is complete: it identifies the scope, the returned quantities, and the units. Nothing critical is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters, so there is no ambiguity for the agent to resolve. The description does not need to add parameter-level detail, and no parameter semantics are missing.

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

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

The description states a specific verb ('get'), a clear resource ('bounding box of the current part'), and the exact output components (min/max/size in mm). It also distinguishes this from the sibling get_assembly_bounding_box by explicitly scoping it to the current part.

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 phrase 'current part' gives clear context that this is for part-level bounding boxes rather than assembly-level ones, so the agent can infer the relevant alternative. However, it does not explicitly mention when not to use it or name the alternative directly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists the output values and their units, but does not communicate whether this is a read-only operation, whether it requires a loaded model, whether it depends on a rebuild, or what happens if no part is open. These are important preconditions that the description omits.

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

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

The description is a single, compact sentence that lists the outputs in a logical order. It is immediately front-loaded with the action and the main resource, and every element (units and property names) adds value. No superfluous words or filler are present.

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 zero-parameter tool with no output schema and no annotations, the description should at least hint at preconditions (e.g., 'on the current model') and possibly note that this is a combined query replacing multiple calls. It does specify the output units and properties, but misses guidance on when it is appropriate to call (e.g., after a rebuild) and how it compares to the get_bounding_box sibling. This is sufficient for a trivial command but not fully complete.

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

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

The tool has zero parameters, so there is nothing to document beyond the already-empty schema. The description adds no parameter semantics, but the baseline for 0 parameters is 4, which is appropriate since the lack of parameters is self-evident and no further clarification is needed.

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

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

The description states a specific verb ('Get') and a resource ('mass properties') and enumerates the exact quantities returned (volume, mass, surface area, center of mass, bounding box). It is clearly distinguishable from siblings like get_bounding_box, which returns only the bounding box, so the purpose is precise 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 gives no guidance on when to use this tool versus alternatives. It does not mention that it operates on the current part or assembly, nor does it reference the more specialized get_bounding_box or other related getters. An agent has to infer the appropriate context, which is a significant gap for a simple 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 carries the full burden of behavioral disclosure. It clearly states that this is a status-reporting operation and lists the reported data, but it does not describe failure behavior, return format, or explicitly confirm there are no side effects. For a no-parameter read-only status tool this is adequate but not detailed.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase adds meaningful information: reachability, revision, and active part.

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 no-argument tool with no output schema, the description covers the main return values clearly. It is slightly incomplete because it does not specify how reachability is represented or what happens if SolidWorks is unreachable, but this is a minor gap for such a straightforward status probe.

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 tool has zero parameters, so there is nothing for the description to explain. The baseline of 4 applies because no parameter semantics are needed.

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

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

The description uses a specific verb ('Report') with a clear subject (SolidWorks status) and enumerates the exact outputs: reachability, revision, and active/current part. This clearly distinguishes it from the sibling tools, which focus on creation, modification, or other queries.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites such as SolidWorks needing to be running. The intended use is implied by 'Report whether SolidWorks is reachable,' but no direct when-to-use or exclusion criteria are stated.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: origin placement is exact and verified, the fixed parameter's effect, and the default behavior of fixing only the first component. It also states what the return value includes (name, placement, box). This is richer than a typical insert tool description, though it omits potential side effects like assembly interdependence or overwriting existing components.

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 but information-dense. It front-loads the core action, then layers behavioral details, default behavior, and return info without redundancy. Each sentence earns its place—no filler or vague phrasing.

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

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

While the description explains the action, defaults, and return value, it omits a critical prerequisite: that an assembly must already be open to insert into the 'current assembly'. It also leaves the path parameter's format unspecified. For a tool with no annotations and no output schema, these gaps could lead an agent to misuse it in an invalid context.

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

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

Schema coverage is 0%, so the description must explain all parameters. It explicitly covers x_mm, y_mm, z_mm (origin coordinates) and fixed (pin/unpin), including the default for fixed. However, the 'path' parameter is only indirectly referenced via 'Insert a .sldprt' — it does not explicitly state that the path must be a valid file path to a SolidWorks part file. This is a notable gap for the most critical 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 the tool inserts a .sldprt file into the current assembly at a specified origin. This distinguishes it from sibling tools that create geometry (e.g., add_box, new_part) or modify assemblies (e.g., add_mate, set_component_transform). The verb 'insert' and resource '.sldprt' 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 implies usage context (working on an assembly, inserting an existing part file) and contrasts with geometry-creation tools by requiring a file path. However, it does not explicitly mention when NOT to use it (e.g., when you need to create a new part from scratch) or name an alternative tool. The context is clear but exclusions are implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It clearly signals a read-only listing operation and adds valuable behavioral context by specifying units (mm, degrees) and coordinate systems for positions, rotations, and bounding boxes. It does not cover edge cases like empty assemblies, but this is minor for a simple list tool.

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

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

The description is two concise sentences with no wasted words. The first sentence states the action and output fields, and the second clarifies units and coordinate context.

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

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

For a no-parameter listing tool, the description provides the essential output fields and their units. It could be more explicit that it operates on the currently open/active assembly, but the definite article 'the assembly' and the tool context make this reasonably 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?

There are zero parameters, so there is nothing for the description to add beyond the empty schema. The baseline of 4 applies because parameter semantics are not applicable.

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

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

The description uses a specific verb and resource ('List the assembly's components') and enumerates exactly what is returned. This distinguishes it from sibling tools like list_faces and list_edges, which operate on different geometric entities.

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

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

The intended use is implied by the description: call this when you need the assembly's components and their properties. However, it does not explicitly state when to prefer this over siblings such as get_bounding_box or list_faces, nor does it mention exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the output structure and implies a read-only operation through the verb 'List'. It does not discuss units or ordering, but for a simple edge-listing tool the provided output details are sufficient.

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 no filler. The first sentence states the core function and output, and the second adds actionable cross-tool guidance. Every sentence earns its place.

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

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

For a zero-parameter listing tool with no output schema, the description is complete: it states what is returned and how to use the result. An agent has enough information to call the tool and apply the output correctly.

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

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

The input schema is empty, so there are no parameters to document; the baseline of 4 applies. The description adds value by explaining the output fields and how the edge index should be used in subsequent fillet/chamfer operations.

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

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

The description opens with a specific verb and resource: 'List the part's edges'. It also details the output (index, type; lines give axis/length/midpoint), which clearly distinguishes it from sibling tools like list_faces. An agent can immediately understand what this tool returns and how it differs from related list 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 explains how to use the returned edge indices with add_fillet/add_chamfer, giving concrete downstream usage. It does not explicitly mention alternatives or when not to use this tool, but the resource scope and output purpose make the appropriate context clear.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the positional nature of indices and the need to re-call after edits, which is meaningful behavioral context beyond the tool name. It does not cover all edge cases, but it is sufficient for a simple list 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?

Two concise sentences: the first states exactly what is listed and for what purpose, the second provides a crucial caveat. No filler or repetition.

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

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

For a zero-parameter inspection tool, the description covers the returned fields and the important index-shift caveat. It does not mention prerequisites such as an open part, but the tool name and sibling context make that reasonably inferable.

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 tool has zero parameters and the schema is empty, so the baseline is 4. There is no parameter information needed, and the description adds no conflicting or redundant parameter details.

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

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

The description uses a specific verb ('List') and resource ('the part's faces') and enumerates the exact fields returned (index, planar?, normal, area, centre). This clearly distinguishes it from sibling tools like list_edges and get_mass_properties.

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

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

The description states that the tool is for inspection and explicitly warns that indices shift as features are added, advising to call again after edits. This gives clear context for when to use it, though it does not name alternative tools or exclusions.

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

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

No annotations are present, so the description carries the burden. It discloses the key state change—becomes the current document—but does not mention persistence, whether the previous document is closed, or any other side effects. Core behavior is covered, but not richly.

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

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

Two concise sentences with no filler. The primary action and state effect are front-loaded, and the second sentence earns its place by providing workflow context and pointing to sibling tools.

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, no-argument creation tool, the description is largely complete: it names what is created, its state, and how it fits into the assembly workflow. Without annotations or an output schema, a note about return values or safety would make it fully complete, but nothing essential is missing for calling it.

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

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

The tool has zero parameters and 100% schema coverage, so the schema leaves nothing undocumented. No parameter explanation is needed, and the baseline for zero-parameter tools is 4.

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

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

States a specific verb and resource: 'Create a new empty assembly document; it becomes the current document.' This clearly distinguishes the tool from sibling creation tools like new_part by naming the document type and empty initial state.

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 clear context by explaining that assemblies compose saved parts and names the follow-up tools (insert_component, add_mate, check_interference). It does not explicitly exclude new_part or state 'use when...', so it stops short of full when/alternatives guidance.

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

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

With no annotations, the description carries the behavioral burden. It discloses the key side effect that the new part becomes the current part, which is an observable state change. It does not discuss file persistence or unsaved-work handling, but for a zero-argument creation command the core behavior is clear.

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

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

A single sentence with no filler; the verb and object are front-loaded and the side effect follows immediately. Every word contributes meaning.

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

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

For a zero-parameter, no-output-schema tool, the description explains what is created and the resulting state. It is nearly complete, though it could add one clause about what happens to the previously current part to remove all ambiguity.

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 no properties and the description reflects that by describing the operation as parameterless. With zero parameters, there is nothing for the description to add to the schema, so this is the correct baseline.

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

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

Description uses a specific verb ('Create'), names the resource ('new empty part document'), and states the immediate effect ('becomes the current part'). This distinguishes it from siblings like new_assembly and open_part without needing to inspect schemas.

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

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

The intended use is implied: call it when you want to start a new empty part. However, it does not explicitly say when not to use it or mention alternatives such as new_assembly or open_part, leaving the routing decision mostly to inference.

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

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

No annotations are provided, so the description is the only source of behavioral disclosure. It mentions that the file becomes the current document, but does not describe what happens to any currently open document, error behavior for invalid paths, or file access requirements. For a tool that mutates application state, this is a significant gap.

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

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

The description is a single, direct sentence with no filler. It front-loads the action and includes the key state change, earning its place with minimal 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?

For a simple one-parameter open operation, the description covers the essential behavior and result. It is adequately complete given the low complexity, though it could mention handling of unsaved current documents or errors for a fully robust definition.

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 a single 'path' parameter with no description (0% coverage). The description adds some meaning by clarifying the path points to an existing .sldasm file, but it does not specify path format, absolute vs relative, or extension handling beyond the obvious context.

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

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

The description uses a specific verb ('Open') with a specific resource ('.sldasm' assembly file) and states the result ('becomes the current document'). This clearly distinguishes it from siblings like open_part and new_assembly based on file type.

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

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

The description implies usage for opening existing assembly files, but does not explicitly state when to use this tool versus open_part or new_assembly. There are no exclusions or alternative routing hints, leaving the agent to infer from the .sldasm extension.

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

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

With no annotations provided, the description carries the full burden. It discloses the key state change ('becomes the current part'), but does not mention whether the previous part is closed, whether unsaved changes are affected, or what happens if the file does not exist. This is a minimum-viable disclosure for a simple open 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 a single, efficient sentence that front-loads the action ('Open an existing .sldprt file') before the outcome. Every word earns its place; there is no filler or repetition.

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

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

For a one-parameter open operation, the description is mostly complete: it identifies the file type and the resulting state. However, it omits relevant context such as whether the current part is replaced or closed, and does not mention error behavior for invalid paths. These gaps are notable given there is no output schema or annotations to fill them.

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

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

The schema has one parameter, 'path', with no description (0% coverage). The description implicitly clarifies that the path should reference an existing .sldprt file, but it does not add details about absolute vs relative paths or file URI formats. The parameter name is self-explanatory, so the description adds modest value.

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

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

The description states the specific verb 'Open' and the exact resource type '.sldprt file', and clarifies the intended consequence: 'it becomes the current part.' This clearly distinguishes it from siblings like new_part, open_assembly, and close_part.

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 phrase 'existing .sldprt file' gives clear context for when to invoke this tool: when an existing part should be loaded. It does not explicitly name alternatives or exclusions, but the resource type and 'existing' qualifier strongly imply the appropriate usage scenario.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool forces a rebuild (a potentially expensive operation) and reports error status, which is useful. However, it doesn't disclose side effects (e.g., whether the rebuild can fail mid-way, whether it blocks until complete, or whether it affects unsaved changes). It's adequate but not rich.

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

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

One sentence, front-loaded with the action ('Force a rebuild') and ending with the reported outcome. Every word earns its place; no fluff or repetition.

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

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

For a single-parameter tool with no output schema, the description is mostly complete: it says what it does and what it reports. However, it doesn't explain the meaning of 'top_only' (the only parameter), and with no annotations, the agent has no safety or side-effect context. It's adequate for a simple tool but leaves the parameter semantics to inference.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'top_only' parameter. The description does not mention 'top_only' at all, leaving the agent to infer its meaning from the name alone. Since there is only one parameter and its name is fairly self-explanatory, this is a minor gap, but the description adds no semantic value beyond the schema.

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

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

The description states a specific verb ('Force a rebuild') and resource ('the current part'), and adds the outcome it reports ('whether it rebuilt without errors'). This is clear enough to distinguish it from sibling tools like get_status or export, though it doesn't explicitly name a sibling to differentiate from.

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

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

The description implies when to use it: after making changes to a part, to force a rebuild and check for errors. However, it provides no explicit guidance on when not to use it or which alternative to prefer (e.g., get_status for checking state without rebuilding). The context is clear but the exclusion/alternative guidance is missing.

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?

Since no annotations are provided, the description carries full burden for behavioral disclosure. It states that it saves to a .sldasm file, implying a write operation and file system interaction, but does not mention whether it overwrites existing files, requires certain conditions, or what happens on failure. The description is minimal and leaves important behavioral aspects unaddressed.

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

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

The description is very short and to the point, with no unnecessary words. It is appropriately front-loaded with the purpose. It earns a 4 for efficiency, though it could be slightly more detailed without becoming verbose.

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

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

The tool is simple with only one parameter and no output schema, so baseline completeness could be higher. However, given the zero schema coverage and lack of annotations, the description fails to provide essential context such as file handling behavior and parameter specifics. An agent might not know whether to include '.sldasm' in the path or if the tool creates directories. It is incomplete for a file-saving operation.

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?

Parameter schema coverage is 0%, meaning the description must compensate for the undocumented 'path' parameter. The description says 'Save the current assembly to a native .sldasm file', which implies that 'path' is the file location, but it does not clarify if the path should include the file extension, whether directories are created automatically, or any format requirements. This is a significant gap given the zero 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 verb ('Save') and the resource (current assembly) and specifies the output format (.sldasm). This distinguishes it from save_part, which is a sibling, though it does not explicitly differentiate between saving assemblies and parts. The purpose is unambiguous and specific.

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

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

The description implies when to use this tool: when the user wants to save an assembly for later reopening. It does not explicitly state when not to use it or mention alternatives like save_part, but the context of 'assembly' is clear. No contraindications are provided, but the purpose is obvious enough that an agent can infer 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?

There are no annotations, so the description carries the full burden. It clearly states the core write behavior and the native format, but it does not disclose whether an existing file is overwritten, whether the path must include the .sldprt extension, or what the tool returns. This is an adequate but incomplete disclosure.

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

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

A single, front-loaded sentence states the operation, destination format, and rationale with no filler. The parenthetical adds purpose without bloating the description.

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

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

For a simple one-parameter save operation the description is broadly adequate, but with no annotations and no output schema it leaves out side effects (e.g., overwrite behavior) and return value or error information. An agent can call it correctly in the common case, but not with full certainty about edge cases.

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

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

With 0% schema description coverage, the description is the only source of parameter meaning. It indicates that 'path' is the destination file path and that it should point to a native .sldprt file, which is material information beyond the raw schema. It does not discuss extension handling or paths, but for a single string parameter the key semantics are conveyed.

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

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

The description uses a specific verb ('Save'), identifies the resource ('the current part') and the exact output ('a native .sldprt file'), and adds the intent ('so it can be reopened/edited'). This clearly differentiates it from export, save_assembly, and other siblings.

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

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

The description gives clear context: use this when persisting the current part in a natively editable format. It does not explicitly name alternatives like export or save_assembly or state when not to use them, so it falls short of a 5.

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

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

With no annotations, the description carries the behavioral burden. It clearly communicates that the tool writes an image file in PNG/BMP/JPG format, which is useful, but it does not mention preconditions (e.g., whether a document must be open), overwrite behavior, or whether the viewport is altered.

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

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

A single, front-loaded sentence conveys the tool's purpose and key format options without wasted words. Every element earns its place.

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

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

For a one-parameter, no-output-schema tool, the description covers the subject matter, rendering style, and file formats. The only notable omissions are explicit prerequisites and side-effect details, but the tool is simple enough that this is an acceptable gap.

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

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

Schema coverage is 0%, so the description must compensate. The verb 'Save' and the listed formats imply that 'path' is the destination file path, and the format list adds some meaning beyond the bare 'Path' property. However, the description never explicitly states how the path relates to format selection or file creation.

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

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

The description states a specific action ('Save'), a precise rendering style ('isometric, zoom-to-fit'), and the target resource ('current part or assembly'). Naming the supported image formats clarifies it as a screenshot capture tool, which differentiates it from the 'export' sibling.

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 makes the usage context clear: when an isometric, zoom-to-fit image of the current part or assembly is needed. It does not explicitly state when not to use it or mention 'export' as an alternative, so it stops short of a full 5.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses rotation order (X then Y then Z about assembly axes), that fixed components are supported, and that the transform is read back and compared so ignored moves fail loudly. This goes well beyond a generic 'moves a component' statement, though it does not describe return values or success output.

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

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

Two sentences carry high-density information with no fluff. The core action is front-loaded, and the second sentence adds crucial parameter and failure-mode details. Every clause earns its place.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description covers the essential invocation details: coordinates, rotation units/order, component naming, and error behavior. It is slightly ambiguous what 'fixed component' exactly means versus 'pinned by mates,' but overall it gives an agent enough to call and interpret the result.

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

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

Schema description coverage is 0%, and the description compensates fully: it explains name with example format ('Bed' or 'Bed-1'), gives units for x/y/z (mm) and rx/ry/rz (degrees), clarifies rotation order, and states the origin is moved to the provided coordinates. All seven parameters are meaningfully defined.

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

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

The description opens with a specific verb and resource: 'Move/rotate a component: its origin to (x, y, z) mm, rotated rx/ry/rz degrees.' This clearly distinguishes the tool from siblings like set_dimension, set_material, and insert_component by stating exactly what it does.

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

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

Usage is implied through the description of behavior ('work on a fixed component too', 'fails loudly instead of silently leaving the part'), but there is no explicit 'use this when...' or comparison to alternative tools. The context is clear enough, but no exclusions or alternative routing are provided.

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

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

With no annotations, the description carries the burden and it does disclose the main effects: setting the value, rebuilding, and remeasuring. It also conveys the parametric/driving nature of the edit. It does not cover failure modes, save/persistence, or output behavior, but the core side effects are stated.

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 efficient sentences front-load the action and then add only relevant context. Every phrase earns its place, with no repetition of schema or title.

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

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

For a simple two-parameter tool, the definition covers what it does, when to use it, and how to obtain the dimension name. Missing explicit return value and error handling details, and there is no output schema, so it isn't fully complete, but it is sufficient for correct invocation in the stated loop.

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 provides essential meaning: dimension_name is in the role-qualified form 'D1@BlockExtrude' and is provided by modelling tools, while value_mm is explicitly in mm. This compensates well for the empty schema but doesn't add constraints like valid ranges or naming rules.

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

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

The description clearly identifies a specific operation: set a named driving dimension (with example) in mm, then rebuild and remeasure. It positions the tool as the parametric edit in the correction loop, which separates it from geometry-creation siblings, but it does not explicitly contrast it with set_equation or rebuild.

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 gives a clear usage context ('the parametric edit at the heart of the correction loop') and explains where dimension_name comes from ('Every modelling tool returns its dimensions by role'). It does not state explicit when-not-to-use conditions or name alternatives, so it is just short of a 5.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool rebuilds and remeasures, persists a relation, and returns mass properties. This goes well beyond a generic 'sets an equation' statement. It does not cover invalid-equation handling or prerequisites, but the main side effects are transparent.

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

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

Every sentence earns its place. The core action is front-loaded, followed by necessary syntax examples and one comparative note about persistence. There is no filler or repetition of schema fields.

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 one-string-parameter tool with no annotations and no output schema, the description is complete. It explains the parameter format, the side effects, the alternative tool, and the return value. Nothing essential is missing for an agent to select and invoke this 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 the lone parameter. It does: it provides exact SolidWorks equation syntax, multiple examples, global variable syntax, and how to link a dimension to a global variable. An agent can construct a valid equation string directly from the description.

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

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

The description uses a specific verb and resource: 'Add a global equation linking dimensions, then rebuild and remeasure.' It clearly distinguishes itself from set_dimension by stating that it 'Persists a relation (unlike set_dimension).' This is not a tautology and gives an agent a precise mental model of the action.

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

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

The description explicitly names set_dimension as the alternative and explains the key difference: set_equation persists a relation, set_dimension does not. It also implies the workflow (add equation, rebuild, remeasure), giving contextual guidance. It lacks a fuller when-not-to-use list, but the core routing decision is covered.

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

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

With no annotations, the description must disclose behavioral traits on its own. It explains that mass and density are updated and that mass properties are returned, but it does not mention potential failure modes (e.g., invalid material name) or the effect of the database parameter. This is adequate but not comprehensive.

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

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

The description is concise and front-loaded: the first sentence states the action, the second explains the effect and return. There is no wasted text.

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

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

The tool is a simple setter, but the description omits documentation for the 'database' parameter and does not specify behavior on invalid input. While the main effect is covered, the missing parameter explanation makes it incomplete for a no-output-schema 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 explain parameters. It clarifies the 'name' parameter with examples but says nothing about the 'database' parameter. This leaves a gap for an agent trying to populate that field 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 action ('Assign a material by name') with specific examples, and it distinguishes from sibling tools like get_mass_properties by focusing on setting versus reading. It is unambiguous about the resource being modified.

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 ('instead of the 1000 kg/m³ default'), implying it is for assigning realistic materials. It does not explicitly mention alternatives or when not to use it, but the context is clear enough for an agent to understand its purpose.

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