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 indicate this is a non-read-only, non-idempotent, non-destructive operation. The description adds useful context about units (cm for distances, degrees for angles) which isn't in the annotations. However, it doesn't disclose other behavioral traits like whether dimensions are editable after creation, if they affect sketch regeneration, or error conditions. With annotations covering basic safety, this adds some value but not rich behavioral context.

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

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

The description is perfectly concise with two clear sentences. The first states the core purpose, the second provides crucial unit information. Every word earns its place with zero wasted text, 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?

For a tool with 5 parameters, 80% schema coverage, and no output schema, the description provides adequate but incomplete context. It covers the purpose and units well, but doesn't explain the tool's role in the sketching workflow, how dimensions interact with constraints, or what happens after dimension addition. Given the complexity and lack of output schema, more context would be beneficial.

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%, so the schema already documents most parameters well. The description adds unit information (cm/degrees) for the 'value' parameter, which provides helpful semantic context beyond the schema's numeric type. However, it doesn't explain the relationship between 'dimension_type' choices and other parameters (e.g., when 'entity_two' is required), leaving some gaps.

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

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

The description clearly states the tool's purpose: 'Add a driving dimension to constrain sketch geometry.' It specifies the action (add), resource (driving dimension), and context (sketch geometry). However, it doesn't explicitly differentiate from sibling tools like 'add_constraint' or 'create_sketch', which would be needed for a perfect score.

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 when to choose this over 'add_constraint' or how it relates to 'create_sketch' or other geometry tools. Without any usage context or exclusions, this is minimal 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 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 indicate this is a non-readOnly, non-idempotent, non-destructive operation, but the description adds minimal behavioral context. It implies mutation ('combine') without detailing effects like whether the original bodies are modified or new ones created, or any rate limits. With annotations covering basic safety, the description adds some value but lacks depth on behavioral traits.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action ('combine') and includes essential details (resources and operations). Every word earns its place, 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 complexity of a boolean operation tool with 3 parameters (2 required), 0% schema coverage, no output schema, and annotations that only cover basic hints, the description is inadequate. It fails to explain parameter meanings, expected outcomes, or usage context, leaving significant gaps for an AI agent to understand and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it only vaguely references parameters ('two named bodies', 'join/cut/intersect'). It doesn't explain what 'target_body' and 'tool_body' represent, their formats, or the semantics of the operations beyond the enum values. This leaves key parameter meanings undocumented.

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

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

The description clearly states the verb ('combine') and the resources ('two named bodies'), specifying the operations (join/cut/intersect). It distinguishes from siblings like 'split_body' or 'stitch_surfaces' by focusing on boolean operations between bodies. However, it doesn't explicitly differentiate from all siblings, such as 'extrude' or 'loft', which might also combine geometry in different ways.

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 lacks context on prerequisites (e.g., existing bodies), exclusions (e.g., when to use 'split_body' instead), or comparisons to siblings like 'stitch_surfaces'. This leaves the agent without clear usage direction.

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 mutable, non-idempotent, non-destructive operation, which the description aligns with by implying creation ('Add'). However, the description adds minimal behavioral context beyond annotations—it mentions 'Strategy determines the toolpath type' but doesn't cover error conditions, permissions, or side effects, leaving gaps in transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It avoids redundancy and wastes no words, though it could be slightly more informative without losing conciseness.

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

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

Given the tool's complexity (10 parameters, no output schema) and moderate annotation coverage, the description is adequate but incomplete. It covers the basic purpose but lacks details on usage context, behavioral nuances, or output expectations, which are needed for a mutation tool with many parameters.

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 90% schema description coverage, the input schema already documents most parameters well. The description adds some value by explaining that 'Strategy determines the toolpath type', which clarifies the 'strategy' parameter's role, but it doesn't provide additional semantics for other parameters beyond what's 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?

The description clearly states the action ('Add a machining operation to a setup') and resource ('machining operation'), distinguishing it from sibling tools like 'cam_create_setup' or 'cam_list_operations'. However, it doesn't explicitly differentiate from other CAM-related tools beyond the strategy mention, which is why it's not a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'cam_generate_toolpath' or 'cam_post_process', nor does it mention prerequisites like needing an existing setup. It only states what the tool does, not when to apply it.

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

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

Annotations indicate this is a non-readonly, non-idempotent, non-destructive operation. The description adds that it 'defines' setup components, which aligns with annotations. However, it doesn't provide additional behavioral context like whether this creates persistent configurations, requires specific permissions, or has side effects beyond what annotations cover.

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 immediately states the tool's purpose without unnecessary words. It's appropriately sized for a creation tool with 7 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 creation tool with 7 parameters, no output schema, and moderate schema coverage (71%), the description adequately covers the basic purpose but lacks information about return values, error conditions, or relationships to other CAM operations. The annotations help but don't fully compensate for missing output documentation.

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 71% schema description coverage, the baseline is 3. The description mentions 'stock, coordinate system, and operation type' which maps to parameters like stock_mode and operation_type, but doesn't add meaningful semantic context beyond what the schema already documents about these parameters.

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

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

The description clearly states the verb 'Create' and resource 'manufacturing setup for a body', specifying it defines stock, coordinate system, and operation type. It distinguishes from siblings like 'cam_create_operation' by focusing on setup creation rather than operation creation, but doesn't explicitly contrast with other setup-related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'cam_list_setups' or 'cam_create_operation'. It mentions what the tool does but gives no context about prerequisites, timing, or when other tools might be more appropriate.

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

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

Annotations indicate this is not read-only, idempotent, or destructive, but the description adds minimal behavioral context. It implies a generation process but doesn't detail effects (e.g., whether toolpaths are saved, visible in the UI, or trigger simulations). No contradiction with annotations exists, but the description could better explain the tool's impact beyond the basic hints.

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 without unnecessary details. It uses clear language and avoids redundancy, making it easy to parse while conveying essential scope information.

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

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

