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

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, covering basic safety. The description adds context about entity referencing by index, which is useful for understanding how to interact with the sketch. However, it lacks details on error conditions, side effects, or what happens if constraints conflict, leaving behavioral 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 a single, efficient sentence that directly states the tool's purpose and key operational detail (entity referencing). It is front-loaded with essential information and has no wasted words, making it highly concise and well-structured.

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

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

Given the tool's moderate complexity (5 parameters, mutation operation) and lack of output schema, the description is adequate but incomplete. It covers the basic action and entity referencing but misses details on usage context, potential errors, or result implications, leaving gaps for an AI agent to infer behavior.

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

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

Schema description coverage is 80%, providing good documentation for parameters like 'entity_one' and 'constraint_type'. The description adds minimal value beyond the schema, only implying entity indexing without explaining parameter interactions or constraints like when 'entity_two' is required. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('Add a geometric constraint') and resource ('in the active sketch'), with specific mention of how entities are referenced ('by index within the sketch'). It distinguishes from siblings like 'create_sketch' or 'draw_line' by focusing on constraints rather than creation or drawing, though it doesn't explicitly differentiate from all constraint-related tools (none listed).

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites (e.g., needing an active sketch), or exclusions. It mentions the active sketch but doesn't clarify if other tools might be needed first or when constraints are applicable in a workflow.

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

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

Annotations declare the safety profile (not read-only, not idempotent, not destructive), so the description doesn't need to restate it. But it discloses nothing about behavior beyond that: no mention of what happens on over-constraint, that the operation is undoable, or what state the sketch must be in.

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 with the core action front-loaded. The second and third sentences restate the same cm/degrees rule, which is redundant rather than wasteful, so it stays readable but could be tightened.

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

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

For a 5-param mutation tool with no output schema and no annotations covering failure/state behavior, the description is minimally adequate: it covers units but omits sketch-state prerequisites and constraint-conflict behavior an agent would need.

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 80%, so the baseline is 3. The description's unit conventions (cm for lengths, degrees for angles) largely duplicate what the schema already states on the value parameter, adding little beyond it.

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 (add), resource (driving dimension), and scope (sketch geometry constraint). An agent can distinguish it from add_constraint (which adds geometric constraints) and measure_distance/measure_angle (which measure rather than constrain).

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

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

No indication of when to use this versus the sibling add_constraint or auto_constrain, nor prerequisites such as the sketch needing to be active/edited. The only guidance given is about units, which is parameter semantics rather than usage 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?

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds minimal behavioral context beyond annotations—it implies creation but doesn't detail effects like persistence, error conditions, or dependencies. With annotations covering safety, a 3 reflects some added value but limited depth.

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

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

The description is a single, efficient sentence with no wasted words, front-loading the core action. It's appropriately sized for the tool's complexity, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (3 parameters, no output schema), the description is incomplete. It lacks usage guidelines, detailed parameter explanations, and behavioral insights like how joints interact with components or what happens on failure. Annotations help but don't fully compensate, leaving gaps for an agent to operate effectively.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'two components' and 'joint', hinting at 'component_one' and 'component_two', but doesn't explain their format or the 'joint_type' enum meanings. This adds minimal semantics beyond the bare schema, failing to address the coverage gap adequately.

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

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

The description clearly states the action ('Add') and resource ('a joint between two components'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'add_constraint' or 'create_as_built_joint', which might have overlapping functionality in a CAD/mechanical context.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools (e.g., 'add_constraint', 'create_as_built_joint'), the description lacks context about prerequisites, typical scenarios, or exclusions, leaving the agent to 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?

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the safety profile is partly structured. The description adds genuinely non-redundant behavior: option 3 may move geometry within tolerance, and the tool requires Fusion 2026+ AutoConstrain API. It doesn't say what happens to pre-existing constraints or how failure is reported, so not a 5.

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

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

Front-loaded with the core action, followed by a compact option mapping and a version note. It is efficient, though the option mapping duplicates the schema and is slightly redundant.

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

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

For a two-parameter tool with no output schema, the description covers the action, the outcome, the version requirement, and the notable side effect of the geometry-moving option. No return values need explaining, and nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so result_option's meaning is already fully documented in the schema, and the description's '1 = thorough/slow, 2 = fast, 3 = may move geometry' largely restates it. No added syntax, bounds rationale, or interaction between the option and sketch_name is provided, so baseline 3 is correct.

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 (add geometric constraints and dimensions), the resource (a sketch), and the outcome (fully constrain), which clearly separates it from the manual add_constraint/add_dimension siblings. It stops short of explicitly naming those siblings as alternatives, so it is clear but not maximally differentiating.

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 'fully constrain a sketch' — an agent can infer this is the bulk alternative to manually adding constraints. However, it never states when to prefer this over add_constraint/add_dimension, nor any prerequisites (e.g., which sketch state is valid), leaving the routing 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?

Adds real value beyond the sparse annotations (readOnly=false, idempotent=false, destructive=false): it discloses that Fusion silently discards the tool body's geometry on a non-touching join and that the tool instead refuses proactively and reports the minimum distance. This failure-mode disclosure is exactly the kind of context annotations cannot carry.

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 operation and modes, then the one non-obvious precondition. No filler, and the parenthetical failure explanation earns its length by preventing a silent-success trap.

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?

A destructive-in-effect modeling operation with no output schema and zero schema documentation is partially covered: the join-touch pitfall is handled, but cut/intersect behavior, body consumption, and result/report format are left unspecified.

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 names target_body and tool_body and states their required relationship for join, and its operation vocabulary matches the enum, but it never explains what happens to the tool body (consumed?), the default mode, or how target vs tool roles differ for cut/intersect.

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 (combine), the exact resource (two named bodies), and enumerates the three modes (join/cut/intersect), which maps 1:1 to the schema enum. It is clearly separable from neighbors like split_body, mirror, or loft.

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

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

It gives an important precondition for the 'join' mode (bodies must touch or overlap), but there is no guidance on when to choose join vs cut vs intersect, nor on prerequisites such as selecting bodies in the same component. Usage is implied by the mode names rather than explained.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, non-idempotent), so the description adds rather than carries this. It usefully discloses a cross-cutting behavioral convention (units in cm, angles in degrees) that is not derivable from the annotations, but omits workflow consequences such as needing a tool before toolpaths can be generated.

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, front-loaded with the core action and immediately followed by the two facts (strategy semantics, unit conventions) an agent most needs. 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 12-parameter mutation tool with no output schema, the description covers the essential unit convention, but the schema carries all critical gotchas (tool_number fallback, modal freeze, geometry_face_index requirements). The description itself leaves the workflow context — sequencing with toolpath generation — unstated.

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 already 92%, so the baseline is 3. The description goes beyond the schema by stating the global unit convention for lengths, coordinates and angles, which disambiguates several numeric parameters whose schema notes are terse or absent.

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

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

The description states a specific verb and resource ('Add a machining operation to a setup') and clarifies the role of the strategy parameter. It is clear against generic siblings, though it never names or distinguishes itself from close CAM siblings like cam_create_setup or cam_generate_toolpath.

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

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

There is no when-to-use guidance and no exclusions. It does not say that a setup must exist first, nor when to follow this with cam_generate_toolpath or cam_post_process, so the agent must infer the CAM workflow from sibling names alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds useful behavioral context about unit conventions (cm and degrees unless stated otherwise) and clarifies what the setup defines, but does not disclose what happens on repeated calls, whether existing setups are modified, or any permission requirements.

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

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