Given the lack of output schema and annotations that only cover basic hints, the description is somewhat incomplete. It doesn't explain what the tool returns (e.g., success status, generated paths) or address potential complexities like error handling for invalid inputs. However, it adequately covers the tool's intent within the context of 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 description coverage is 100%, so parameters are well-documented in the schema. The description mentions 'specific operation or all operations,' which aligns with the parameters but doesn't add significant semantic value beyond what the schema provides (e.g., clarifying interactions between 'setup_name', 'operation_name', and 'generate_all').

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 ('Generate toolpaths') and specifies the scope ('for a specific operation or all operations in a setup'), which distinguishes it from general CAM tools. However, it doesn't explicitly differentiate from sibling tools like 'cam_post_process' or 'cam_get_operation_info', which might involve related CAM workflows.

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., requiring an existing setup or operation), exclusions, or comparisons to siblings like 'cam_post_process' for post-processing or 'cam_list_operations' for listing operations without generation.

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 indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description adds value by clarifying it's a transformation step (toolpaths to G-code). However, it doesn't disclose key behavioral traits like whether it overwrites files, requires specific permissions, or has rate limits. With annotations covering basic safety, the description provides some context but lacks depth on operational 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, efficient sentence that front-loads the core purpose with zero waste. Every word earns its place by clearly stating the tool's function and output, making it easy for an agent 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 complexity (transforming toolpaths to machine code) and lack of output schema, the description is minimally adequate. It states what the tool does but doesn't cover output details (e.g., file format, error handling) or integration with siblings. With annotations providing basic hints and schema covering most parameters, it's functional but leaves gaps for a tool in a CAM 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 80%, so the schema already documents most parameters well. The description doesn't add meaning beyond the schema—it doesn't explain parameter interactions (e.g., how 'operation_name' affects output) or provide examples. This meets the baseline for high schema coverage but doesn't compensate for the 20% gap or enhance 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 tool's purpose: 'Post-process toolpaths to generate NC code (G-code)'. It specifies the verb ('post-process') and resource ('toolpaths'), and the output ('NC code/G-code'). However, it doesn't explicitly differentiate from sibling tools like 'cam_generate_toolpath' or 'execute_code', which might handle related but different steps in the CAM workflow.

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 generated toolpath first), exclusions, or how it fits into the workflow with siblings like 'cam_generate_toolpath' or 'execute_code'. This leaves the agent to infer usage from context 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 indicate this is a mutable (readOnlyHint: false), non-idempotent, non-destructive operation. The description adds that it modifies edges of a body, which aligns with annotations but doesn't provide additional behavioral context like whether it creates a new feature, affects model history, or has side effects. 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 extremely concise—just four words—and front-loaded with the core action. There's no wasted language, making it easy to parse quickly, though this brevity contributes to gaps in other dimensions.

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 CAD modeling tool with four parameters, no output schema, and annotations covering only basic hints, the description is insufficient. It doesn't explain the operation's effect on the model, parameter roles, or expected outcomes, leaving too much for the agent to infer from the schema and context alone.

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

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

With 0% schema description coverage, the description provides no parameter information beyond what's implied by the tool name. It doesn't explain what 'distance', 'body_name', 'body_index', or 'edge_selection' mean, their units, or how they affect the chamfer operation. This leaves significant gaps in understanding the four 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 'Chamfer edges of a body' clearly states the verb ('chamfer') and resource ('edges of a body'), making the purpose understandable. However, it doesn't differentiate this tool from similar siblings like 'fillet' (which also modifies edges) or 'bevel' operations, leaving some ambiguity about when to choose chamfering over other edge treatments.

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 an existing body), when chamfering is appropriate versus filletting, or any context-specific considerations. The user must infer usage from the tool name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, repeatable read operation. The description adds the specific behavioral context of detecting collisions/interference, which is valuable beyond the annotations. However, it doesn't describe what constitutes a 'collision' in detail, how results are returned, or any performance considerations.

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

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

The description is extremely concise - a single sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded with the core functionality and contains zero wasted language. This is an excellent example of efficient documentation.

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 (collision detection with 2 parameters), good annotations, and 100% schema coverage, the description is adequate but has clear gaps. The lack of output schema means the description should ideally explain what the tool returns (e.g., boolean result, collision details, interference volume), but it doesn't. For a read-only analysis tool, this represents a significant omission 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 100%, with both parameters well-documented in the schema itself. The description doesn't add any additional parameter semantics beyond what's already in the schema descriptions. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even without parameter information in the description.

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

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

The description clearly states the tool's purpose with a specific verb ('Detect') and resource ('collisions between components/bodies'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'measure_distance' or 'get_physical_properties' that might involve spatial analysis, leaving room for potential confusion about when to choose this specific collision detection tool.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for measurement, analysis, and geometry operations, there's no indication of prerequisites, typical use cases, or comparisons to tools like 'measure_distance' for proximity checks or 'get_physical_properties' for spatial properties. This leaves the agent without context for tool selection.

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

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

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description adds no behavioral context beyond that. It doesn't explain what 'pattern' entails (e.g., creating copies, modifying geometry), potential side effects, or performance considerations. With annotations covering basic safety, the description adds minimal value, scoring a baseline 3.

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 ('pattern a body'). It avoids unnecessary words, but could be more specific (e.g., 'Create copies of a body arranged in a circle around an axis') to improve clarity without losing conciseness.

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

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

For a tool with 4 parameters, low schema coverage (25%), no output schema, and no annotations explaining behavior, the description is incomplete. It lacks details on what the tool returns, how it interacts with geometry, or error conditions, making it inadequate for an agent to use effectively without additional 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 low at 25%, with only 'total_angle' having a description. The description adds no parameter semantics beyond the schema, failing to explain 'body_name' (what body to pattern), 'count' (number of copies), or 'axis' (rotation axis). Given the coverage gap, the description doesn't compensate, resulting in a baseline 3 due to inadequate parameter clarification.

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

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

The description states the action ('pattern a body') and resource ('around an axis'), which clarifies the basic purpose. However, it's vague about what 'pattern' means (creating copies in a circular arrangement) and doesn't distinguish from sibling tools like 'rectangular_pattern' or 'mirror', which also create patterns but with different geometries.

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

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

No explicit guidance is provided on when to use this tool versus alternatives like 'rectangular_pattern' or 'mirror'. The description implies usage for circular arrangements but doesn't mention prerequisites (e.g., needing an existing body) or exclusions, leaving the agent to infer context from the tool name alone.

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

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

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 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 a geometric modification but doesn't specify effects like permanent model changes, error conditions, or typical use cases in CAD workflows.

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. It's front-loaded with the core action and resource, making it easy to parse quickly 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?

For a CAD modeling tool with 4 parameters, no output schema, and annotations covering basic safety, the description is minimally adequate. It states what the tool does but lacks details on typical outcomes, error handling, or integration with sibling tools, leaving gaps in contextual understanding.

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

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

Schema description coverage is 75% (3 of 4 parameters have descriptions), providing good baseline documentation. The description doesn't add meaningful parameter semantics beyond what the schema already covers (e.g., it doesn't explain relationships between parameters like bend_line_sketch and angle).

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 bend') and the target resource ('to a sheet metal body'), making the purpose immediately understandable. However, it doesn't differentiate this tool from similar sibling tools like 'create_flange' or 'fold/unfold' operations, which might also manipulate sheet metal geometry.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_flange' or 'fold' operations. The description lacks context about prerequisites (e.g., needing a sheet metal body and bend line sketch) or when this operation is appropriate in a design 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 indicate this is a non-readOnly, non-idempotent, non-destructive operation. The description adds that it creates 'non-parametric' geometry via 'TemporaryBRepManager', which provides useful context about the creation method and persistence characteristics. However, it doesn't explain what 'TemporaryBRepManager' means in practice or how the created box interacts with the modeling environment.

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. There's no wasted verbiage, though it could potentially benefit from slightly more detail given the complete lack of parameter documentation in the schema.

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

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

For a 6-parameter creation tool with no output schema and 0% schema description coverage, the description is inadequate. It doesn't explain what the tool returns, how the created box integrates into the scene, what coordinate system is used, or provide any examples of typical usage patterns.

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

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

With 0% schema description coverage for all 6 parameters, the description provides no information about what length, width, height, or center coordinates mean. It doesn't specify units, coordinate system, orientation, or how these parameters relate to the resulting box geometry. The description fails to compensate for the complete lack of schema documentation.

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

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

The description clearly states the verb ('Create') and resource ('box primitive'), and specifies it's 'non-parametric via TemporaryBRepManager' which distinguishes it from parametric modeling approaches. However, it doesn't explicitly differentiate from sibling tools like 'create_component' or 'create_cylinder' that also create geometry.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for creating geometry (create_cylinder, create_sphere, create_torus, etc.), there's no indication of when a box primitive is appropriate versus other primitives or modeling methods.

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

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

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 indicate this is a non-read-only, non-idempotent, non-destructive operation (readOnlyHint: false, idempotentHint: false, destructiveHint: false). The description doesn't contradict these annotations, but it also adds no behavioral context beyond the basic 'create' action. No information about side effects, error conditions, or system behavior is provided, though annotations cover the safety profile adequately.

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

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

The description is extremely concise with just three words. While it's under-specified for the tool's complexity, it's not verbose or poorly structured. Every word serves a purpose, and there's no wasted text, earning full marks for conciseness.

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

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

Given the tool's complexity (7 parameters with conditional dependencies based on 'method'), lack of output schema, and minimal annotations, the description is inadequate. It doesn't explain what a construction axis is, how it's used in CAD workflows, or provide any context about the multiple creation methods. For a tool with this parameter richness, more explanation is needed.

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

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

Schema description coverage is 57% (4 of 7 parameters have descriptions). The description adds no parameter information beyond what's in the schema. It doesn't explain the relationship between 'method' and other parameters (e.g., that 'point_one' and 'point_two' are required for 'two_points' method), nor does it clarify the purpose of construction axes. With incomplete schema coverage, the description fails to compensate.

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 'Create a construction axis' is a tautology that restates the name/title without adding specificity. It doesn't explain what a construction axis is, what it's used for, or how it differs from other construction tools like 'create_construction_plane' in the sibling list. The purpose is stated but lacks meaningful differentiation.

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. The description provides no context about appropriate scenarios, prerequisites, or how it relates to other tools in the extensive sibling list (e.g., when to create an axis versus a plane or sketch). This leaves the agent with no usage direction.

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-readOnly, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds minimal behavioral context by specifying the plane is 'for sketching', but doesn't explain what happens after creation (e.g., if it becomes active, how it interacts with other features, or any side effects). With annotations covering basic safety, this earns a baseline score for adding some purpose but lacking detailed 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. It's front-loaded with the core action and purpose, making it efficient and easy to parse, which is ideal for conciseness.

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

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

Given the tool's complexity (10 parameters, no output schema) and rich schema coverage, the description is minimal but not incomplete. It states what the tool does but lacks context on usage, output, or integration with other tools. With annotations providing safety hints, it's adequate but leaves gaps in guiding the agent 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 high at 90%, with most parameters well-documented in the schema itself (e.g., method enum values, plane references). The description adds no parameter-specific information beyond the general purpose, so it relies on the schema. This meets the baseline for high schema coverage without adding extra value.

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

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

The description clearly states the action ('Create') and resource ('construction plane') with the purpose 'for sketching', which distinguishes it from other creation tools like create_box or create_cylinder. However, it doesn't explicitly differentiate from create_sketch, which might be a related sibling tool for sketching purposes.

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, context (e.g., when sketching is needed), or how it relates to sibling tools like create_sketch or create_construction_axis, leaving the agent with no usage direction.

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 mutable, non-idempotent, non-destructive operation, which the description does not contradict. The description adds value by specifying 'non-parametric via TemporaryBRepManager', hinting at creation behavior without persistence or parametric features, but it doesn't detail effects like scene changes or error conditions.

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

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

The description is a single, efficient sentence that front-loads the core action. It avoids unnecessary words, though it could be more structured by separating purpose from technical notes.

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

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

For a creation tool with no output schema and low parameter documentation, the description is incomplete. It lacks details on return values, error handling, or how the cylinder integrates into the scene, making it inadequate for full contextual understanding.

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

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

With low schema description coverage (17%), the description does not compensate by explaining parameters. It mentions 'non-parametric' but doesn't clarify what parameters like 'radius', 'height', or 'axis' mean in context, leaving semantics largely undocumented beyond the minimal schema details.

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

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

The description clearly states the action ('Create a cylinder primitive') and specifies the resource ('cylinder'), but it does not explicitly differentiate from sibling tools like 'create_box' or 'create_sphere'. The mention of 'non-parametric via TemporaryBRepManager' adds technical context but doesn't clarify functional uniqueness among 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 guidance is provided on when to use this tool versus alternatives like 'create_box' or 'create_sphere', nor are there any prerequisites or exclusions mentioned. The description lacks context for tool selection among the many creation tools available.

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-readOnly, non-idempotent, non-destructive operation. The description adds that it creates a flange, implying a modeling operation that modifies geometry. However, it doesn't disclose additional behavioral traits like whether it requires specific permissions, how it handles errors, or what the expected output looks like (since no output schema 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 directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, 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?