Three sentences, front-loaded with purpose and followed by unit conventions. The middle sentence about stock, coordinate system, and operation type is slightly redundant with the purpose but still adds useful detail without bloat.

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 output schema, the description covers purpose and unit semantics but leaves gaps in workflow context, return values, and behavior relative to sibling CAM tools. It is adequate but not fully complete for an agent navigating CAM operations.

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 71%, and the description adds a global unit convention that applies across parameters, which is valuable beyond the schema's per-parameter hints. However, it does not explain the stock_mode options or add meaning to the enum parameters beyond restating the operation_type choices.

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 ('Create') and resource ('manufacturing setup for a body'), and lists what it defines (stock, coordinate system, operation type). It distinguishes this from sibling CAM tools only implicitly through the resource, not by explicitly naming alternatives like cam_create_operation.

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

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

The description offers no guidance on when to use this tool versus alternatives such as cam_create_operation or cam_list_setups. There is no explicit when/when-not, nor any mention of prerequisites or typical workflow 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 annotations already covering the safety profile (not read-only, not idempotent, not destructive), the description adds no behavioral context beyond restating what the schema parameters already say. It does not disclose computational cost, side effects on the CAM setup, or prerequisites for successful generation.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the action and its scope.

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 100% schema coverage and present annotations, the description is minimally adequate. However, it omits any usage context, prerequisites, or behavioral implications for a CAM mutation tool. With no output schema, it need not explain return values, but it could do more to orient an agent.

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

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

Schema description coverage is 100%, so the schema already fully documents setup_name, generate_all, and operation_name. The description's phrase 'specific operation or all operations in a setup' aligns with those parameters but adds no syntax or constraints beyond what the schema provides. Baseline 3 is appropriate.

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: generate toolpaths for a specific operation or all operations in a setup. It is clear what the tool does, though it does not explicitly differentiate itself from sibling CAM tools like cam_create_operation or cam_post_process.

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 basic use case (generate toolpaths for an operation or setup) but gives no explicit guidance on when to use this tool versus alternatives such as cam_create_operation or cam_post_process. No prerequisites or exclusions are stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, repeatable read operation. The description adds value by specifying the types of details returned (strategy, tool, parameters, toolpath status), which provides context beyond annotations. However, it doesn't disclose other behavioral traits like error conditions, rate limits, or authentication needs.

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 purpose ('Get details about a specific operation') and specifies the key details retrieved. There is no wasted wording, and it's appropriately sized for a simple read operation.

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 low complexity (a read operation with 2 parameters), rich annotations (covering safety and idempotency), but no output schema, the description is partially complete. It specifies what details are returned, which helps, but lacks parameter explanations and usage guidelines. For a tool with good annotations but no output schema, this is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description doesn't add any parameter-specific information—it doesn't explain what 'setup_name' or 'operation_name' represent, their formats, or examples. With 2 required parameters and no schema descriptions, the baseline is 3 as the description doesn't compensate for the coverage gap.

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

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

The description clearly states the verb 'Get' and the resource 'details about a specific operation', specifying what information is retrieved (strategy, tool, parameters, toolpath status). It distinguishes from siblings like 'cam_list_operations' by focusing on details of a single operation rather than listing multiple, though it doesn't explicitly contrast with 'get_object_info' or 'get_parameters' which might overlap in domain.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid setup and operation name), exclusions, or compare it to similar tools like 'cam_list_operations' for listing or 'get_object_info' for general object details. Usage is implied by the name but not explicitly 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?

Annotations indicate read-only, idempotent, and non-destructive behavior, which the description does not contradict. The description adds context by specifying the scope ('within a setup'), which is not covered by annotations. However, it lacks details on output format (e.g., list structure, pagination) or any rate limits, though annotations cover safety aspects well.

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 with zero wasted words. It is front-loaded with the core purpose and avoids redundancy. Every part of the sentence earns its place by specifying the action and scope.

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 low complexity (1 parameter, read-only per annotations) but lack of output schema, the description is minimally adequate. It covers the basic purpose and scope but misses details like output format or error handling. With annotations providing safety context, it meets a baseline but could be more informative for agent use.

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

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

The input schema has 1 parameter with 0% description coverage, so the description must compensate. It implies 'setup_name' is required to scope the listing but does not explain its format, constraints, or examples. The description adds minimal meaning beyond the schema, meeting the baseline for low coverage without fully compensating.

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

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

The description 'List operations within a setup' clearly states the verb ('List') and resource ('operations'), specifying the scope ('within a setup'). It distinguishes from siblings like 'cam_list_setups' (which lists setups rather than operations) and 'cam_get_operation_info' (which gets details of a specific operation). However, it does not explicitly mention what 'operations' refer to (e.g., CAM machining operations), leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an existing setup), exclusions, or comparisons to siblings like 'cam_get_operation_info' for detailed info or 'cam_list_setups' for listing setups. Usage is implied by the name and context but not explicitly 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?

Annotations already indicate this is a read-only, idempotent, non-destructive operation. The description adds minimal behavioral context beyond this, stating it lists 'all' setups, which implies completeness but doesn't detail format, pagination, or error handling. No contradiction with annotations exists.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse.

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

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

Given the tool's simplicity (0 parameters, no output schema, and annotations covering safety), the description is adequate but minimal. It could be more complete by adding details like return format or usage context, but it's not incomplete for a basic list operation with good annotations.

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

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