For a creation tool with 5 parameters, no output schema, and annotations covering basic hints, the description is minimally complete. It specifies the action and target but lacks details on usage context, error handling, or output format, leaving gaps that could hinder effective 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 60% (3 of 5 parameters have descriptions). The description mentions 'on an edge', which hints at 'edge_index', but doesn't add meaning beyond the schema for parameters like 'body_name', 'height', 'angle', or 'bend_radius'. With moderate schema coverage, the baseline score of 3 is appropriate as the description provides minimal additional parameter context.

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

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

The description clearly states the specific action ('Create a sheet metal flange') and the target resource ('on an edge'), using precise terminology. It distinguishes this tool from siblings like 'create_bend' (which might create bends without specifying flange geometry) or 'extrude' (which creates features from sketches rather than edges).

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_bend' or 'extrude', nor does it mention prerequisites (e.g., needing an existing body with an edge). It simply states what the tool does without contextual usage information.

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 minimal behavioral context beyond the basic action. It does not explain potential side effects, such as how the hole interacts with the body or if it requires specific permissions. However, it does not contradict the annotations, so it meets a baseline level with some added value from the description.

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 that directly states the tool's purpose without unnecessary words. It is front-loaded and efficient, making it easy for an agent to quickly grasp the core functionality.

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

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

Given the complexity of a 7-parameter tool with no output schema and 0% schema coverage, the description is insufficient. It lacks details on parameter usage, expected outcomes, error conditions, or integration with sibling tools, making it incomplete for effective agent operation in this context.

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

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