With 0 parameters and 100% schema description coverage, the schema fully documents the lack of inputs. The description doesn't need to add parameter details, and it doesn't introduce any confusion, so it meets the baseline for this scenario.

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 ('List') and resource ('all manufacturing setups in the document'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'cam_list_operations' or 'list_components', which would require mentioning the specific scope of CAM setups versus other listable entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention context, prerequisites, or exclusions, such as whether it should be used for CAM-specific setups only or how it relates to other list tools like 'cam_list_operations' or 'list_components'.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is partially covered. But the description adds nothing behavioral: it never mentions that the tool writes G-code files to disk (output_folder), what happens on repeat runs or whether existing output is overwritten.

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 clause with no filler or redundancy. It is tight, though the brevity contributes to the specification gaps noted elsewhere rather than being an independent virtue.

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 6-parameter CAM operation with no output schema, the description omits prerequisites, the relationship to cam_generate_toolpath, and the fact that the operation produces files as side effects. An agent could invoke it correctly from the schema alone but lacks the workflow context.

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

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

Schema description coverage is 83% with rich per-parameter notes (e.g., the fanuc integer-only program_name constraint, post-processor resolution rules), so the schema carries the semantic load. The description adds no parameter meaning beyond naming the G-code output, making the baseline 3 appropriate.

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 gives a specific verb+resource+result: post-processes toolpaths to produce NC code (G-code), which is clearly distinct from CAM siblings like cam_create_setup and cam_create_operation. It does not, however, differentiate itself from cam_generate_toolpath, which an agent could plausibly confuse it with.

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

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

There is no guidance on when to use this versus cam_generate_toolpath, nor on prerequisites such as needing an existing setup with generated toolpaths. The only usage signal ('omit to post all in setup') lives in the schema, not the description.

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

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

With annotations declaring readOnlyHint=false, idempotentHint=false and destructiveHint=false, safety is partly covered. The description usefully adds the unit convention (cm, not mm; angles in degrees) and implies the operation is non-idempotent via the schema's convexity failure note, but says nothing about failure modes, needed selections, or reversibility itself.

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

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

Two short sentences, purpose front-loaded before the unit caveat. 'Unless a parameter says otherwise' is slightly vague but does not waste much space.

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

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

For an 11-parameter mutation tool with no output schema, the description covers the highest-risk ambiguity (units) but omits how body_name and body_index interact, what happens if no edges match the filters, and whether the operation must be undone rather than reversed. Adequate but with clear gaps.

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

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

At 64% schema coverage, the schema documents the bounding-box filters, convexity and edge_selection, but leaves 'distance' and 'body_name'/'body_index' undescribed. The description only supplies unit semantics ('lengths and coordinates in cm, angles in degrees'), which partially compensates and largely repeats the per-parameter cm notes already in 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?

States a specific verb and resource ('Chamfer edges of a body'), which is unambiguous and distinguishable from the geometric siblings fillet/shell by name alone. It stops short of explicitly contrasting with fillet, which would be the natural confusion point.

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

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

No when-to-use guidance, no prerequisites (e.g. body selection), and no mention of when to prefer fillet or split face instead. The agent must infer applicability purely from the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new information about the result (interference volumes reported in cm³), which matters since no output schema exists, though it says nothing about how results are structured (per-pair list vs. single boolean).

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

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

Two short, front-loaded sentences with zero filler. The core action comes first and the return-unit note follows.

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, read-only geometry query with no output schema, the description covers the action, the units of the result, and the collision semantics implied by the name. It stops short of describing the shape of the returned result set, which is the only real 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 description coverage is 100%, so both parameters (component_names, include_coincident_faces) are fully documented in the schema. The description adds no syntax or format detail beyond it; baseline 3 applies.

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 ('Detect collisions between components/bodies') and adds the output unit ('Interference volumes in cm³'), which clearly distinguishes it from measurement siblings like measure_distance or get_bounding_box. It does not explicitly name alternatives, but the operation is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., measure_distance, compare_meshes), no prerequisites, and no indication of when component selection is appropriate. The agent must infer the use case purely from the name and one-line purpose.

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 annotations already declaring it is a non-readonly, non-idempotent, non-destructive write, the description adds the crucial outcome distinction: without feature_name you get N separate overlapping bodies rather than copies of a feature in one body. It also adds a non-obvious units rule (cm not mm). It stops short of describing whether the source body/feature is preserved or what the call returns.

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?

Dense but front-loaded — the body-vs-feature distinction leads, and the units caveat closes. Slightly long relative to the operation, but nearly every clause carries decision-relevant information rather than restating the 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?

For a 5-param mutation with no output schema and no annotations on safety nuance, the description covers the mode selection and units cleanly. It leaves minor ambiguity — whether the original counts toward 'N times' and whether the source geometry is consumed — but nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 60%, and the description compensates well: it explains the interaction between feature_name and body_name (body_name stays required only to resolve the axis) and pins down units for lengths, coordinates, and angles. It leaves 'count' and 'total_angle' semantics to the schema, which documents them adequately.

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 ('Pattern a body OR a feature around an axis') and immediately disambiguates the two modes. An agent can distinguish this from rectangular_pattern and mirror without opening the schema.

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

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

Explicitly says when to omit feature_name (turntable-style whole-part copy) versus when to pass it (bolt circle, repeated hole), and names the sibling create_hole as the source of feature_name. Both branches of the decision are spelled out with examples.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds value by disclosing the computed output fields, units (cm), and the Fusion version requirement. No behavioral trait contradicts the annotations.

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

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

A single, information-dense sentence front-loads the core operation, then states output units, a motivating example, and version compatibility without redundancy. 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 low-complexity, read-only tool with two fully described parameters, the description supplies the missing output semantics (statistics and units) and a prerequisite, leaving no critical gap in the absence of an output schema.

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

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

Schema coverage is 100%: both parameters are already described as 'Name of the first mesh body' and 'Name of the reference mesh body.' The description only reinforces the reference-mesh role and adds no syntax, constraints, or format details to the parameters.

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

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

The description opens with a specific verb+resource ('Compare two mesh bodies') and specifies the exact output (deviation statistics: min/max/mean/RMS signed distance in cm). The example clearly differentiates this from generic measurement tools like measure_distance or get_physical_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?

It provides a clear use case ('validate an imported STL against a reference mesh') and a compatibility prerequisite ('Requires Fusion 2026+'). However, it does not explicitly state when not to use it or name alternative sibling tools, so it falls just short of full guidance.

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

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

Discloses a non-obvious behavioral trait beyond the annotations: thickness is taken from the geometry, not from the rule. This corrects the natural assumption that rule_name governs thickness. Annotations only cover read/write and idempotency hints, so this added context is genuinely 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?

Three tight sentences, front-loaded with the core action and followed by the two facts an agent actually needs (thickness source, alternative workflow). 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 3-parameter mutation tool with no output schema, the description covers purpose, workflow prerequisite, and the key thickness behavior. It does not state what happens to the original solid body or what the call returns, a minor gap given the annotations cover safety hints.

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 67% with rule_name ('Default: first available') and face_index ('Default: largest planar face') already documented in the schema; body_name is undocumented. The description clarifies that thickness does not come from the rule, adding meaning to rule_name, but does not otherwise expand parameter semantics.

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

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

States a precise verb and resource: 'Convert a solid body of uniform thickness into sheet metal,' including the precondition (uniform thickness) that qualifies which bodies are eligible. It does not explicitly differentiate from the closest sibling fold_sheet_metal, so it falls short of 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?

Gives strong context: it replaces flange creation because the Fusion API doesn't expose it, and prescribes the workflow ('model the shape with extrude/shell, then convert'). No explicit exclusions or named alternatives among siblings, so 4 rather than 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?

Annotations indicate the tool is not read-only, idempotent, or destructive, which the description does not contradict. The description adds context about using 'components' current positions' and being 'easier than geometric joints,' offering some behavioral insight beyond annotations, but lacks details on permissions, side effects, or response format.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It avoids redundancy and wastes no words, though it could be slightly more structured by explicitly listing key parameters or usage scenarios.

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 (3 parameters, 0% schema coverage, no output schema, and annotations only covering basic hints), the description is inadequate. It lacks details on parameter semantics, behavioral traits like error handling, and does not reference sibling tools, making it incomplete for effective agent use.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'components' current positions' and 'joint,' hinting at 'component_one' and 'component_two,' but does not explain parameter meanings, the 'joint_type' enum options, or their implications, leaving significant gaps in understanding.

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

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

The description clearly states the action ('Create a joint') and the resource ('from components' current positions'), with a specific verb and target. It distinguishes itself from geometric joints by noting it's 'easier,' though it doesn't explicitly differentiate from sibling tools like 'add_joint' or 'create_rigid_group.'

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

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

The description provides minimal guidance, only implying usage when easier joint creation is needed compared to geometric methods. It does not specify when to use this tool over alternatives like 'add_joint' or 'create_rigid_group,' nor does it mention prerequisites or exclusions, leaving usage context vague.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the mutation/safety profile is largely covered. The description adds non-obvious behavioral context that annotations cannot: the center_z-as-bottom-face convention with a live-verified example, plus the cm/degree unit system. It stops short of describing side effects such as whether repeated calls stack bodies or which component receives the result.

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 dense sentences, front-loaded with the core purpose and non-parametric caveat before the parameter/unit details. Every sentence earns its place, though the parenthetical source attribution adds slight noise.

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 6-parameter mutation tool with no output schema and 0% schema description coverage, this covers the highest-risk ambiguities (units, center convention). It does not address what the call returns or the default placement context, which would matter for an agent chaining calls.

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 carry the load, and it does: it disambiguates the three center_* parameters (XY center vs Z bottom face) with a concrete numeric example and specifies the unit system (cm, degrees) that the schema leaves entirely unstated. length/width/height semantics are left to be inferred from 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 verb and resource ('Create a box primitive') and immediately qualifies the implementation mode ('non-parametric via TemporaryBRepManager'), which is exactly what distinguishes it from the sibling create_box_parametric. An agent can select correctly without opening either 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 parenthetical '(non-parametric via TemporaryBRepManager)' implies when this tool is appropriate versus its parametric sibling, but it never names create_box_parametric or states the condition explicitly ('use X if you need editable parameters'). Usage is therefore implied rather than directed.

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

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

Annotations already cover read/write safety hints, and the description adds useful behavioral context: it creates a history feature via sketch+extrude, accepts expressions, and has a create_parameter prerequisite. It does not describe failure modes or return behavior, but with annotations present the added context 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?

The description is dense but front-loaded: purpose and sibling distinction first, then parameter semantics, then the create_parameter prerequisite, then units. Every sentence carries relevant information for correct invocation.

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 9-parameter creation tool with no output schema, it provides the critical context: method, expression support, prerequisite, and unit convention. It does not explain the plane orientation meaning or what the tool returns, but those gaps are minor given the schema and annotations.

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

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

Schema coverage is 67%, so the description must add value. It explains that length/width/height accept either a number in cm or a string expression, gives examples like '56 mm' and 'outer - 2 * wall_t', and clarifies that lengths/coordinates default to cm while angles are degrees. It leaves plane enum semantics and some origin/body/component details to 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?

States a specific verb+resource ('Create a history-based rectangular box') and immediately distinguishes it from the sibling create_box by implementation method. An agent can tell which box tool to choose without opening either 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?

Provides clear context: this is history-based and expression-capable, unlike create_box, and requires create_parameter first for named parameters. It does not explicitly spell out when to prefer create_box, but the alternative and prerequisite are clear 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?

Annotations already indicate this is a non-readonly, non-idempotent, non-destructive operation. The description adds minimal context beyond this - it specifies 'new component (sub-assembly)' which clarifies the type of object being created, but doesn't address behavioral aspects like permissions needed, what happens on duplicate names, or response format.

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 gets straight to the point with zero wasted words. It's appropriately sized for a simple creation tool and front-loads the essential information.

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

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

For a creation tool with good annotations (readOnlyHint=false, destructiveHint=false) and full schema coverage, the description is minimally adequate. However, without an output schema and with many similar sibling tools, it could benefit from more context about what constitutes a 'component' versus other creatable objects and what the tool returns.

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 100% schema description coverage, the schema already documents both parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema - no examples, formatting details, or clarification about the parent-child relationship implied by 'sub-assembly'.

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

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

The description clearly states the action ('Create') and resource ('new component (sub-assembly) in the design'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_box' or 'create_cylinder' that also create objects but of different types.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling 'create_' tools (e.g., create_box, create_cylinder, create_sketch), there's no indication of when a component is appropriate versus other object types, nor any prerequisites or exclusions 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?

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the mutation/non-destructive profile is already covered. The description adds genuinely useful unit-convention context (cm not mm, degrees) but says nothing about failure modes or per-method behavior.

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

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

Two tightly written sentences with the core action front-loaded and the unit caveat immediately after. No wasted words.

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

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

No output schema exists so return values needn't be described, and the unit note is valuable. However, the four-method enum with divergent parameters (body_name/edge_index vs plane_one/plane_two vs point_one/point_two) is left entirely unexplained, which is a meaningful gap for a modeling agent.

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

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

Schema coverage is 57%, with method, point_one, and point_two lacking schema descriptions. The description partially compensates by stating the unit convention (cm, degrees), which is critical for the point coordinates, but adds nothing about method values.

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

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

States a clear verb+resource: 'Create a construction axis.' This distinguishes it from sibling create_construction_plane by resource type, though it doesn't explain how the four methods differ from each other.

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

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

No when-to-use guidance or alternatives are given. The agent isn't told which of the four methods to pick or under what conditions, and no sibling routing (e.g., plane vs axis) is offered.

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

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

Annotations already declare this is a non-read-only, non-idempotent, non-destructive operation. The description adds default unit context (cm/degrees) but does not disclose permissions, side effects, or other behavioral traits beyond the annotations.

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

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

Two sentences, front-loaded with the core purpose and followed by an important default-unit caveat. No filler or redundant information.

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

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

For a tool with 10 parameters and five construction methods, the description is minimal. It adds unit context but does not explain method-specific parameter usage, and no output schema exists to cover return behavior.

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

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

Schema description coverage is 90%, so baseline is 3. The description adds meaningful semantics by clarifying that lengths and coordinates are in cm and angles in degrees unless a parameter overrides this, which supplements point parameters whose schema entries lack unit 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?

States a specific verb and resource: 'Create a construction plane for sketching.' An agent can identify the tool's purpose, though the description does not distinguish it from similar siblings like create_construction_axis or create_ucs.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. 'For sketching' hints at context but does not route between alternatives or state 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?

Annotations cover safety (readOnly=false, idempotent=false, destructive=false), so the bar is lower. The description adds valuable behavioral context beyond that: the result is a non-parametric body, the base circle position convention, that direction_* overrides axis, and the critical units caveat (cm not mm, degrees). It stops short of saying whether the new body is selected/merged or what happens on failure.

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

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

A tight paragraph where each clause adds information (variant, mechanism, geometry layout, axis override, units). The nested parenthetical about TemporaryBRepManager slightly interrupts flow, but nothing is redundant.

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 10-parameter primitive-creation tool with no output schema, the description supplies the geometry semantics, the non-parametric nature, and the non-obvious cm/degree unit convention. It is largely self-sufficient; only the return value and any preconditions (an open design/component context) are left implicit.

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 only 30%, so the description must compensate, and it largely does: it explains base_x/y/z as the base circle centre, that height runs along axis, that direction_x/y/z override axis, that top_radius produces a cone, and the global unit convention for lengths and angles. The few remaining undescribed params (e.g., direction_y/z) are inferable from the direction_x note.

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

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

States a specific verb and resource ('Create a cylinder... primitive') and even names the cone variant via top_radius, plus the underlying mechanism (TemporaryBRepManager, non-parametric). However, it does not differentiate itself from sibling primitive creators like create_box, create_sphere, or create_torus, nor from parametric feature tools such as extrude.

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 'non-parametric via TemporaryBRepManager' note implicitly signals when this is appropriate (throwaway geometry vs. a parametric feature), and the direction-vector example ('an inclined valve bore') hints at use cases. But there is no explicit when-to-use/when-not guidance or named alternative among the many sibling creation tools.

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

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

Annotations already disclose a non-read-only, non-idempotent, non-destructive mutation. The description contributes a genuinely useful behavioral convention (cm and degrees by default) that is not in the annotations, but it says nothing about preconditions, whether an existing body/face is required, or what happens on failure.

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

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

Two short sentences, front-loaded with the action and followed immediately by the cross-cutting unit convention. Nothing is wasted.

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

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

For a 7-parameter mutation tool with 43% schema coverage and no output schema, the description covers units but leaves body identification (body_name vs body_index) and the semantics of the required depth/diameter under-explained. Adequate but with clear gaps.

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

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

Schema coverage is only 43%, so the description carries weight; the unit statement (cm, degrees) usefully applies to depth/diameter/center coordinates. However, it does not clarify the relationship between body_name and body_index, nor the meaning of depth relative to the selected face, so several undocumented parameters remain opaque.

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 hole feature on a body face'), which an agent can distinguish from sibling feature tools like extrude, shell, or chamfer. It doesn't explicitly distinguish itself from shape primitives such as create_cylinder, but the 'feature on a body face' framing is reasonably clear.

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

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

No guidance on when to use this versus alternatives such as create_cylinder, extrude with a cut, or boolean_operation. No preconditions (e.g., an active design or an existing body) are stated; the only usage-like content is the unit convention.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is already covered. The description adds useful behavioral context by stating the default unit convention: lengths/coordinates are in cm not mm, and angles in degrees. It still does not disclose duplicate-name behavior or return values.

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

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

The description is two sentences, front-loaded with the core action and then the important unit convention. It is concise and has 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 four-parameter creation tool with full schema coverage and annotations, the description supplies the essential purpose and unit context. It omits return-value information, but that is a minor gap given the simplicity of the 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?

Schema description coverage is 100%, so the schema already documents each parameter. The description adds meaning beyond the schema by clarifying the default unit convention for values, which is relevant when using the required 'unit' 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 states a specific verb and resource: 'Create a new user parameter.' The word 'new' also distinguishes it from set_parameter, which likely modifies an existing parameter.

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

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

Usage is implied by 'Create a new user parameter' — use it when a parameter does not already exist. However, the description does not explicitly say when not to use it or name set_parameter as the alternative for existing parameters.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the mutation profile is covered by structured data. The description adds real value by disclosing the 'most recent sketch' target and the cm/degree unit convention, but omits what happens if no sketch is active and whether it creates geometry non-idempotently.

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

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

Two short sentences, front-loaded with the action and target; the unit caveat is appropriately placed at the end. No filler, though the second sentence is a generic caveat rather than parameter-specific detail.

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

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

For a 5-parameter creation tool with no output schema and low schema coverage, the description covers target context and units but leaves the sketch prerequisite, failure modes, and most parameter semantics undocumented.

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 only 20% (just radius), so the description must compensate. It does partly by stating that lengths and coordinates default to cm and angles to degrees, which clarifies center_x/y/z and radius, but 'sides' and the center point meaning remain unexplained 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?

States a specific verb (Draw) and resource (regular polygon) plus the target location ('most recent sketch'). This cleanly distinguishes it from draw_rectangle, draw_circle, and draw_line by resource name, though it does not name those siblings explicitly.

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

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

There is no when-to-use/when-not guidance and no mention of alternatives such as draw_circle (a polygon as a many-sided alternative) or the requirement that a sketch must already exist. Only the unit convention is supplied, which is not usage 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?

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, which the description aligns with by implying a creation action ('Lock'). The description adds minimal behavioral context beyond annotations—it hints at grouping behavior but doesn't detail effects like persistence, reversibility, or interaction with other operations. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence with zero wasted words—'Lock multiple components together' directly conveys the core action. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.

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

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

Given the tool has no output schema and annotations cover basic safety (non-destructive), the description is minimally adequate. It states the purpose but lacks details on behavioral outcomes, error conditions, or integration with sibling tools. For a creation tool with 2 parameters, it meets a bare minimum but doesn't provide rich contextual guidance.

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

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

Schema description coverage is 100%, with clear parameter documentation: 'component_names' (array of strings, min 2 items) and 'include_children' (boolean, default true). The description 'Lock multiple components together' loosely relates to 'component_names' but adds no specific semantics beyond the schema, such as format examples or grouping implications. Baseline 3 is appropriate given high schema coverage.

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

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

The description 'Lock multiple components together' clearly states the tool's function with a specific verb ('Lock') and resource ('components'), and the 'rigid' aspect is implied. However, it doesn't explicitly differentiate from sibling tools like 'create_component' or 'add_joint', which could also involve component relationships, leaving some ambiguity about its unique role.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'create_component', 'add_joint', or 'boolean_operation' that might handle component interactions, there's no indication of specific use cases, prerequisites, or exclusions for 'create_rigid_group'.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the agent knows this mutates state but is not destructive. The description adds a genuinely useful behavioral detail (default units are cm, not mm, and angles in degrees) but says nothing about whether the section persists as a feature, what gets created in the tree, or how repeated calls behave.

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

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

Two short sentences with the core action front-loaded and no filler. The unit caveat is worth its space, though the hedge 'Unless a parameter says otherwise' is slightly loose for two parameters, only one of which carries units.

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

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

With no output schema and low schema coverage on the plane enum, the description should say what the tool produces and whether the section is a persistent feature. The unit convention is covered, but the return/result behavior is entirely absent.

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?

Coverage is 50%: 'offset' is documented in the schema as cm, but 'plane' is only an enum with a default and no explanation of the planes' orientation. The description's unit note reinforces the offset semantics but adds no meaning for the plane 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?

States a specific verb+resource ('Cut a section plane through the model'), so an agent knows this creates a cross-section. It does not distinguish itself from nearby siblings like create_construction_plane or split_body, which a stronger definition would do.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as split_body or create_construction_plane. The agent must infer applicability purely from the name and one-line description.

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

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

Annotations already declare this is a non-readonly, non-idempotent, non-destructive mutation, so the safety profile is covered. The description adds genuinely useful context—units are cm not mm and angles are degrees—but says nothing about what is returned (sketch identity) or what happens on duplicate/failed creation.

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

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

Two compact sentences with the core action front-loaded and the units caveat second. Nothing is wasted, though the appended units clause could be tightened.

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

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

For a mutation tool with no output schema and only partial param coverage, the unit convention helps but leaves gaps: no return value, no prerequisite design context, no interaction with the sketch's parent body/component.

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 50%: z_offset is documented in the schema while plane relies on its enum. The description reinforces the cm unit for lengths/offsets, which is added value, but it does not explain the plane enum or the offset's direction/sign convention.

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

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

States a specific verb+resource (create sketch) and constrains it to the three named planes with an optional offset, so an agent can tell it apart from primitives like create_box or curve tools like draw_line. It does not differentiate itself from the related create_construction_plane sibling, but the resource is unambiguous.

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

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

No when-to-use or when-not-to-use guidance is given; it never says whether this should precede draw_rectangle/draw_line or how it relates to create_construction_plane. The unit convention is the only contextual rule offered.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds the non-parametric BRep nature and the unit convention, which is genuine extra context, but says nothing about where the body is created (active component/design) or whether it is unlinked geometry.

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 tight sentences with the core action front-loaded and the unit caveat second. No filler, though the parenthetical implementation detail could arguably be trimmed.

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

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

For a simple 4-parameter primitive with no output schema, the description covers units and the geometry type, which is the essential information. It leaves open the resulting body's context (component, naming, editability), a minor but real gap for a creation 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 schema documents only types and defaults. The description compensates for units (cm and degrees) for radius and center coordinates, which is valuable, but it explains none of the individual parameters' meaning or geometry.

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 sphere primitive') and adds a meaningful qualifier that it is non-parametric via TemporaryBRepManager, distinguishing it from a parametric solid. It does not explicitly contrast with the other primitive creators (create_box, create_cylinder, create_torus), but the name and mechanism make the target 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 mention of 'non-parametric' implies when this is appropriate versus a parametric primitive, but the description never states when to choose it or what alternatives exist. Usage is only inferable, not 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?

Annotations already declare readOnly=false, idempotent=false, destructive=false, so safety is covered. The description adds a genuinely useful behavioral detail: the global unit convention (cm not mm, angles in degrees) applies unless a parameter overrides. It says nothing about what happens to a pre-existing thread, failure modes, or whether the operation is reversible.

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

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

Two sentences, front-loaded with the action and resource, followed by the unit caveat. The second sentence is slightly awkward in phrasing ('Unless a parameter says otherwise, lengths and coordinates are in cm') but nothing is wasted.

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

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

For a 12-parameter, non-idempotent mutation tool with no output schema, the description covers mode and units but omits replacement semantics, error behavior, and any indication of what is returned. An agent can invoke it, but not fully predict its effects.

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

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

Schema coverage is 75%, so the schema documents most parameters itself, and the description's only addition is the repo-wide unit convention (cm/degrees). It does not clarify the near_x/near_y/near_z triple, the face_index tie-break, or valid thread_type/thread_class values beyond what the schema already says. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Add threads to a cylindrical face') plus the two modes (cosmetic or modeled), which is more than the title alone. No sibling tool covers threads, so there is nothing to disambiguate from in the sibling list, which keeps it just short of 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?

Implicit guidance appears in the schema (near_x 'Instead of face_index', is_internal 'Omit it: it is inferred') but the description itself gives no when-to-use/when-not-to-use or alternative-tool routing. Adequate but thin.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations by stating that the torus is non-parametric via TemporaryBRepManager and that lengths/coordinates default to cm and angles to degrees.

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 definition is two sentences with no wasted words. The purpose is front-loaded, followed immediately by the unit caveat, making it easy to parse despite a minor punctuation 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 simple primitive-creation tool with annotations and no output schema, the description covers purpose, method, and units adequately. However, it omits side-effect context such as whether it adds a new body to the active design and does not route the agent among similar creation tools.

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

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

Schema description coverage is low at 33%, with only major_radius and minor_radius documented in the schema. The description compensates by specifying the critical unit convention for lengths, coordinates, and angles, which is absent from the schema and affects most numeric parameters.

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

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

The description states a specific verb and resource: "Create a torus primitive." The parenthetical "non-parametric via TemporaryBRepManager" clarifies the creation method and distinguishes it from parametric primitive creators such as create_box_parametric, though no sibling is named explicitly.

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

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

There is no guidance on when to use this tool versus alternatives like create_sphere, create_cylinder, or parametric creation tools. Usage is only implied by the tool name: call it when a torus primitive is needed.

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

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

Annotations cover the safety profile (readOnly=false, idempotent=false, destructive=false), but the description adds a genuinely non-obvious side effect: a hidden anchor sketch is created and must not be deleted. That is behavior an agent could not infer from the schema or annotations. It stops short of covering naming conflicts 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 sentences, front-loaded with what is created, then the side effect, then the unit convention. No filler and each sentence carries a distinct piece of information.

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

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

For a 7-parameter, all-optional tool with no output schema and no annotations beyond hints, the description covers purpose, units, preview status and the hidden-sketch caveat. It is slightly thin on the active-design/component context the UCS is created in and does not mention any return value, though nothing critical is missing.

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

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

Schema coverage is 100% and each parameter already carries a unit annotation, so the baseline is 3. The description earns above baseline by reinforcing the cross-cutting unit convention ('cm, not mm') and noting that per-parameter overrides exist, which guards against the common mm assumption in Fusion workflows.

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 UCS') plus the key coordinate inputs and optional rotation. No sibling tool creates a UCS, so there is nothing to confuse it with, and the parenthetical version note adds precision.

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 flags that this relies on the Fusion 2026+ UCS API and is in preview, which is real usage context, but it never states when to reach for this versus, say, create_construction_plane or create_construction_axis, nor any 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?

Annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds value by clarifying the scope ('all timeline items') and the action ('Clear'), which aligns with annotations and provides context on what gets destroyed. No contradiction exists.

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

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

The description is a single, efficient sentence that front-loads the core action ('Clear the design') and specifies the target ('delete all timeline items') without any redundant information. Every word serves a purpose.

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

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

Given the tool's destructive nature, annotations cover safety (destructiveHint=true), and the description adds scope. However, with no output schema, it lacks details on return values or confirmation messages, leaving a minor gap in completeness for such a high-impact 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?

With 0 parameters and 100% schema description coverage, the baseline is 4. The description confirms no inputs are needed by specifying the action applies to 'all timeline items', adding clarity beyond the empty schema.

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

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

The description clearly states the verb ('Clear'/'delete') and resource ('design'/'timeline items'), specifying the scope as 'all timeline items'. It distinguishes from siblings like 'delete_parameter' by targeting the entire design rather than a specific parameter.

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

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

The description implies usage when clearing all timeline items is needed, but does not explicitly state when to use this tool versus alternatives (e.g., 'delete_parameter' for specific deletions) or provide exclusions. It offers basic context without detailed 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds non-obvious context: the destructive operation spans root and all components, and it explains why undo is not a substitute. It stops short of stating irreversibility or what happens on a name miss, but the annotation carries the core safety signal.

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, zero waste. The scope constraint is front-loaded before the alternative-tool guidance, which is the right order for an agent deciding whether to call it.

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 mutation tool with no output schema, the description plus annotations cover what is needed. It does not address behavior when the named body is absent or ambiguous across components, a minor gap given the 'searches root and all components' wording.

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

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

Only one parameter (body_name) and schema coverage is 100%, so the schema already documents it. The description's 'one named body' reinforces the parameter's intent, and 'searches root and all components' hints at semantics, but no additional syntax or formatting guidance is provided beyond the 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?

States a specific verb (delete) and resource (one named body) and clarifies scope: it searches the root and all components. This distinguishes it clearly from the sibling delete_all, which removes everything.

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

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

Explicitly names the alternative (undo) and gives the condition that selects this tool over it: API-created features are not reliably on Fusion's UI undo stack. This is a concrete when/when-not rule.

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

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

Annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=false, covering key behavioral traits. The description adds minimal context beyond this, as 'Remove' aligns with destructive but doesn't elaborate on effects (e.g., irreversible deletion, impact on dependent features) or permissions needed. No contradiction with annotations exists.

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

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

The description is a single, direct sentence with zero wasted words, making it highly efficient and front-loaded. Every word contributes to understanding the tool's purpose without unnecessary elaboration.

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 destructive nature (per annotations) and lack of output schema, the description is minimally complete but lacks depth. It doesn't explain what happens post-deletion (e.g., error if parameter doesn't exist, return value) or dependencies, though annotations cover safety aspects. For a simple deletion tool, this is adequate but not comprehensive.

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

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