With 0% schema description coverage, the description does not compensate by explaining any parameters. It mentions 'hole feature on a body face', which hints at 'body_name' and 'face_selection', but does not clarify parameter meanings like 'diameter', 'depth', or 'center_x/y'. This leaves significant gaps in understanding how to use the tool effectively.

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 the resource ('a hole feature on a body face'), which is specific and understandable. However, it does not explicitly differentiate from sibling tools like 'create_cylinder' or 'create_sphere', which might also create features on bodies, leaving some ambiguity about when to choose this tool over others for similar purposes.

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 other creation tools like 'create_cylinder' or 'create_thread'. It lacks context about prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage based on the tool name and parameters 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 indicate this is a non-read-only, non-idempotent, non-destructive operation (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description adds minimal behavioral context beyond this—it doesn't specify what happens on duplicate names, whether creation is immediate, or any permission requirements. It doesn't contradict annotations, but provides little extra value given their coverage.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without redundancy.

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

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

Given the lack of an output schema and the tool's mutation nature (creating a parameter), the description is somewhat incomplete. It doesn't hint at what the tool returns (e.g., success confirmation, the created parameter object, or an error). However, annotations cover safety aspects, and the schema is well-documented, making it minimally adequate but with room for improvement in output expectations.

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 documentation for all four parameters (name, value, unit, comment). The description adds no additional parameter semantics beyond what's in the schema, such as format constraints or examples beyond the unit field's schema description. This meets the baseline for 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 ('Create') and resource ('new user parameter'), making the purpose immediately understandable. However, it doesn't differentiate this from sibling tools like 'set_parameter' or 'get_parameters', which would require explicit comparison to achieve a perfect score.

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 'set_parameter' (which might update existing parameters) or 'get_parameters' (which retrieves them). There's no mention of prerequisites, context, or exclusion criteria, leaving the agent with insufficient usage direction.

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-readOnly, non-idempotent, non-destructive operation, which the description aligns with by implying creation ('Draw'). However, the description adds minimal behavioral context beyond annotations—it doesn't specify if it modifies existing geometry, requires specific sketch states, or has side effects like auto-constraints.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core action ('Draw a regular polygon') and adds necessary context ('in the most recent sketch'), 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 complexity (5 parameters, creation operation), lack of output schema, and low schema coverage, the description is incomplete. It doesn't cover parameter meanings, behavioral nuances, or usage context, leaving gaps for an AI agent to infer correctly.

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

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

Schema description coverage is low (20%), with only 'radius' having a description ('Circumradius (cm)'). The description adds no parameter semantics, failing to explain 'sides' (number of polygon edges), 'center_x/y/z' (3D coordinates), or how they interact. For 5 parameters with poor schema coverage, this is inadequate.

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 ('Draw') and resource ('a regular polygon'), specifying it occurs 'in the most recent sketch'. It distinguishes from siblings like 'draw_circle' or 'draw_rectangle' by focusing on polygons, but doesn't explicitly differentiate from other polygon-related tools (none in the list).

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 is provided. The description mentions 'most recent sketch', implying a sketch must exist, but doesn't state prerequisites or compare to other drawing tools like 'draw_circle' or 'draw_rectangle' for shape selection.

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

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

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 indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description adds minimal behavioral context beyond the action. It implies a creation or analysis outcome but does not detail effects like visual changes, data generation, or interaction with the model. No contradiction with annotations exists, but the description offers limited value beyond 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?

The description is a single, front-loaded sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized for a simple tool, making it efficient and easy to parse for an AI agent.

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

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

Given the tool's moderate complexity (2 parameters, no output schema), the description is minimally adequate but lacks depth. It covers the basic action but omits details on output format, side effects, or integration with sibling tools. With annotations providing safety hints, the description is complete enough for basic use but could be more informative.

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% (only 'offset' has a description), and the description does not add meaning for parameters beyond the schema. It mentions 'plane' and 'offset' implicitly but provides no extra details on usage, constraints, or effects. With moderate schema coverage, the baseline score of 3 is appropriate as the description does not compensate for 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 ('cut a section plane') and the target ('through the model'), which is specific and distinguishes it from sibling tools like 'create_construction_plane' or 'get_object_info'. However, it does not explicitly differentiate from all siblings (e.g., 'split_body' or 'trim_surface' could involve cutting), so it falls short of a perfect score.

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 'create_construction_plane' for reference geometry or 'get_scene_info' for analysis. It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

Annotations indicate this is a non-readOnly, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds minimal behavioral context by mentioning the plane options and offset capability, but doesn't disclose important details like whether sketches are persistent, if they can be edited later, or what happens on failure. With annotations covering basic safety, this earns a baseline score.

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

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

The description is extremely concise—a single sentence that's front-loaded with the core action. Every word earns its place without redundancy, making it easy to parse quickly. No unnecessary details or verbose explanations are included.

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

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

Given the tool has no output schema and annotations cover basic safety, the description is minimally complete. It identifies the action and parameters but lacks depth on usage context, return values, or error handling. For a creation tool with 2 parameters, this is adequate but leaves gaps in practical 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 50% (only 'z_offset' has a description). The description mentions 'plane' and 'offset' but doesn't add meaningful semantics beyond what the schema provides—it doesn't explain what the planes represent, default behaviors, or offset implications. With partial schema coverage, the description doesn't adequately compensate, warranting a baseline score.

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 ('Create') and resource ('new sketch'), specifying it occurs on specific planes (xy/yz/xz). However, it doesn't differentiate from sibling tools like 'draw_rectangle' or 'draw_circle' that might also create sketches, leaving some ambiguity about when to use this versus other drawing tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'optionally offset' but doesn't explain scenarios where offsetting is beneficial or when other tools like 'create_construction_plane' might be more appropriate. No explicit when/when-not instructions 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 indicate this is a mutable operation (readOnlyHint: false) that's neither idempotent nor destructive. The description adds some context about being 'non-parametric via TemporaryBRepManager', which suggests a specific creation method, but doesn't elaborate on what this means behaviorally (e.g., whether the sphere can be edited later, if it's temporary, or how it integrates with the CAD environment).

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. It could potentially benefit from slightly more context about the sphere's characteristics or usage, but it doesn't waste words and communicates the core purpose effectively.

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

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

For a creation tool with no output schema and minimal annotations beyond basic mutability hints, the description provides the essential 'what' but lacks important context. It doesn't explain what happens after creation (e.g., where the sphere appears, whether it's selectable/editable, or what the return value might be). The 'non-parametric via TemporaryBRepManager' hint suggests technical specifics but doesn't make them actionable for an AI agent.

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

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

With 0% schema description coverage, the schema provides only basic type constraints. The description doesn't add any parameter information beyond what's implied by the tool name. It doesn't explain what 'radius' represents, what units are used, or what the center coordinates mean in the 3D space. However, the parameter names are self-explanatory (radius, center_x/y/z), providing some inherent clarity.

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 ('Create') and resource ('sphere primitive'), specifying it's non-parametric via TemporaryBRepManager. However, it doesn't explicitly differentiate from sibling tools like 'create_box' or 'create_cylinder' beyond the sphere shape, leaving some ambiguity about when to choose this specific primitive creation tool.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_box' or 'create_cylinder'. The description mentions 'non-parametric via TemporaryBRepManager', but doesn't explain what this means in practical usage or when this approach is preferred over parametric alternatives.

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

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

Annotations already declare this is a write operation (readOnlyHint=false), non-idempotent, and non-destructive. The description adds useful context about the two thread types (cosmetic vs modeled) which isn't captured in annotations, but doesn't provide additional behavioral details like permission requirements, side effects, or what happens if applied to non-cylindrical 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?

The description is a single, efficient sentence that communicates the essential purpose without unnecessary words. It's front-loaded with the core action and immediately qualifies the thread types, making it easy for an agent 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?

For a 9-parameter CAD modeling tool with no output schema, the description is minimally adequate. It covers the basic purpose but lacks information about return values, error conditions, or practical usage context. The high schema coverage helps, but more guidance would be beneficial given the tool's complexity.

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

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

With 89% schema description coverage, most parameters are well-documented in the schema itself. The description adds minimal semantic context beyond what's in the schema - it mentions 'cylindrical face' which relates to face_index, and 'cosmetic or modeled' which relates to is_modeled, but doesn't provide additional interpretation or usage examples for the 9 parameters.

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

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

The description clearly states the specific action ('Add threads') and target resource ('to a cylindrical face'), with explicit qualification of thread types ('cosmetic or modeled'). It distinguishes from sibling tools like 'create_hole' or 'chamfer' by focusing specifically on thread creation functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or constraints. While it specifies the target must be a cylindrical face, it doesn't explain how this differs from other face modification tools or when threads are appropriate versus other features.

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 mutable (readOnlyHint: false), non-idempotent, non-destructive operation. The description adds that it creates a 'primitive' and uses 'TemporaryBRepManager', which suggests it might be a temporary or intermediate geometric representation, but doesn't clarify persistence, side effects, or error conditions. 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 that front-loads the core action ('Create a torus primitive') and adds technical context without redundancy. Every word serves a purpose, making it appropriately concise.

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

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

Given the complexity of a 3D modeling tool with 6 parameters, no output schema, and annotations covering basic safety, the description is minimal. It states what the tool does but lacks details on return values, error handling, or integration with sibling tools, leaving gaps for an AI agent to infer usage.

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

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

Schema description coverage is low (33%), with only 'major_radius' and 'minor_radius' described. The description adds no parameter details beyond what's in the schema, such as explaining 'axis' enum choices or default center values. With 6 parameters and poor schema coverage, the description fails to compensate adequately, resulting in a baseline score.

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 torus primitive') and specifies the method ('non-parametric via TemporaryBRepManager'), which distinguishes it from potential parametric creation methods. However, it doesn't explicitly differentiate from sibling tools like 'create_box' or 'create_sphere' beyond the geometric shape.

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 'create_sphere' or 'create_cylinder', nor does it mention prerequisites, context, or exclusions. It lacks any usage context or comparison 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 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 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 indicate this is a non-read-only, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds context about the purpose (mold release/injection molding) but doesn't disclose additional behavioral traits like whether the operation is reversible, has specific failure modes, or affects related geometry beyond the selected 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?

Single sentence that is front-loaded with the core action and purpose, with no wasted words. Efficiently conveys the tool's function in a compact form appropriate for its complexity.

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

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

For a geometric modeling tool with 5 parameters, no output schema, and annotations covering basic safety, the description is minimally adequate. It states the purpose but lacks details on geometric constraints, error conditions, or output expectations, 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?

With 80% schema description coverage, the schema already documents parameters well (e.g., 'angle' as draft angle in degrees, 'face_selection' options). The description adds no parameter-specific semantics beyond implying 'faces' are targeted, aligning with the baseline for high schema coverage without extra value.

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

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

The description clearly states the action ('Add a draft angle') and target resource ('faces of a body'), with specific context ('for mold release / injection molding'). It distinguishes from siblings like 'chamfer' or 'fillet' by focusing on draft/taper functionality, though it doesn't explicitly compare to similar tools like 'offset_faces'.

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 'offset_faces' or 'chamfer' for similar geometric modifications. The description mentions the application context (mold release/injection molding) but doesn't provide explicit usage scenarios, prerequisites, or exclusions.

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

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

Annotations indicate this is a non-readOnly, non-idempotent, non-destructive operation, which the description doesn't contradict. However, it adds little behavioral context beyond the basic action—no mention of effects on the sketch, error conditions, or visual feedback. With annotations covering safety, the description provides minimal additional value.

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 zero waste—every word contributes to defining the tool's purpose. It's appropriately sized for a straightforward geometric operation, avoiding redundancy or fluff.

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

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

Given the complexity (7 parameters, low schema coverage, no output schema) and annotations, the description is incomplete. It lacks details on parameter usage, expected outcomes, or integration with the sketching workflow. For a CAD tool with multiple numeric inputs, more context is needed to guide effective use.

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

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

Schema description coverage is low (14%), with only sweep_angle documented. The description mentions parameters generically ('center + start point + sweep angle') but adds no meaning beyond naming them—no units, coordinate system, or geometric relationships. It fails to compensate for the poor schema coverage, leaving most parameters unclear.

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 ('Draw an arc') and the resource ('in the most recent sketch'), with precise geometric parameters (center + start point + sweep angle). It distinguishes from sibling tools like draw_circle, draw_line, and draw_rectangle by specifying arc creation rather than other sketch primitives.

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 for arc drawing in sketches. It lacks explicit when-to-use criteria, prerequisites (e.g., requires an active sketch), or alternatives (e.g., using draw_spline for curves). No exclusions or comparisons to siblings are mentioned.

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

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

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds context about operating on 'the most recent sketch', which is useful behavioral information not covered by annotations. However, it lacks details on error conditions, visual feedback, or interaction with other sketch elements.

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 that efficiently communicates the core functionality without unnecessary words. It's appropriately sized for a simple drawing operation 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 geometry creation tool with 4 parameters, 0% schema description coverage, no output schema, and minimal annotations, the description is inadequate. It doesn't explain what happens after drawing (e.g., does it return an object ID?), coordinate systems, units, or how this interacts with other sketch operations. The context signals indicate significant gaps in documentation.

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

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

With 0% schema description coverage for 4 parameters, the description provides no parameter information beyond what's in the schema. It doesn't explain what 'radius', 'center_x', 'center_y', or 'center_z' mean in context, their units, or how they relate to the sketch coordinate system. The description fails to compensate for the schema's lack of descriptions.

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

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

The description clearly states the action ('Draw a circle') and specifies the context ('in the most recent sketch'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling drawing tools like 'draw_arc', 'draw_line', or 'draw_rectangle', which would require 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?

The description provides minimal guidance by specifying 'in the most recent sketch', but offers no explicit when-to-use rules, alternatives, or exclusions compared to other drawing or geometry creation tools. There's no mention of prerequisites like needing 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 indicate this is a non-readOnly, non-idempotent, non-destructive operation, which the description doesn't contradict. The description adds context about operating on 'the most recent sketch', which is useful behavioral information not covered by annotations. However, it lacks details on potential side effects, error conditions, or what happens if no sketch exists, leaving some gaps in behavioral understanding.

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

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

The description is extremely concise with a single sentence that states the core functionality without any wasted words. It's front-loaded with the essential action and context, making it efficient for quick understanding despite its limitations in other dimensions.

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

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

Given the complexity of a 6-parameter drawing operation with no output schema and 0% schema description coverage, the description is insufficiently complete. It lacks crucial information about parameter semantics, coordinate systems, units, error conditions, and what constitutes 'the most recent sketch'. For a tool that creates geometry in a 3D environment, this leaves significant gaps in understanding how to use it 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?

With 0% schema description coverage for all 6 parameters, the description carries full burden for explaining parameter meaning but provides no information about what start_x, start_y, start_z, end_x, end_y, or end_z represent. The description doesn't compensate for the complete lack of parameter documentation in the schema, leaving the agent guessing about coordinate systems, units, or interpretation of these values.

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

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

The description clearly states the action ('Draw a line') and specifies the target ('in the most recent sketch'), which provides a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'draw_arc', 'draw_circle', or 'draw_spline' that also draw in sketches, leaving some ambiguity about when to choose this specific drawing tool.

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

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

The description provides minimal guidance by specifying 'in the most recent sketch', which implies a prerequisite context but doesn't offer explicit when-to-use instructions or alternatives. There's no mention of when to use this versus other drawing tools (e.g., 'draw_arc' for curves) or how it relates to sibling tools like 'create_sketch', leaving the agent with little direction on tool selection.

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

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

Annotations already indicate this is a mutable operation (readOnlyHint: false) that's non-destructive and non-idempotent. The description adds minimal behavioral context beyond this - it specifies the sketch context ('most recent sketch') but doesn't describe what happens if no sketch exists, whether the rectangle becomes a sketch entity, or any other behavioral details. The description doesn't contradict 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, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized for a straightforward drawing operation 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 5-parameter drawing tool with no output schema and minimal annotations, the description is incomplete. It doesn't explain what the tool returns, how errors are handled, or provide usage examples. While the purpose is clear, the lack of parameter guidance and behavioral context leaves significant gaps for an AI agent trying to use this tool 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?

With 0% schema description coverage, the description carries full burden for parameter explanation but provides none. However, the parameter names (width, height, origin_x/y/z) are self-explanatory for rectangle drawing in a 3D context. The description implies these parameters define the rectangle's dimensions and position, though it doesn't explicitly explain their meaning or units.

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

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

The description clearly states the action ('Draw') and the resource ('a rectangle'), specifying it operates 'in the most recent sketch'. This distinguishes it from sibling tools like 'create_box' or 'create_polygon' by focusing on sketch-based rectangle drawing rather than 3D primitive creation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_box' or 'create_polygon'. It mentions 'most recent sketch' which implies a prerequisite sketch context, but doesn't explicitly state when this tool is appropriate or what alternatives exist for different scenarios.

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 (readOnlyHint=false, idempotentHint=false, destructiveHint=false), which the description doesn't contradict. The description adds useful context about operating 'in the most recent sketch,' implying it modifies the current sketch state, but doesn't detail side effects like sketch activation requirements or error conditions. With annotations covering basic safety, the description adds some value but lacks rich behavioral context.

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

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

The description is two sentences with zero waste: the first states the core action and target, and the second provides essential usage guidance for the key parameter. It's front-loaded with the main purpose and efficiently structured for quick 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 has 3 parameters with moderate schema coverage (67%), no output schema, and annotations covering basic operational hints, the description is reasonably complete. It clarifies the spline_type options and sketch context, but could improve by mentioning prerequisites (e.g., requires an active sketch) or output expectations. For a drawing tool with clear parameters, it's mostly adequate but has minor gaps.

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

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

Schema description coverage is 67% (2 of 3 parameters have descriptions), with the description adding meaning for spline_type by explaining the difference between fit_points and control_points. It doesn't elaborate on points or degree beyond what the schema provides (points as array of coordinates, degree as 3 or 5 for control_points), but the schema coverage is moderate, and the description compensates with clear spline_type guidance, earning a score above 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?

The description clearly states the action ('Draw a spline') and the target ('in the most recent sketch'), which is specific and unambiguous. It also distinguishes between two spline types (fit_points vs control_points), providing clear differentiation from other drawing tools like draw_line or draw_circle in the sibling list.

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

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

The description provides clear context for when to use each spline_type option ('Use fit_points for a curve through points, or control_points for a control-polygon spline'), which helps the agent choose between them. However, it doesn't explicitly state when to use this tool versus other curve-drawing alternatives like draw_arc or spline-related tools (none listed), nor does it mention prerequisites like needing 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 indicate non-read-only, non-idempotent, and non-destructive operations, but the description adds valuable context: it specifies that the tool runs arbitrary Python (implying potential side effects), returns the last expression's value (REPL-style), and lists pre-defined names (app, ui, design, etc.). This clarifies execution behavior beyond annotations, though it doesn't detail error handling or security constraints.

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

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

The description is front-loaded with the core purpose, followed by essential behavioral details in a single, efficient sentence. Every part adds value without redundancy, making it appropriately sized for the tool's complexity.

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

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

Given the tool's high complexity (arbitrary code execution), lack of output schema, and minimal annotations, the description is reasonably complete. It covers purpose, behavior, and parameter context, but could improve by mentioning error cases, execution limits, or safety warnings to fully guide an AI agent.

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

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

With 0% schema description coverage for the single parameter 'code', the description compensates by implicitly defining it as Python code to execute. It adds meaning by mentioning REPL-style return and pre-defined names, which help interpret the parameter's expected content. However, it doesn't specify syntax examples or constraints.

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 ('Run arbitrary Python in Fusion 360') and resource (Fusion 360 environment). It distinguishes itself from all sibling tools by being the only code execution tool, with siblings focused on CAD operations like modeling, constraints, and measurements.

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

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

The description implies usage for executing Python code within Fusion 360, particularly mentioning REPL-style behavior and pre-defined names. However, it doesn't explicitly state when to use this versus other tools (e.g., for automation vs. direct CAD operations) or provide exclusions, leaving some ambiguity.

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 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 indicate this is a non-readOnly, non-idempotent, non-destructive operation, which the description aligns with by implying mutation ('extend') without contradiction. However, it adds minimal behavioral context beyond annotations—no details on error conditions, rate limits, or what happens if no intersection exists—leaving gaps in understanding the tool's full 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 highly concise and front-loaded, using two clear sentences with zero wasted words. Every phrase ('extend a sketch curve', 'to the nearest intersection', 'The end nearest to the given point') directly contributes to understanding the tool's function efficiently.

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 (mutation without annotations covering all behaviors) and lack of output schema, the description is adequate but incomplete. It explains the core operation but omits details like return values, error handling, or interaction with other sketch tools, leaving the agent to infer some aspects from 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?

With 75% schema description coverage, the schema documents three parameters well, but 'sketch_name' lacks a description. The description adds value by explaining the purpose of 'point_x' and 'point_y' ('near the end to extend') and implying 'curve_index' selects the target, though it doesn't fully compensate for the missing 'sketch_name' documentation, keeping it from a perfect score.

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 ('extend'), target resource ('a sketch curve'), and precise behavior ('to the nearest intersection') with the end selection logic ('The end nearest to the given point is extended'). It distinguishes from siblings like 'trim_curve' or 'offset_curve' by focusing on extension rather than cutting or offsetting.

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 'trim_curve' or 'offset_curve', nor does it mention prerequisites such as needing an existing sketch or intersecting geometry. It lacks explicit context for tool selection among the many sibling CAD operations.

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

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

Annotations indicate the tool is not read-only, idempotent, or destructive, but the description adds minimal behavioral context. It does not explain what extrusion entails (e.g., creating new geometry, modifying existing bodies based on the 'operation' parameter), potential side effects, or performance considerations. While not contradicting annotations, the description fails to provide meaningful behavioral insights beyond the basic action.

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

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

The description is extremely concise—a single phrase—with no wasted words. It is front-loaded and efficiently states the core action, though this brevity contributes to gaps in other dimensions. Every word earns its place by directly addressing the tool's function.

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

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

Given the tool's complexity (4 parameters, including enums for 'operation' and 'direction'), lack of output schema, and minimal annotations, the description is incomplete. It does not cover parameter meanings, expected outcomes, or integration with sibling tools, leaving significant gaps for an agent to understand and use the tool effectively in a 3D modeling 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?

With 0% schema description coverage, the input schema lacks parameter explanations, and the description does not compensate by detailing any parameters. It mentions 'sketch profile' but does not clarify how parameters like 'height', 'profile_index', 'operation', or 'direction' affect the extrusion process. This leaves key semantics undocumented, failing to add value beyond the bare schema.

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

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

The description 'Extrude a sketch profile' clearly states the action (extrude) and target (sketch profile), providing a basic understanding of the tool's function. However, it lacks specificity about what extrusion does (e.g., creating 3D geometry from 2D profiles) and does not distinguish it from similar sibling tools like 'revolve', 'sweep', or 'loft', which also create 3D geometry from sketches. This makes the purpose somewhat vague in 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an existing sketch), compare it to sibling tools like 'revolve' or 'sweep' for different 3D modeling approaches, or specify scenarios where extrusion is preferred. This absence of usage context leaves the agent without direction on tool selection.

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

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

Annotations indicate this is a non-readOnly, non-idempotent, non-destructive operation, but the description adds minimal behavioral context. It implies a geometric modification ('round edges') without specifying permanence, side effects, or what happens to the original body. No contradiction with annotations exists, but the description doesn't enrich understanding beyond the basic action.

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

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

The description is extremely concise with just four words, front-loading the core action. There's no wasted language, though this brevity contributes to gaps in other dimensions. Every word earns its place in conveying the basic purpose.

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

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

For a 4-parameter tool with low schema coverage, no output schema, and annotations that only cover basic hints, the description is insufficient. It doesn't explain what 'round edges' means in practice, what the radius parameter does, how edge selection works, or what the tool returns. The context demands more detail for effective use.

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

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

With only 25% schema description coverage (only 'body_name' has a description), the description doesn't compensate for the undocumented parameters. It mentions 'edges' generally but doesn't explain the 'edge_selection' enum options or clarify the relationship between 'body_name' and 'body_index'. The description adds little semantic value beyond what's implied by the tool name.

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 ('round edges') and target ('of a body'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'chamfer' (which also modifies edges) or 'shell' (which might involve rounding), so it doesn't fully distinguish from alternatives.

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 like 'chamfer' or other edge-modification tools. The description only states what the tool does, not when it's appropriate or what prerequisites might be needed for successful operation.

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

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

Annotations indicate this is a non-read-only, non-idempotent, non-destructive operation, but the description does not add behavioral context beyond this. It mentions creating a flat pattern, which aligns with the annotations, but fails to disclose details like potential side effects, error conditions, or performance considerations, resulting in moderate transparency.

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

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

The description is a single, direct sentence that efficiently conveys the core action without unnecessary words. It is front-loaded and wastes no space, making it highly concise and well-structured for quick understanding.

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 (creating a flat pattern from sheet metal), lack of output schema, and minimal annotations, the description is somewhat incomplete. It does not explain the result format, potential errors, or dependencies, but it adequately states the basic purpose, meeting a minimum viable level for 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?

With 0% schema description coverage for the single parameter 'body_name', the description does not provide any additional semantic information about this parameter, such as what constitutes a valid body name or examples. However, since there is only one parameter, the baseline is set to 4, but the lack of compensation for the coverage gap reduces the score to 3.

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

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

The description clearly states the action ('create') and the resource ('flat pattern from a sheet metal body'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'unfold' or 'create_bend', which might have related sheet metal functions, leaving room for improvement in 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, such as 'unfold' or other sheet metal-related siblings. It lacks context on prerequisites, constraints, or specific scenarios for application, offering minimal usage direction.

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 minimal context beyond this, specifying it retrieves 'detailed info' but not elaborating on what that includes or any limitations. 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 that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, 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 simplicity (one parameter, read-only, idempotent) and lack of an output schema, the description is minimally adequate. It specifies the resource types ('body or sketch') but doesn't detail the return format or potential errors. For a basic info-retrieval tool with good annotations, it meets the minimum viable threshold.

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 'name' documented as 'Object name'. The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the 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 clearly states the verb ('Get detailed info') and resource ('about a named body or sketch'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_parameters', 'get_physical_properties', or 'get_scene_info', which also retrieve information but about different resources.

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, such as needing an existing object name, or compare it to siblings like 'get_physical_properties' for different types of object details. Usage is implied only by the tool name and description.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context beyond this, as it does not specify output format, pagination, or error handling. No contradiction with annotations is present.

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 that efficiently conveys the core purpose without any wasted words. It is front-loaded and appropriately sized for a simple tool.

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

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

Given the tool's low complexity (0 parameters, no output schema) and rich annotations, the description is minimally complete. However, it could benefit from more context, such as explaining the return format or linking to related tools, to better assist an agent in usage.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add parameter details, which is acceptable in this case, as the baseline for 0 parameters is 4, indicating adequate handling.

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 ('user parameters in the design'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get_object_info' or 'get_scene_info', which might also retrieve information, so it lacks 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 does not mention any context, prerequisites, or exclusions, such as when to prefer 'get_parameter' (if it existed) or other info-retrieval tools in the list.

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, so the agent knows it's safe. The description adds value by specifying the exact properties returned, but doesn't disclose behavioral traits like performance implications of the 'accuracy' parameter, potential errors for invalid bodies, or if it works on all body types.

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 key information (what properties are retrieved). There's no wasted text, 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?

For a read-only tool with annotations covering safety, the description adequately states what it returns. However, without an output schema, it doesn't detail the return format (e.g., units, structure), and the lack of parameter explanations leaves gaps in understanding how to use it 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?

With 0% schema description coverage, the description doesn't explain either parameter. It mentions 'body' but not the 'body_name' parameter specifically, and omits the 'accuracy' parameter entirely, failing to compensate for the schema's lack of descriptions.

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

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

The description clearly states the action ('Get') and the specific properties returned (mass, volume, surface area, center of mass, density) for a body, making the purpose explicit. However, it doesn't distinguish this tool from potential measurement-related siblings like 'measure_distance' or 'measure_angle', which slightly limits differentiation.

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. For example, it doesn't mention if this is for physical bodies only, how it relates to 'get_object_info' or 'measure_distance', or any prerequisites like needing a body to exist first.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior, so the description does not need to repeat these. However, it adds value by specifying the types of scene information retrieved (e.g., design name, camera info), which provides useful context beyond the annotations. No contradictions with annotations are present.

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 phrase that lists all retrieved information without any redundant words. It is front-loaded and every word contributes directly to understanding the tool's purpose, 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 has 0 parameters, rich annotations (read-only, idempotent, non-destructive), and no output schema, the description adequately covers what information is retrieved. However, it lacks details on the format or structure of the returned data, which could be helpful for an agent to interpret results, leaving room for improvement.

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 does not need to cover parameters, and it appropriately focuses on the output information, earning a baseline score of 4 for not introducing unnecessary parameter details.

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

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

The description clearly states the action ('Get') and the specific information retrieved ('design name, bodies, sketches, features, camera info'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'get_object_info' or 'get_parameters', which limits the score to 4 instead 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?

The description provides no guidance on when to use this tool versus alternatives such as 'get_object_info' or 'get_parameters', nor does it mention any prerequisites or context for usage. It merely lists what information is retrieved without indicating appropriate scenarios.

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 read-only, idempotent, and non-destructive behavior. The description adds minimal context by implying it lists 'all' components, but does not disclose details like pagination, sorting, or return format. It does not contradict annotations, so it earns a baseline score for adding some value beyond the structured data.

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. It is front-loaded with the core action and resource, making it easy to parse and understand 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 simplicity (0 parameters, annotations covering safety), the description is adequate but incomplete. It lacks output details (no schema provided) and does not specify scope or limitations, such as whether it returns a flat list or structured data, leaving gaps for the agent.

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