Schema description coverage is 100% with one parameter ('name') clearly documented. The description doesn't add any meaning beyond the schema, such as format examples or constraints (e.g., case sensitivity). With high schema coverage, a baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description 'Remove a user parameter' clearly states the action (remove) and resource (user parameter), making the tool's purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'delete_all' (which might delete all parameters) or 'set_parameter' (which modifies rather than removes), missing full sibling 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., parameter must exist), exclusions (e.g., cannot delete system parameters), or compare to siblings like 'delete_all' or 'set_parameter', leaving usage context unclear.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the safety profile is covered. The description adds a useful unit convention (cm and degrees by default), but says nothing about reversibility, permission/body-state requirements, or whether the operation can fail on degenerate faces.

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 tight sentences, with the core action front-loaded ahead of the unit caveat. No filler, though the trailing unit sentence could have been folded into the schema descriptions for the affected parameters.

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

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

For a 5-parameter, no-output-schema mutation tool with annotations covering the safety profile, the description is adequate but thinnest where it matters: it does not clarify how face_selection interacts with pull_direction_plane or how tangent chains are treated, leaving an agent to infer the geometry behavior.

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

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

Schema coverage is 80%, with enum values and defaults already documented for face_selection, pull_direction_plane, and is_tangent_chain. The description adds a global unit convention for lengths and angles, but the caveat 'unless a parameter says otherwise' is vague and no parameter is named, so it adds little 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?

States a specific verb (add) and resource (draft angle to faces of a body) and gives the engineering rationale (mold release / injection molding). It is clearly distinguishable from nearby face-modifying siblings like offset_faces or split_face, 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?

The description explains why one would draft (mold release), but never states when to use this tool versus sibling alternatives such as offset_faces or shell, nor any prerequisites (e.g., body must exist, direction of pull drives face selection). No exclusions or context triggers 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation profile is known. The description adds useful unit context (cm, degrees) and sketch scope, but does not disclose whether an active sketch is required, what happens if none exists, or other behavioral constraints.

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

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

Two efficient sentences with no wasted text. The core action and scope are front-loaded, and the unit caveat follows immediately.

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

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

For a mutation tool with no output schema and low parameter coverage, the description covers the basic action, sketch target, and units. However, it omits prerequisites such as requiring an active sketch and does not clarify the working plane or coordinate system, leaving notable gaps for correct invocation.

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

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

Schema description coverage is only 14%, so the description must compensate. It adds critical unit semantics for lengths and angles, but does not explain coordinate order, z-coordinate defaults, or the meaning of optional center_z/start_z beyond what parameter names imply.

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: 'Draw an arc in the most recent sketch.' It also names the geometric definition (center + start point + sweep angle), which distinguishes it from sibling draw_* tools like draw_circle and draw_line.

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

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

The description gives no explicit when-to-use, when-not-to-use, or alternatives guidance. It implies an active sketch is needed by saying 'in the most recent sketch,' but it does not state that prerequisite or route the agent to sibling tools.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the agent knows this is a non-destructive, non-idempotent mutation. The description usefully adds the unit convention (cm not mm, degrees), which is behaviorally relevant, but says nothing about what happens with no sketch present or how the new geometry affects downstream features.

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

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

A single tight sentence with the action front-loaded and the unit caveat attached; nothing is wasted and no filler is 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?

With no output schema and no annotations covering return values, the description covers the essential unit semantics but omits error/failure behavior (e.g., no active sketch) and any note on whether defaults place the circle at the sketch origin. Adequate but with clear gaps for a state-mutating tool.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It clarifies the unit system for lengths and coordinates (cm) and angles (degrees), which is genuinely useful, but never explains that center_x/y/z define the circle center or that they default to 0; the reader must infer this from the parameter names.

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

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

States a specific verb and resource ('Draw a circle') and scopes the target ('in the most recent sketch'), which meaningfully narrows it among drawing siblings like draw_rectangle, draw_arc, and draw_line. It is clear but does not explicitly contrast with those siblings.

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

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

No indication of when to use this versus draw_arc, draw_rectangle, or create_polygon, nor any prerequisite such as requiring an existing/active sketch. The mention of 'most recent sketch' implies context but gives no explicit condition.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation profile is known. The description adds genuinely useful context not in structured fields: default units are cm (not mm) and angles are degrees. It does not, however, disclose failure modes (no sketch present) or which sketch is modified beyond 'most recent'.

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

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

Two short sentences, front-loaded with the action before the convention caveat. Efficient overall, though the mention of angles in degrees earns little since this tool exposes no angle parameters.

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

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

No output schema exists and annotations only cover the safety profile, so the description is the agent's main source of detail for a 6-parameter geometry mutation. It delivers the critical unit convention but leaves prerequisites (existing sketch) and the coordinate system unexplained, leaving gaps for a tool of this 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% across 6 parameters, so the description carries the full burden. It supplies the unit convention (cm) and mentions angles in degrees, but the actual parameters are all coordinates and there are no angle parameters, so that clause is largely irrelevant and the z-default behavior and coordinate origin remain unexplained.

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

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

States a specific verb and resource ('Draw a line') and scopes it to 'the most recent sketch', which distinguishes it from the rectangle/circle/arc/spline siblings without needing to open a schema. It stops short of explicitly contrasting with those siblings, so it is clear but not maximally differentiated.

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

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

No when-to-use or when-not-to-use guidance, and no alternative named (e.g., draw_spline for curves, draw_arc for arcs). The phrase 'in the most recent sketch' implies a sketch must already exist, but this prerequisite is only implicit rather than stated as a rule.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the mutation profile is covered. The description adds genuinely non-obvious unit conventions (cm not mm, degrees) but says nothing about failure when no sketch exists, what the call operates on, or whether the rectangle is added as a constrained entity.

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 tight sentences with zero filler, purpose front-loaded and the unit caveat placed second where it belongs. 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?

With no output schema and no meaningful annotations, the description must carry more weight than it does. It omits prerequisites, failure modes, and return behavior for a 5-parameter mutation tool, leaving real gaps an agent would hit at call time.

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% across 5 parameters, so the description must compensate and largely does not. It gives unit conventions but never explains what origin_x/y/z represent (corner vs. center) or clarifies width vs. height semantics, leaving the parameters effectively undocumented.

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

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

States a specific verb (draw) and resource (rectangle) plus the target context (the most recent sketch), which no sibling tool claims. It does not explicitly distinguish itself from draw_line/draw_circle, but the scope is unambiguous.

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

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

The phrase 'in the most recent sketch' implies the tool requires an existing sketch, which is useful context, but it never states this as a prerequisite or says when to prefer a rectangle over draw_line/create_box. Usage is inferable but not spelled out.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context beyond annotations: it specifies that the spline is drawn in the most recent sketch and that lengths/coordinates default to cm and angles to degrees, which is essential for correct invocation.

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, front-loaded with the primary action and context, followed by parameter guidance and then unit defaults. Every sentence adds necessary information with zero waste.

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 drawing tool with three parameters and no output schema, the description covers the essential context: action, target sketch, spline type semantics, and units. It does not state whether a sketch must already exist or what happens if none is active, but those gaps are minor given the tool's scope and the annotations.

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

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

Schema coverage is 67% (degree and points documented; spline_type enum lacks a description). The description compensates by explaining the meaning of the two spline_type enum values and by adding unit context (cm, degrees) for coordinate values, which the schema does not provide. The degree parameter is already covered, so this is not a full 5.

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

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

The description states a specific verb (draw) and resource (spline) plus the context (most recent sketch), making it immediately distinguishable from sibling drawing tools like draw_line or draw_arc. No ambiguity remains about what the tool 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?

The description gives clear guidance for choosing between the two spline_type values (fit_points vs control_points), but it does not explicitly say when to use draw_spline over alternatives such as draw_arc or create_polygon. Usage is only implied by the tool's name and the prerequisite of an active sketch.

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

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

Annotations only declare the safety profile (destructive, non-idempotent). The description goes well beyond that: it discloses the REPL return convention, the pre-injected names (app, ui, design, component, adsk, math, late_results), the 30 s default wait, and the non-obvious fact that a timed-out command still completes and its result is retrievable via late_results(). That timeout semantics detail is exactly the kind of behavior an agent cannot infer elsewhere.

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?

Dense but front-loaded: purpose, return convention, available names, timeout behavior, then units. Every sentence carries information, though the late_results clause is stated twice in slightly different terms.

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?

There is no output schema, but the description defines the return convention (last expression value, late_results) so the agent knows what it will get back. For an arbitrary-code tool with no annotations covering behavior, this covers the semantics an agent needs to call it safely and interpret results.

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 50% (timeout_s documented in schema, code not). The description compensates by explaining the timeout behavior, the 600 s ceiling in context, and adding unit conventions (cm, degrees) that govern the free-form code parameter. It does not describe any constraint on the code string itself.

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

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

States a specific verb and resource ('Run arbitrary Python in Fusion 360') and immediately narrows the semantics with 'REPL-style' return behavior. This clearly separates it from every sibling, all of which are narrow CAD operations.

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

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

It explains when to raise timeout_s ('a script that runs many features on a large timeline'), but never states when to prefer this escape hatch over the dedicated siblings like extrude or fillet, nor any when-not-to-use conditions. Usage is implied rather than guided.

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

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

Annotations declare non-read-only, non-idempotent, non-destructive, which aligns with an export operation. The description adds useful behavioral details: auto-detection of format from file extension, and the conditional requirement for body_name. This goes beyond annotations without contradicting them.

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 that front-load the main purpose and include all critical routing and requirement information. No fluff, 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 wrapper with 3 parameters and no output schema, the description covers the essential behavior: what it does, how it routes, and key constraints. It doesn't mention error handling or return values, but that's not required for a simple export tool. The default path is in the schema, so that's 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 coverage is 100%, so all parameters are already documented. The description adds value by clarifying the body_name condition ('F3D exports the whole design') and reiterating the auto-detection logic. It doesn't fully compensate for any gaps, but it enhances understanding beyond the schema.

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

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

The description clearly states it's a unified export wrapper that dispatches to specific export tools (export_stl, export_step, export_f3d) based on format or extension. It names the exact resources and behavior, distinguishing it from siblings. The verb 'dispatches' is specific and the scope is well-defined.

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

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

It explains the routing logic (format or extension) and explicitly states the requirement for body_name for STL/STEP and that F3D exports the whole design. This gives clear when-to-use context and parameter conditions. It doesn't explicitly contrast with the specific export tools, but the wrapper concept implies it can be used interchangeably, which is sufficient.

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

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

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation. The description adds that it exports to a specific file format (.f3d), which is useful context beyond annotations. However, it doesn't mention potential side effects like file system changes or authentication needs.

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 directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and format.

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 one parameter (fully documented in schema), no output schema, and annotations covering key behavioral hints, the description is minimally adequate. It explains what the tool does but lacks details on usage context or output behavior.

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

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

Schema description coverage is 100%, with the single parameter 'file_path' fully documented in the schema. The description doesn't add any additional parameter details beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the specific action ('Export') and the resource ('the design'), specifying the output format ('native Fusion 360 archive (.f3d)'). It distinguishes from sibling tools like 'export_step' and 'export_stl' by specifying the .f3d format.

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

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

No guidance on when to use this tool versus alternatives like 'export_step' or 'export_stl' is provided. The description states what it does but not when it's appropriate or what prerequisites might be needed.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the write/no-destroy profile is covered. The description usefully adds the prerequisite dependency on flat_pattern, but says nothing about file overwrite behavior, default output location, or what happens when the body has no flat pattern — notable gaps given idempotentHint=false.

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, resource and format, with the prerequisite appended in parentheses. Zero wasted words.

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

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

There is no output schema and no parameter documentation, leaving the agent without return values (e.g., resulting file path), path semantics, or error conditions. For a file-producing, non-idempotent tool with 0% schema coverage, the definition is too thin.

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

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

Schema description coverage is 0% for both parameters, so the description must carry parameter meaning. It only loosely implies body_name (a sheet metal body) and file_path (a DXF destination); it never states that body_name must be an existing sheet-metal body with a generated flat pattern, nor whether file_path is a full filename or a directory, or what the default is.

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), a specific resource (the flat pattern of a sheet metal body), and a concrete output format (DXF), plus the downstream intent (laser/plasma/waterjet cutting). This clearly separates it from the many sibling export_* tools (export_stl, export_step, export_f3d, export_view_sheet), which handle different artifacts.

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

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

Explicitly states the precondition 'run flat_pattern first', which is exactly the routing information an agent needs before calling. It does not name alternatives or state when NOT to use it (e.g., non-sheet-metal bodies), 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?

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, which the description aligns with by implying a file creation action. However, the description adds minimal behavioral context beyond this—it doesn't specify if the export overwrites existing files, requires specific permissions, or has rate limits, leaving gaps in understanding the tool's behavior.

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

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

The description is a single, clear sentence with no wasted words, making it easy to parse and understand quickly. It's front-loaded with the core action and resource, which is ideal for efficient comprehension.

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

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

Given the tool's moderate complexity (2 parameters, no output schema) and annotations covering basic safety, the description is minimally adequate. It states the purpose but lacks details on usage, behavioral nuances, or parameter specifics, making it incomplete for fully informed tool selection and invocation.

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

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

Schema description coverage is 50%, with 'file_path' documented but 'body_name' lacking a description. The tool description mentions 'a body or component' which clarifies the semantics of 'body_name' slightly, but it doesn't provide details on format, constraints, or examples. This adds some value but doesn't fully compensate for the schema's gaps.

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

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

The description clearly states the action ('Export') and the target resource ('a body or component as a STEP file'), making the purpose immediately understandable. It distinguishes itself from other export tools like 'export_f3d' and 'export_stl' by specifying the STEP format, though it doesn't explicitly contrast with those 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 provides no guidance on when to use this tool versus alternatives like 'export_f3d' or 'export_stl', nor does it mention prerequisites or context for exporting STEP files. It simply states what the tool does without indicating appropriate scenarios 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?

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description adds value by specifying the action (export to STL) and implying file creation. However, it does not disclose additional behavioral traits like error handling, file overwriting, or performance considerations, leaving gaps beyond the annotations.

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

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

The description is a single, direct sentence with no wasted words, clearly front-loaded with the core action. It efficiently conveys the essential information without unnecessary elaboration.

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

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

Given the tool's moderate complexity (export operation with 2 parameters), lack of output schema, and annotations covering basic safety, the description is minimally adequate. It states what the tool does but lacks details on output format, error cases, or integration with sibling tools, leaving room for improvement in 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 50%, with 'file_path' documented but 'body_name' lacking a description. The description mentions 'a named body', which adds some context for 'body_name', but does not fully compensate for the missing schema details or explain parameter interactions, aligning with the baseline for partial 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 'Export' and the resource 'a named body as an STL file', making the purpose specific and understandable. However, it does not explicitly differentiate from sibling export tools like 'export_f3d' or 'export_step', which would require mentioning format distinctions or use cases.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'export_f3d' or 'export_step', nor does it mention prerequisites like needing an existing body. It lacks explicit context for selection among export or other sibling tools.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the write nature is partly covered there. The description adds genuinely new context beyond annotations: the artifacts produced (PNGs + self-contained HTML), that it opens in any browser, and the notable side effect that it 'Restores the viewport camera after rendering' — an important state-restoration 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?

Three tight sentences with the core output front-loaded, followed by consumption instructions and the side-effect note. No filler, and the most decision-relevant information (what is produced and how it is shared) comes first.

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