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

The description does not contradict annotations (readOnlyHint=true, etc.). It only restates the purpose without adding behavioral context beyond what annotations already provide. Baseline score is appropriate.

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

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

The description is a single sentence with an example, no wasted words, and purpose is front-loaded. 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 simplicity (1 parameter, no output schema, clear annotations), the description is complete enough. It explains the purpose and gives a useful example. Some may expect mention of return type, but not strictly necessary.

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 sole parameter 'name' has no schema description, but the description provides an example ('ExtrudeFeatures.createInput') which clarifies the expected format, adding significant value beyond the schema.

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

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

The description clearly states the verb 'Get' and the resource 'Autodesk cloudhelp URL for an API class or member', with a concrete example. It is distinct from siblings which are mostly CAD operations.

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

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

The description implies using this tool to retrieve help URLs for API classes or members, but does not provide explicit when-to-use, when-not-to-use, or alternatives. Suitable for implied 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 already declare readOnlyHint and destructiveHint; description adds that it inspects the live API and lists signatures, providing context beyond annotations. No contradictions.

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

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

Three sentences, front-loaded with main action, parameter explanations, and usage guidance. No wasted words.

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

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

While no output schema exists, the description explains what the tool lists (properties and method signatures). Slightly lacking on return format but adequate for a discovery tool.

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

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

Schema coverage is 0% with no descriptions, but the description provides detailed explanations for both parameters (target with examples, query with filtering), fully compensating for missing schema descriptions.

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

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

The description clearly states the tool inspects the live Fusion API to list properties and method signatures, with specific verb-resource pairing. It distinguishes from sibling fusion_api_docs by mentioning live inspection and direct usage to drive fusion_api_call.

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

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

Explicitly advises using this tool to discover the exact API for fusion_api_call, providing clear context for when to use. Does not explicitly state when not to use or mention alternatives, but context is sufficient.

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

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

Annotations indicate mutation and non-destructive behavior. Description adds the key trait of keeping components in place but lacks details on permissions, reversibility, or consequences.

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

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

One sentence front-loads the core purpose. Efficient but could benefit from structured presentation for multiple aspects.

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

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

Given the simple tool with 2 string params and no output schema, the description covers the main action but omits prerequisites and potential side effects.

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

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

Schema coverage is 0%, but description provides no additional meaning for component_one and component_two beyond their names. Full burden on description to explain parameters, which it fails to do.

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

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

The description clearly states the tool creates an as-built joint that keeps both components in place, distinguishing it from a regular joint which typically moves components to align.

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 fusion_joint. The description implies context but gives no exclusions or explicit when-to-use instructions.

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 and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context by enumerating the fields returned by the inspection, which goes beyond the annotations and helps the agent understand what the tool reveals. It stops short of describing edge cases or exact return formatting, but is strong for a read-only query.

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 states the action first, then the selection method, then the concrete content of the inspection. There is no filler, repetition, or unnecessary context.

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

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

For a one-parameter, read-only inspection tool with no output schema, the description covers nearly everything an agent needs: what to pass and what will be returned. It gives the returned field categories explicitly. It could be more complete by noting exact output structure or failure behavior, but the current definition is sufficient for correct usage in most cases.

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

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

The schema only describes 'body' as an integer or string, with 0% coverage. The description compensates by explaining that the parameter can be an index or a name, mapping the two schema types to meaningful selection modes. It could add detail such as index base or name resolution rules, but the core semantics are clearly conveyed.

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

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

The description states a specific action ('Inspect one body') and a resource with selection scope ('by index or name'), then lists the exact data returned: operative ID, component, topology counts, volume, visibility, and bounding box. This distinguishes it from siblings like fusion_get_body, fusion_bounding_box, and fusion_physical_properties without 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 gives no explicit guidance on when to use this tool versus alternatives such as fusion_get_body, fusion_bounding_box, or fusion_physical_properties. There are no stated exclusions or conditions, so an agent must infer when this aggregate inspection tool is the right choice.

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

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

Annotations already declare readOnlyHint true, indicating safe read. The description adds that it returns the bounding box in millimeters, which is useful context but not substantial 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?

Single sentence with no unnecessary words. Front-loaded with the core 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?

For a parameterless tool with no output schema, the description provides essential information: what it returns and unit. It could mention the return format, but it is sufficient for a simple tool.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain 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 'Get', the resource 'bounding box of the whole design', and specifies the unit 'millimetres'. This is specific and distinguishes it from sibling tools.

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

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

No explicit guidance on when to use this tool versus alternatives. Usage is implied from the purpose, but without explicit context, the agent lacks direction on selection criteria.

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

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

The description adds behavioral context beyond annotations by stating that it auto-creates a document if none is open and that the box is centered on the XY origin rising in +Z. Annotations indicate mutability and side effects, and the description complements them without contradiction.

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

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

The description is concise at three sentences, starting with core functionality and adding useful tips without extraneous information. Every sentence adds value and improves clarity.

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

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

While the description covers orientation, auto-document creation, and component usage, it omits explanations for parameters 'x', 'y', and 'name', and does not specify the result (e.g., body or feature). Given the complexity of 7 parameters and no output schema, more detail is needed for full completeness.

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

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

With 0% schema description coverage, the description partially compensates by explaining width, depth, height as dimensions and the 'component' parameter for assembly use. However, it does not clarify the purpose of parameters 'x', 'y', and 'name', leaving gaps in parameter understanding.

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

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

The description clearly states it creates a box (cuboid) with specific dimensions and orientation, differentiating it from shape tools like cylinders or spheres. The verb 'Create' and resource 'box' are precise and unambiguous.

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

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

The description provides context for when to use the tool, such as building assembly parts inside a component and the shortcut for cubes. However, it does not explicitly state when not to use it or mention alternative tools, so it aligns with 'clear context, no exclusions'.

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

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

The description adds behavioral context beyond annotations: it creates an operation, optional parameters are specified, and it warns that tool assignment is needed for toolpath generation. Annotations already indicate side effects (openWorldHint=true, destructiveHint=false), and no contradictions.

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

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

The description is concise: two sentences, front-loaded with the core action and key parameter, with an important note. No extraneous information.

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

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

For a tool with 6 parameters and no output schema, the description adequately covers the main points. It could be improved by explaining that 'setup' refers to a setup ID and perhaps the return value (e.g., operation ID). Overall, it's reasonably complete for an agent to 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 description explains strategy with examples, and notes that tool_diameter, stepdown, and stepover are optional with units in mm. However, the required 'setup' parameter and optional 'name' are not described, which is a gap given 0% schema description coverage.

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

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

The description clearly states the action: 'Add an operation to a setup by strategy' with specific examples (face, pocket2d, adaptive2d, contour2d, drill, bore). This distinguishes it from sibling tools like fusion_cam_create_setup and fusion_cam_generate.

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

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

The description implies the tool is used when you need to add a CAM operation to an existing setup. It provides a prerequisite note: 'most strategies need a tool assigned before a toolpath will generate.' No explicit when-not-to-use or alternatives, but the context is clear.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, consistent with a write operation. The description adds no behavioral context beyond the creation action, such as side effects, required permissions, or document modifications.

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 sentence, efficiently stating the core purpose. It is front-loaded with the main action. While concise, it could include more detail without being verbose.

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

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

Given no output schema and low parameter coverage, the description is too minimal. It does not explain what a CAM setup is, what the 'body' parameter requires, or the outcome of creation. A creation tool for a complex domain needs more context.

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

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

Schema description coverage is 0%, so description must compensate. It provides examples of allowed values for operation_type (milling/turning/cutting), which adds meaning beyond the schema. However, it does not explain the 'body' or 'name' parameters.

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

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

The description clearly states the tool creates a CAM setup around a body, and mentions operation_type examples. However, it does not distinguish from sibling tools like fusion_cam_create_operation, which also creates something. The purpose is clear but lacks 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 explicit guidance on when to use this tool versus alternatives. The description does not provide context about prerequisites or exclusions. Users must infer usage from the tool name and parameters.

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

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

The description discloses the scoping behavior (operation, setup, all) and the fact that it generates toolpaths, which aligns with readOnlyHint=false. However, it lacks details on side effects, required document state, or what 'generate' entails (e.g., computation vs. saving). Annotations partially cover safety but not 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 sentence of 12 words, front-loading the core purpose. Every word earns its place, with no 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 tool has 3 parameters, no output schema, and is part of a CAM workflow, the description covers the main use cases but is incomplete. It omits prerequisites, exactly what generation does (compute/save?), and how to handle multiple specified parameters. Adequate but not thorough.

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

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

Since schema description coverage is 0%, the description compensates by explaining the relationship between parameters: 'one operation in a setup, a whole setup, or all=true.' This adds significant meaning beyond the schema, though it doesn't cover edge cases like conflicting parameter combinations.

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 'Generate' and the object 'toolpaths', and specifies the scope: one operation in a setup, a whole setup, or all. This distinguishes it from sibling tools like fusion_cam_post_process and fusion_cam_create_*.

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

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

The description gives no explicit guidance on when to use the tool versus alternatives, nor does it mention prerequisites or context. It only implies usage by stating what it does, without exclusion criteria or sequencing advice.

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

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

Annotations (readOnlyHint=true, destructiveHint=false) already indicate a safe read operation. The description adds nothing beyond confirming it lists operations, which does not 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 concise sentence with no unnecessary words. It efficiently conveys the core action and data fields.

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

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

For a simple list tool with no output schema, the description covers the relevant return fields. However, it lacks information about error conditions or prerequisites like whether the setup must exist.

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

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

Schema description coverage is 0% and only one parameter 'setup' exists. The description references 'in a CAM setup' but does not explain what the setup parameter is or its format, leaving ambiguity.

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 lists operations in a CAM setup and specifies the fields returned (name, has_toolpath, is_valid). It distinguishes from siblings like fusion_cam_list_setups and fusion_cam_list_tools by resource.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. Usage is implied as a simple list operation, but no alternatives or exclusions are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the prerequisite about the Manufacturing workspace, which is useful context beyond annotations. No contradictions.

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

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

Two sentences: first defines purpose, second gives prerequisite. No extraneous words. Front-loaded and efficient.

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

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

Given no parameters and annotations covering safety, the description is complete enough. It states the action and a required condition. Could mention return format, but not essential.

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

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

The input schema has no parameters, so schema description coverage is 100%. Per guidelines, 0 parameters yields a baseline of 4. No additional parameter info is needed.

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

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

The description clearly states it lists CAM setups and their operations, which is a specific verb and resource. It differentiates from siblings like fusion_cam_list_operations (lists operations) and fusion_cam_create_setup (creates setups).

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

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

It provides a prerequisite (Manufacturing workspace opened once), but does not explicitly compare to alternatives or state when not to use. The usage context is clear enough.

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 and destructiveHint=false, indicating a safe read operation. The description adds no further behavioral context (e.g., pagination, performance, or data freshness).

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 at one sentence and front-loaded with the main action. However, it sacrifices parameter information, which would be valuable.

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

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

The tool is simple with one optional parameter and good annotation coverage. However, the description omits the return format and does not explain the parameter, leaving some gaps for a complete understanding.

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

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

The schema description coverage is 0%, and the description does not mention the 'limit' parameter at all. It fails to add meaning beyond the schema, leaving the agent without guidance on how to use the parameter.

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

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

The description clearly states the tool lists 'cutting tools from the local tool library' with a specific purpose 'for assigning to operations'. It includes a specific verb and resource, and distinguishes from sibling list tools like fusion_cam_list_operations.

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

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

The description gives a hint on when to use ('for assigning to operations'), but provides no explicit guidance on when not to use it or comparison with other list tools like fusion_cam_list_operations or fusion_cam_list_setups.

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?

While annotations indicate a write operation, the description does not disclose side effects (e.g., file overwriting), required permissions, or error conditions. It mentions a default output folder but does not clarify behavior when the folder exists or when outputs already exist.

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

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

Two sentences, no redundancy. However, the second sentence ('post_processor is a generic post name') is somewhat ambiguous and could be integrated more clearly.

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

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

Given 5 parameters, no output schema, and minimal description, the tool lacks crucial information: how the G-code file is named, error scenarios, locale/units handling, and what happens when operation is null. The description is insufficient for 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?

With 0% schema description coverage, the description only loosely explains setup, operation, and post_processor. It does not define units, output_folder (despite mentioning a default path that conflicts with schema's null default), or provide parameter format/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 tool's action ('Post-process') and resource ('a setup (or one operation)'), with a specific output (G-code file) and a default location. This distinguishes it from sibling tools like fusion_cam_create_operation or fusion_cam_generate.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. The mention of post-processing setup or operation is implicit but does not contrast with similar tools like fusion_cam_generate.

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

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

The description adds no behavioral traits beyond what annotations already provide. Annotations indicate it is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false), but chamfering is inherently destructive—the description does not clarify this contradiction or explain side effects, permission needs, or failure modes.

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. It is concise with no filler. However, it could be slightly more structured by separating the edges and distance clarifications.

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 3 parameters and no output schema, the description covers the core functionality but lacks return value information (e.g., success status or modified body handle), prerequisites (body must exist), and edge indices context. It 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?

The input schema has 0% description coverage; the description adds meaning for two parameters: edges can be 'all' or a list of indices, and distance is in mm. The body parameter remains unexplained (integer or string ID), so there is some gap, but overall the description significantly enhances understanding of parameter 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 (chamfer), the resource (edges of a body), and the key parameter (distance). It distinguishes the tool from most siblings by naming a specific geometric operation, but it does not explicitly differentiate from fusion_fillet which performs a similar edge modification.

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

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

There is no guidance on when to use this tool versus alternatives like fillet or other edge operations. The description does not mention prerequisites, typical use cases, or scenarios where this tool is inappropriate.

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?

Description adds that it creates copies over an angle, which aligns with non-destructive hints, but doesn't provide additional behavioral context beyond what annotations already indicate.

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 with key verb, resource, and parameters, no redundant information, highly efficient.

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

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

Covers core functionality and main parameters, but could mention default values for axis and angle for completeness, though not critical given the description.

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

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

Despite 0% schema coverage, description explains axis options (x/y/z), that count is copies, and angle is in degrees, adding significant meaning beyond schema titles.

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

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

Description clearly states 'Pattern a body around axis x/y/z' with specific verb and resource, and distinguishes from siblings like fusion_rectangular_pattern by the circular nature.

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

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

Implies usage for circular patterns but lacks explicit guidance on when to use versus alternatives like fusion_rectangular_pattern, and no exclusion criteria.

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

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

Annotations declare destructiveHint=true, but the description goes beyond that by explaining the safety behavior: with save=true and never-saved documents, it attempts to write to the active project and leaves the document open if saving fails, avoiding data loss. This is critical behavioral information that annotations do not provide, making the tool's side effects and failure mode clear.

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

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

The description is concise (three sentences) and front-loaded with the core behavior (save true/false). It efficiently packs critical information about document selection, saving location, and failure handling without unnecessary 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?

Despite no output schema being present, the description explains the main outcomes (document closed vs. left open) and error behavior. However, it lacks details on edge cases like closing the only open document or what happens if the named document doesn't existiments. Given the tool's complexity and the richness of annotations, this is acceptable but not perfect.

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 must compensate, and it does: it explains that 'document' names another open document to close (rather than active), and that 'name'/'project' choose where to save a never-saved document. It does not explain 'description' or the default behavior of other parameters, but the key ones are covered, so a slight gap remains.

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 primary function: closing a document with a flag to save or discard changes. It also explains the two possible behaviors (save vs. discard) and the context of the active document. This distinguishes it clearly from sibling tools like fusion_save_document and fusion_close_other_documents.

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

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

The description implies when to use save=true vs save=false (to persist changes or discard them). It also hints at the alternative for closing multiple documents (fusion_close_other_documents is a sibling). However, it doesn't explicitly state 'use fusion_save_document when you want to save without closing' or other exclusions, so it falls short of being fully explicit.

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

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

The description explicitly discloses the destructive consequence: 'save=false discards their unsaved changes.' This goes beyond the destructiveHint annotation by specifying exactly what is destroyed and under which condition. The description is consistent with the annotations.

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

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

Two sentences with no filler: the first front-loads the action and purpose, the second adds the critical parameter consequence. Every word earns its place.

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

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

For a one-parameter destructive bulk operation, the description fully covers what happens, the scope (all other documents), and the risk (unsaved data loss). No output schema exists, and return values are not needed for correct invocation. Complete enough for an agent to use safely.

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 zero schema description coverage, the description must carry parameter meaning. It explicitly explains the behavior of save=false (discards unsaved changes), which is the default and most important case. It only implies save=true behavior, but this is easily inferable and the single parameter is adequately covered.

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

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

The description states a specific action ('Close every open document EXCEPT the active one') with a clearly defined resource and scope, making it unmistakable what the tool does. The phrase also differentiates it from siblings like fusion_close_document, which closes a single document.

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

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

The description provides a clear usage context ('handy for tidying up after stray documents accumulated') that helps an agent decide when to invoke it. It does not explicitly mention alternatives or when-not-to-use, but the scope distinction from sibling tools is implicit and sufficient.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds value by explaining the effect of keep_tools=true to preserve tool bodies, providing behavioral context 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 extremely concise with two sentences, no filler, and immediately communicates the core purpose. Every sentence adds value.

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

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

The description covers key aspects but lacks information on return values, what happens to the target body, and error conditions. Given no output schema, more context would help the agent understand the full effect.

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 schema description coverage at 0%, the description compensates by explaining the operation parameter (join, cut, intersect) and the keep_tools parameter. However, it does not fully detail the 'tools' parameter's array format or the 'target' parameter's meaning beyond 'by index or 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 tool performs boolean combinations (join, cut, intersect) on a target body with tool bodies. This distinguishes it from sibling tools like delete, move, or scale, which have different 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 implies the tool is for boolean operations on bodies but does not explicitly specify when to use it versus alternatives such as fusion_split_body or fusion_scale_body. No direct guidance on prerequisites or context is provided.

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

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

Annotations already indicate this is a non-read-only, non-idempotent operation; the description adds that creation can optionally set the build target. It does not elaborate on open-world side effects or document context, but it does not contradict the annotations.

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

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

A single front-loaded sentence conveys the core action and the optional parameter behavior with no redundant words. Every phrase earns its place.

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

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

No output schema is provided, and the description does not explain return behavior, prerequisites such as an active document, or what 'name' should refer to. For a creation tool, the missing operational context leaves an agent to rely on unstated assumptions.

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 must compensate for parameter meaning. It clarifies the 'activate' parameter via 'optionally making it the build target', but it gives no additional meaning for the required 'name' parameter.

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

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

The description uses a specific verb and resource ('Create a component occurrence') and names the distinct optional behavior of making it the build target. No sibling tool covers the same create-occurrence operation, so it is clearly distinguishable.

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

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

No guidance is given on when to use this tool instead of related component tools such as fusion_set_active_component or fusion_list_occurrences. The description does not state prerequisites, exclusions, or alternative tools.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so description adds the key behavioral limitation that the API cannot create flanges/bends. This adds context beyond annotations but does not fully describe behavior like return values or side effects.

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

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

The description is two sentences (21 words), front-loaded with the core purpose, and includes a critical note. Every sentence adds value with no redundancy.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose and a key limitation. However, the lack of parameter format guidance and any description of what the flat pattern creation entails (e.g., new feature added) leaves 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?

With 0% schema description coverage, the description must compensate. It adds that the body must be 'sheet-metal' and 'EXISTING', but provides no guidance on how to specify the body (e.g., ID or name), leaving the parameter ambiguous.

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

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

The description clearly identifies the tool's action ('Create a flat pattern') and the specific resource ('EXISTING sheet-metal body'). It distinguishes from siblings by focusing on flat patterns, a unique capability among the listed tools.

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

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

The description implies usage context ('from an EXISTING sheet-metal body') and notes a limitation about flanges/bends, but does not explicitly compare to alternatives or state when not to use. Guidance is implied but not explicit.

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 non-read-only and non-destructive behavior. Description adds minimal context beyond the example.

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 with example, front-loaded verb, no unnecessary words.

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

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

Lacks details on return value, effect on design, duplicate handling, or prerequisites.

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

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

Schema coverage is 0%, so description must compensate. It hints at name and expression via example but omits unit and comment semantics.

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

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

Description clearly states the action ('Create') and resource ('new user parameter'), with a concrete example that distinguishes it from sibling tools like fusion_set_parameter or fusion_get_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?

No guidance on when to use this tool instead of siblings, no prerequisites or when-not-to-use conditions.

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

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

The description's 'Create' aligns with readOnlyHint=false and does not contradict any annotation. It adds the useful detail that the sketch is empty, but it does not disclose side effects such as whether a document must be open or whether the new sketch becomes the active target for subsequent sketch tools.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. It conveys the essential action, target resource, and parameter semantics 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?

For a simple two-parameter create operation with no output schema, the description is largely complete. The main missing context is the expected working state (e.g., active document) and whether the created sketch becomes active for later geometry tools, but these are not critical to invoking the operation.

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

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

The description clarifies the plane parameter by explaining that xy/xz/yz are base planes and an integer is a construction-plane index, which is meaningful given the anyOf schema. However, it gives no guidance on the 'name' parameter, leaving a gap in an otherwise low-coverage 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 uses a specific verb ('Create') with a clear resource ('empty sketch') and location ('base plane (xy/xz/yz) or construction-plane index'). The word 'empty' and the plane focus distinguish this from sibling sketch tools like fusion_create_sketch_on_face and the geometry-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 implies the usage context: create an empty sketch on a plane before adding geometry. However, it does not explicitly state when to choose this over fusion_create_sketch_on_face or mention any exclusions, so the guidance remains implicit.

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 mutation (readOnlyHint=false) and non-destructive nature. The description adds that coordinates are local to the face, which is useful. It does not disclose potential errors or side effects, but given annotation coverage, it is adequate.

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

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

Two concise sentences with no extraneous words. The key information is front-loaded: the action and prerequisite.

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

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

For a simple tool with no output schema, the description covers purpose and a usage hint but omits details on return values and the 'name' parameter. Adequate but not fully 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?

With 0% schema description coverage, the description partially compensates by explaining the 'face' parameter's origin and coordinate locality. However, it does not explain the 'body' or 'name' parameters, leaving gaps.

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

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

The description clearly states the verb 'create', the resource 'sketch on a planar face', and differentiates from siblings like fusion_create_sketch by specifying the face constraint.

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

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

Explicitly suggests using fusion_list_faces to obtain the face index, providing a prerequisite step. However, it does not explicitly state when not to use this tool or mention alternatives beyond the implicit sibling.

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 openWorldHint=true and readOnlyHint=false, consistent with creating a new object. The description adds value by revealing the auto-document creation behavior, which is not apparent from annotations alone.

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 purpose and key parameters without extraneous text.

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

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

For a 6-parameter tool with no output schema, the description covers the core functionality and key parameters. It could improve by clarifying the x,y parameters and the interaction between radius and diameter, but is largely adequate for an agent.

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

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

With 0% schema coverage, the description compensates by explaining height, radius, and diameter parameters and their relationship. However, it omits the x, y, and name parameters, leaving their roles unclear (though x,y default to 0, consistent with centered origin).

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

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

The description clearly states the tool creates a cylinder with specified height and radius/diameter, centered at the XY origin. It distinguishes from other shape-creation tools like fusion_box and fusion_sphere.

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

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

The description mentions auto-creating a document if none is open, providing context on when the tool can be used without a document. However, it does not explicitly compare to sibling tools like fusion_box or fusion_revolve for alternative shape creation.

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

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

The description reinforces the destructiveHint annotation by stating 'Destructive.' and adds that it clears the design. However, it does not disclose potential irreversible effects or confirmations. With annotations already marking it destructive, the additional behavioral context is minimal.

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

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

A single, concise sentence conveys the core purpose without unnecessary words. Every part is essential.

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

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

Given no parameters, no output schema, and a simple destructive action, the description is mostly complete. It could mention that deletion is permanent or that the design is reverted, but current wording suffices.

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?

No parameters exist, so the description does not need to explain them. Baseline score of 4 is appropriate as there is nothing missing.

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

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

The description explicitly states 'Delete every timeline feature, clearing the design.', clearly identifying the action and scope. It distinguishes from sibling tools like fusion_delete_body or fusion_delete_parameter which target specific elements.

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 (e.g., selective deletions or undo). Only 'Destructive.' is present, which is already indicated by the destructiveHint annotation. Lacks context for appropriate invocation.

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 destructive and non-idempotent behavior. The description adds useful context beyond annotations: it promises to 'verify the resulting model state' and specifies that it does not delete sketches, features, or construction geometry. This gives the agent a clearer picture of side effects, though it does not detail failure scenarios or reversibility.

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

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

The description is two concise sentences, front-loaded with the core action and outcome. Every sentence adds value: the first defines the operation and result, the second clarifies scope. No 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?

The description is reasonably complete for a destructive tool given annotations, but it leaves a key gap: the meaning of the 'body' parameter is unexplained, which is critical for correct invocation. It also does not address what happens if the body does not exist or how verification is performed. Without an output schema, more detail on expected outcomes would improve completeness.

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

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

Schema description coverage is 0%, and the description provides no additional meaning for the 'body' parameter. It does not clarify whether the integer/string refers to an ID, name, or index, nor how to obtain it. The description says 'exactly one body' but that is behavioral, not semantic. The tool description fails to compensate for the schema's lack of parameter 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 states a specific verb and resource ('Delete exactly one body') and adds scope clarification ('This does not delete sketches, features, or construction geometry.'). While it does not name a sibling tool, the scope disclaimers effectively distinguish it from other deletion or modification tools, making the purpose unambiguous.

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

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

The context is clear: this tool deletes a single body and verifies the model state. It implicitly excludes multiple-body deletion with 'exactly one'. However, it does not explicitly name alternatives (e.g., fusion_delete_all) or state when not to use this tool, so it does not fully meet the 5-level criterion.

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. The description confirms deletion and adds the constraint about model parameters, but does not disclose additional behavioral traits like error handling or side effects.

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

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

The description is a single sentence, concise, and front-loaded with the key action. It avoids unnecessary words, though a bit more detail could be added 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 simplicity (one required param, no output schema), the description covers the main purpose and constraint. However, it lacks details on behavior when parameter doesn't exist or success/failure indicators.

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 documentation coverage is 0%. The description only says 'by name' but does not explain the format, case sensitivity, or how to obtain the parameter name. The schema provides no description for '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 'delete', the resource 'user parameter', and adds a constraint 'model parameters cannot be deleted'. This distinguishes it from sibling tools like create_parameter or set_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 gives a condition (model parameters cannot be deleted) but does not explicitly guide when to use this tool over alternatives or when not to use it. It implies usage for user parameters only.

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 as read-only and non-destructive, so the bar is lower. The description adds context about what is reported (units, counts, save state, active component) but discloses no additional behavioral traits like side effects or performance characteristics. It is consistent with the readOnlyHint.

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

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

A single sentence that front-loads the verb and resource ('Summarize the active document') and then lists the information items. There is no fluff or redundancy.

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

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

With no output schema, the description must communicate what the tool returns, and it does enumerate the key data points. It is slightly vague about the level of detail and about whether counts are recursive across the whole document, but it is sufficient for a zero-parameter summary tool.

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

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

The tool has 0 parameters, and the schema is an empty object with 100% coverage, so the description carries no burden of explaining parameters. Baseline 4 applies.

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

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

The description clearly states the tool's purpose: 'Summarize the active document' and enumerates the specific contents (units, counts of bodies/components/sketches/parameters, save state, active component). It is distinct from the list tools and getters, though it doesn't explicitly differentiate itself from the sibling 'fusion_summary'.

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 usage is implied by the verb 'Summarize' – an agent would call this for a high-level overview. However, it provides no explicit guidance about when to choose this over alternatives like fusion_list_bodies or fusion_summary, and no when-not-to-use conditions.

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

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

Annotations indicate a write operation (readOnlyHint=false) with potential side effects (openWorldHint=true). The description adds context about angle units and plane selection but does not disclose failure modes or reversibility. It does not 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?

Two sentences: first states purpose, second provides parameter details. No redundant information, and critical details are front-loaded.

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

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

Given the lack of output schema and the mutation nature of the tool, the description covers essential aspects: purpose, angle, plane, and faces behavior. It does not explain return values or error conditions, but for a drafting operation this is acceptable.

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 carries full burden. It explains that angle is in degrees, plane is a string (xy/xz/yz), and faces is a list of indices from fusion_list_faces or null for all. Body is not elaborated, but the description adds significant meaning to three of 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 clearly states 'Apply draft to faces of a body,' identifying the specific operation. It distinguishes from sibling tools like fusion_fillet and fusion_chamfer by using the verb 'draft', though it does not explicitly differentiate.

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 usage hints such as angle in degrees and plane options (xy/xz/yz), and notes that faces can be omitted for all. However, it does not offer guidance on when to use draft over alternatives like fillet or chamfer, relying on implied context.

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

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

Annotations indicate it's not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds no further behavioral details such as file overwrite behavior, path handling, or side effects beyond stating the export action.

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

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

The description is very concise (one short sentence) and front-loaded with essential information. However, it is slightly too brief, missing details that could be added without sacrificing 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?

With 2 parameters, no output schema, and moderate complexity (file export), the description is incomplete. It does not explain file save location, return value, or prerequisites like a valid sketch. More context is needed for an agent 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?

Schema description coverage is 0%, and the description only mentions 'sketch' without explaining that it's a required parameter expecting an ID or name. The 'path' parameter is entirely undocumented. No parameter semantics are conveyed beyond the raw schema.

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

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

Description clearly states 'Export a sketch to a 2D DXF file' with an example use case (laser cutting/drawings). It distinguishes itself from sibling export tools by specifying 2D DXF format and application.

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 laser cutting or 2D drawings but does not explicitly state when to use this tool over other export siblings (e.g., fusion_export_stl, fusion_export_step). No exclusion criteria or alternatives are mentioned.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true, suggesting potential side effects. The description adds only that it 'preserves the full design tree' but does not disclose where the file is saved, whether it overwrites, or any other behavioral traits beyond what annotations already suggest.

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 sentence, which is concise and front-loaded, but it is too brief given the tool's context, lacking necessary details about parameters and usage.

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

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

With one optional parameter, no output schema, and many sibling export tools, the description only covers purpose. It fails to explain parameter behavior, return value, or provide enough context for an agent to use the tool correctly.

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

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

The only parameter 'path' is optional with default null, and the schema coverage is 0%. The description provides no explanation of what the path does, what happens if null, or expected format, failing to compensate for the lack of schema descriptions.

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

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

The description clearly states the verb 'Export' and the resource 'native Fusion archive (.f3d)', and distinguishes it from other export tools by mentioning 'preserving the full design tree', which indicates a specific use case not covered by sibling export tools.

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

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

The description implies usage when a native Fusion archive is needed, but does not provide explicit guidance on when to use this tool versus alternatives like fusion_export_step or fusion_export_stl, nor does it mention when not to use 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?

The description discloses the license restriction, which is a behavioral constraint, but does not explain other traits like whether it modifies the document, creates a file, or handles the path parameter. Annotations provide readOnlyHint=false and openWorldHint=true, but the description adds little beyond the restriction.

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, consisting of two sentences with no unnecessary words. It is front-loaded with the tool's purpose and efficient in its use of space.

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

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

While the description adequately covers purpose and usage, it is incomplete due to the lack of parameter documentation. For an export tool, understanding the path parameter is crucial. The absence of an output schema is acceptable, but the missing parameter info is a significant gap.

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

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

The description does not explain the 'path' parameter at all. With 0% schema description coverage, the description carries the full burden of clarifying parameter semantics, but it fails to do so, leaving the agent guessing about its purpose (likely an output file path).

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 exports the whole design to IGES format (.igs), using a specific verb and resource. It distinguishes itself from sibling export tools like fusion_export_step by mentioning the format and license restriction.

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

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

The description provides explicit usage guidance: it notes that IGES export is restricted on personal-use Fusion licenses and recommends preferring STEP for CAD interchange. This helps the agent decide when to use this tool versus alternatives.

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

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

The description says 'Export the whole design', which is non-destructive and aligns with annotations (destructiveHint: false, readOnlyHint: false). However, it adds no further behavioral context such as file overwrite behavior, permission requirements, or output format details beyond the annotation baseline.

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 function. However, it omits crucial parameter details, which would improve clarity without significantly increasing length.

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

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

For a simple export tool with one optional parameter and no output schema, the description fails to specify the meaning of the 'path' parameter or the behavior when it is null. It also lacks guidance on file destination or format specifics, making it incomplete for an agent to use correctly.

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

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

The input schema has one optional parameter 'path' with no description, and the parameter coverage is 0%. The description does not explain the parameter's purpose or default behavior (e.g., where the file is saved if path is null). This is a significant gap given the lack of schema descriptions.

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

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

The description clearly states the tool exports the entire design to STEP format, naming the specific file extension and asserting its suitability for CAD interchange. This provides a specific verb (Export) and resource (design to STEP), distinguishing it from sibling export tools like DXF, F3D, IGES, and STL.

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 CAD interchange (mentioning 'best for CAD interchange') but does not explicitly state when to use this tool versus alternatives like DXF or STL. No guidance on prerequisites, exclusions, or direct comparisons with siblings is provided.

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

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

Annotations indicate mutability (readOnlyHint=false) and potential side effects (openWorldHint=true). Description adds that it saves to the host with a default path, but does not explain file overwrite behavior or require an open document, leaving 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?

Two sentences, no fluff. Essential info is front-loaded: purpose, optional body, refinement options, and save location. Every word counts.

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

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

No output schema exists, so the description should cover the return or outcome. It states the file is saved, which is helpful, but does not mention what the tool returns (e.g., success message, path). It is adequate but not fully complete.

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

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

With 0% schema description coverage, the description must compensate. It explains 'body' and 'refinement' well, but 'path' is omitted. This partial coverage results in a baseline 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?

Clearly states 'Export to STL (for 3D printing)', which is a specific verb and resource. It distinguishes from sibling export tools like export_dxf and export_f3d by format and purpose.

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

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

Mentions optional 'body' parameter to select a specific part, otherwise exports the whole design, and refinement levels. Does not explicitly compare with other export tools, but the context of 3D printing makes it clear when STL is appropriate.

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

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

Annotations provide the read-only and destructive hints, but the description itself adds little behavioral context. It does not explain that extrusion creates or modifies a 3D body, that a cut operation removes material, or what happens to the original sketch. The listed operation/direction values mostly repeat the input schema's enum rather than revealing 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 extremely compact, with no filler or redundancy. It front-loads the main action and then packs the key parameter semantics into two short clauses, making it easy to scan.

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 five parameters, no output schema, and no schema-level descriptions, the description is too incomplete for safe autonomous use. It omits return values, prerequisites like an active sketch, whether the operation creates a new body or modifies the existing one, and how profile indices are resolved.

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 compensates well by explaining the distance unit (mm), profile as an index or 'all', and enumerating direction and operation choices. However, the required 'sketch' parameter is not directly explained, and the precise meaning of profile indexing remains ambiguous.

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 verb and resource: extrude a sketch profile by a distance in mm. It lists operation, direction, and profile options, making the core purpose understandable. However, it does not explicitly differentiate from related modeling tools like revolve, sweep, or loft, though the name and action make the distinction mostly implicit.

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, nor are there any prerequisites such as requiring an active sketch or component. The description only enumerates parameter options, leaving the agent to infer the appropriate context.

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

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

Annotations already declare readOnlyHint=false, indicating mutation. The description adds the unit (mm) and the default for edges, but does not detail if the body is modified in-place, what happens with invalid edge indices, or any side effects. This is acceptable but adds minimal value beyond 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 sentence that is front-loaded with the action. No redundant words or phrases, making it highly efficient 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 has 3 parameters, no output schema, and low schema coverage, the description covers the key operational aspects but omits return behavior (success/failure) and the nature of the 'body' parameter. It is adequate but not rich.

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

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

Schema coverage is 0%, so the description carries the burden. It explains the unit for radius and the default/list behavior for edges, compensating well. However, the required 'body' parameter is left undefined (no type or source hint), so not all parameters are fully clarified.

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 'Round edges of a body by `radius` mm' uses a specific verb ('round') and clearly identifies the resource (edges of a body). It implicitly differentiates from sibling tools like fusion_chamfer, making the tool's purpose unmistakable.

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 (e.g., fusion_chamfer). It does not specify prerequisites, limitations, or context for edge index usage, leaving the agent to infer usage from the 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 provide idempotentHint and other traits. The description adds no behavioral context beyond what annotations state, missing details like side effects or permissions.

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?

Extremely concise and front-loaded. Every word is necessary. Zero wasted space.

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

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

For a parameter-less tool with clear annotations and a simple purpose, the description is fully sufficient. No output schema 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?

No parameters exist, so baseline is 4. Description adds no parameter information, but schema coverage is 100%.

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 ('Zoom/fit the view') and the resource ('to show the whole model'). It distinguishes from sibling tools like fusion_set_view which allows custom view settings.

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

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

Implies usage when wanting to see the entire model, but does not explicitly state when to use versus alternatives like fusion_set_view. No exclusions or 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds behavioral meaning by explaining that the returned value represents the target for subsequent build operations, which goes beyond the structured hints. No contradictions with annotations.

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

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

A single sentence with no fluff. The verb is front-loadedhol and every word earns its place, delivering the essential meaning in fourteen words.

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

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

For a zero-parameter getter with strong annotations, the description covers the core semantic and operational relevance. The only minor gap is the lack of an explicit return type (e.g., a component name string vs. an object), but this does not hinder correct invocation.

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

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

With zero parameters expeced, the schema coverage is vacuously 100%, so there is nothing for the description to clarify about inputs. The baseline of 4 applies, and no parameter-related compensation is needed.

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

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

The description states a specific verb ('Return') and resource ('current build target'), making the tool's function immediately obvious. It clearly distinguishes from the nearby sibling fusion_set_active_component by focusing on retrieval, not modification.

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 text 'subsequent build operations target it' conveys the practical context: call this to know where future build-related operations will apply. It does not explicitly name alternatives or exclusions, but for a getter, the usage is intuitive and well implied.

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 and destructiveHint=false, covering safety. The description lists returned data but adds no behavioral traits beyond that. Consistent, but no extra 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?

A single, well-front-loaded sentence that efficiently conveys purpose, identification method, and returned data. No wasted words.

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

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

Given no output schema, the description explicitly lists return fields. The one parameter is fully clarified. All necessary context for a read-only retrieval tool is provided.

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

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

Schema has 0% description coverage. The description clarifies that 'body' can be an integer index or string name, adding essential meaning beyond the anyOf type. This compensates well.

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

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

The description clearly states it provides detailed info on a single body by index or name, listing specific properties (volume, area, counts, bbox). It distinguishes from siblings like 'fusion_list_bodies' and 'fusion_bounding_box'.

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 use when needing detailed info on one body, but does not explicitly state when not to use or contrast with alternatives. Sibling names provide that context, but the description lacks direct 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?

The description adds no behavioral context beyond what annotations already provide (readOnlyHint=true, openWorldHint=true). It doesn't explain what happens if the parameter is not found, whether caching is used, or any side effects. Given annotations already declare it read-only, the description's value is minimal.

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 sentence with no wasted words. However, it is so brief that it sacrifices informative content. It is efficient but not optimally structured for clarity.

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

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

The tool is simple but the description lacks details about return value (e.g., what is returned: value, units, metadata?). With no output schema and a low description coverage, the agent lacks essential information to interpret the tool's output. Sibling tools add context but the description itself is incomplete.

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

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

Schema coverage is 0%, and the description only says 'by name', adding little meaning to the 'name' parameter. It doesn't specify format, case sensitivity, or uniqueness constraints. For a required string parameter, additional guidance would help the agent construct valid inputs.

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 'Get one parameter by name', specifying the action (Get) and the resource (parameter). It distinguishes from sibling tools like 'fusion_list_parameters' (lists all), 'fusion_set_parameter' (modify), and 'fusion_create_parameter' (create).

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 that for multiple parameters, one should use 'fusion_list_parameters', or that this tool is for retrieving a single parameter's value. Context signals include sibling tools that are clearly related but no exclusions or recommendations.

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. The description adds no further behavioral details, such as return format or any side effects.

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

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

Single concise sentence with no unnecessary words or repetition.

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

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

For a getter with no output schema, the description should at least indicate the return value type (e.g., string for unit name). It lacks this critical detail, making it incomplete.

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

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

No parameters exist, so schema coverage is 100%. The description does not add any semantics about the output, which would be beneficial since there is no output schema.

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

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

The description 'Get the document's default length unit' clearly specifies the action (get) and resource (document's default length unit), distinguishing it from sibling tools like fusion_set_units.

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 (e.g., fusion_set_units). Missing context about when getting units is appropriate.

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

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

Annotations indicate the tool is not read-only and not destructive, but the description adds no behavioral context beyond the action. It does not mention side effects, reversibility, or how grounding interacts with other constraints. No contradiction with 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 sentence with no wasted words, but it is too brief for a non-trivial operation. It could be expanded to include necessary details without becoming verbose.

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

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

Given no output schema and two parameters, the description does not specify return values, error handling, or what constitutes grounding. The openWorldHint annotation suggests external effects, but the description does not clarify.

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 two parameters with 0% description coverage. The tool description provides zero additional meaning for 'name' or 'grounded', forcing the agent to guess their semantics (e.g., what qualifies as a valid name, the effect of ungrounding).

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 'ground' or 'unground' and the resource 'component occurrence', distinguishing it from sibling tools like fusion_move_component or fusion_joint. However, it does not explain that grounding fixes the component in space, which is a key concept.

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 fusion_joint or fusion_rigid_group. The description lacks any context about prerequisites or typical use cases.

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

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

Adds behavioral context beyond annotations: it is a cut operation, defaults to through-all, and explains local coordinates for faces. No contradiction with annotations. Could mention idempotency or return value but not required.

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

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

Two sentences with no wasted words. The primary action and defaults are front-loaded, and special cases are clearly separated. Excellent structure.

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

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

For an 8-parameter tool with no output schema, the description covers most key aspects. Missing explanation of the 'through_all' boolean slightly reduces completeness. Overall, it sufficiently informs 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?

With 0% schema description coverage, the description compensates by explaining diameter, x, y, plane, on_body, on_face, and depth. However, it omits the 'through_all' parameter, which has a default of true and might need 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 specifies the action ('drill a circular hole'), the resource ('diameter mm at (x,y)'), and the default behavior (through everything on plane). It clearly distinguishes from sibling tools like fusion_box or fusion_cylinder by focusing on hole cutting.

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?

Describes default through-all behavior and provides explicit instructions for using on_body + on_face for holes on existing faces. Mentions blind holes with depth. However, does not explicitly compare to alternatives like fusion_extrude or state when not to use.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds that it returns volumes and checks interference, but does not detail behavior for edge cases like missing bodies or coincident faces. The description is consistent with 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 extremely concise: two sentences that convey purpose, input, output, and use case. Every word adds value, with no redundancy.

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

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

For a tool with 2 parameters and no output schema, the description adequately covers the key information: what it does, what to pass, and what is returned. Minor omission is the handling of multiple body pairs, but overall sufficient.

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

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

Schema coverage is 0%, so the description must compensate. It explains that 'bodies' can be a 'list of indices/names', adding meaning beyond the raw schema. However, it does not elaborate on 'include_coincident_faces' or the format of the returned volumes.

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: 'Check interference between 2+ bodies' and specifies the output 'overlapping volumes (mm³)'. It uniquely identifies this tool among siblings as the only interference-checking 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 gives a clear use case: 'Use to validate clearances/fits in an assembly.' While it doesn't explicitly state when not to use or compare to alternatives, the context is sufficient for a specialized tool.

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

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

The description discloses the core behavior: creating a joint with various types and axis options. Annotations indicate it is not read-only, not idempotent, and not destructive, which aligns with the description. It adds context beyond annotations by explaining the parameter effects.

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

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

The description is extremely concise: two sentences that front-load the purpose and then detail parameters. Every sentence adds value with no wasted words or redundancy.

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

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

The description covers the essential aspects of creating a joint, including types, axis, and face options. However, it does not mention return values or potential error conditions, which would be helpful given there is no output schema.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter: type (rigid/revolute/slider/cylindrical/planar), axis (x/y/z), face_one/face_two (planar face indices), and the required component names. It clarifies default values and usage.

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

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

The description clearly states 'Create a joint between two components.' It specifies the verb (Create) and the resource (joint), and lists the types and parameters. It distinguishes itself from siblings like 'fusion_as_built_joint' by focusing on creating joints with explicit types and 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?

The description provides clear guidance on how to use the tool, including default behavior (joins at origins) and optional face indices. However, it does not explicitly mention when not to use this tool or provide alternatives beyond the implicit presence of sibling tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safe read operation. The description adds no further behavioral context beyond what annotations provide. It does not 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?

Single sentence, no wasted words. Purpose is front-loaded. Every part is necessary.

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

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

Tool is simple (two optional params, no output schema). Description implies return type (list of names). Annotations cover safety. Slightly less than perfect because no hint about pagination or limit 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 0%, but description adds meaning to 'filter' parameter ('optionally filtered by substring'). However, 'limit' parameter is not explained. Baseline 3 is appropriate given partial compensation.

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 lists available appearance names with optional substring filtering. It uses specific verb 'list' and resource 'appearance names', and distinguishes from sibling tool 'fusion_set_appearance' which sets appearances.

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. Among many listing tools (list_bodies, list_components, etc.), no differentiation is provided. The description does not mention 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 already indicate readOnlyHint: true and destructiveHint: false, so safety is clear. The description adds value by detailing return fields (index, name, volume, bounding box) beyond annotations. No contradictions.

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

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

Two concise sentences that front-load the purpose and add a usage hint. No extraneous words; every sentence earns its place.

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

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

Despite lacking an output schema, the description explicitly states the returned data (index, name, volume in mm³, bounding box in mm) and provides context for using the output. Complete for a listing tool.

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

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

The tool has zero parameters, and schema coverage is 100% trivially. The description does not need to explain parameters; the baseline for 0 parameters is 4.

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

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

The description clearly states the tool lists all solid/surface bodies with specific attributes (index, name, volume, bounding box), and distinguishes itself from siblings like fusion_get_body (single body) and fusion_list_faces (faces) by specifying the output.

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

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

The description explains that the output index or name can be used to target a body in other tools, providing clear usage context. It doesn't explicitly state when not to use it, but the read-only nature and listing purpose are well communicated.

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 readOnlyHint=true and destructiveHint=false. The description adds that the tool returns body counts, which is behavioral context beyond the annotations. However, it does not disclose any potential limitations (e.g., whether it includes nested components).

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

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

The description is a single, concise sentence that front-loads the key action and result. It contains no unnecessary words and earns its place.

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

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

Given no output schema, the description only mentions 'body counts' without specifying the structure (e.g., list of component names with counts, hierarchical status). This leaves some ambiguity about the return format, making it moderately complete.

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

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

With no parameters and 100% schema coverage, the description does not need to add parameter details per the baseline rule (0 params = baseline 4). The description focuses on the output, which is acceptable for a parameterless tool.

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 'list', the resource 'components', and the specific information 'with their body counts'. This distinguishes it from sibling tools like fusion_list_bodies (which list bodies, not components with counts) and other list 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 does not mention when not to use it or compare to similar list tools like fusion_list_occurrences or fusion_list_features, leaving the agent to infer usage context.

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

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

The annotations already list readOnlyHint=true and destructiveHint=false, covering the read-only safety profile. The description adds useful context about what it returns (state per document), which goes beyond annotations, but does not disclose any extra behaviors like possible slowdowns or filtering semantics.

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

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

A single sentence front-loads both the action ('List') and the object ('open Fusion documents'), with the state detail appended. No filler, every word earns its place.

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

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

The tool has no parameters and no output schema; the annotations cover the read-only nature. The description includes the key return concept (state), which is enough for basic usage. It could be slightly richer by saying exactly how the return is structured (e.g., an object per document), but for a simple list operation this is acceptable.

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

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

The tool has zero parameters, so there is no parameter semantics to clarify. With schema description coverage already at 100%, there is nothing for the description to add.

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

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

The description states a specific verb ('List') and a clearly scoped resource ('all open Fusion documents'), and it names the returned data ('active / modified / saved state'). This distinguishes it from siblings like fusion_document_info or fusion_list_projects with sufficient precision.

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

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

The usage is implied: it is for enumerating open documents. However, there is no explicit mention of when to choose this over alternatives like fusion_document_info, and no exclusion or context such as 'when you need a list of all documents'. The purpose is clear but the guidance is minimal.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context by enumerating exactly what the topology snapshot includes: index, curve type, length, points, radius when circular, and adjacent face indices/types, which is beyond what the schema or annotations convey.

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

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

The description is concise and front-loaded, leading with the primary action and purpose, then listing the output contents in a compact second sentence. Every part earns its place and no unnecessary fluff is present.

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

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

The returned fields are clearly listed, which helps compensate for the lack of an output schema. However, the description does not explain the body parameter's accepted formats, which is a critical gap given the schema provides no parameter descriptions. The tool is otherwise reasonably self-contained for a read-only enumeration.

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 does not clarify how the 'body' parameter should be specified—whether integer index, string ID, name, or path. The only hint is the phrase 'one body's edges', which does not explain accepted value formats or how to resolve a body.

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

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

The description clearly identifies the verb ('Enumerate') and resource ('one body's edges'), and frames the use case as preparing for selective operations. It is distinct from likely siblings like fusion_list_faces by the resource type, but it does not explicitly name or contrast any sibling tool.

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

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

The phrase 'for selective operations' gives a reasonable hint that this tool should be used when you need to choose edges for a downstream operationcars. However, it does not explicitly explain when not to use it, nor does it recommend alternatives such as fusion_list_faces or fusion_get_body.

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 readOnlyHint=true, destructiveHint=false. Description adds details about output properties and usage hints. No contradictions; description enriches 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?

Two concise sentences: first states action and output, second gives usage guidance. No wasted words, 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?

For a simple list tool with no output schema, description provides output properties and usage context. However, parameter details are missing, which is a gap given low schema coverage.

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

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

Schema description coverage is 0%, yet description does not clarify the 'body' parameter format (integer or string) or how to identify the body. Only mentions 'body' without additional semantics.

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

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

Description clearly states the tool lists faces of a body and specifies returned properties (index, area mm², is_planar, centroid, normal). It also provides downstream usage examples, making the purpose unmistakable.

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

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

Explicitly states when to use (list faces) and references specific downstream tools (fusion_create_sketch_on_face, fusion_hole). Lacks explicit exclusions or alternatives but provides clear context.

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

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

Annotations already indicate this is a safe, read-only operation (readOnlyHint=true, destructiveHint=false). The description adds the behavioral detail that features are listed 'in creation order,' which is not covered by annotations. However, it does not specify whether suppressed features are included or what properties are returned.

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 at one sentence, with no wasted words. It is front-loaded with the key action. However, it could be slightly expanded to clarify the output format 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 simplicity of a zero-parameter list tool and no output schema, the description is minimally complete. It states what is listed and the order, but does not mention what fields the returned features contain or if there are any limitations (e.g., only active features). Additional details would improve 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?

There are zero parameters, so the input schema is empty and has 100% coverage. The description does not need to explain parameters. The baseline score for zero-parameter tools is 4, and the description adds no extra meaning beyond the tool's purpose.

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

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

The description clearly states the action ('List'), the resource ('timeline features'), and the ordering ('in creation order'). This distinguishes it from sibling tools like fusion_list_bodies or fusion_list_components, which list 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 implies usage by stating what the tool does, but provides no explicit guidance on when to use it versus alternatives or when not to use it. The context is straightforward, but adding a note about checking feature existence or limitations would improve clarity.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the description's contribution is limited to specifying the returned data (name, type, counts). This adds some behavioral context beyond annotations. However, it does not mention potential side effects, error conditions, or scope (e.g., all joints in document).

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

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

The description is a single, compact sentence that conveys the essential information without any wasted words. It is front-loaded and efficient.

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

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

Given the tool has no parameters and no output schema, the description tells the agent what it will receive (joint names, types, and counts). It is adequate for a simple listing tool. However, it could be improved by specifying the scope (e.g., all joints in the current document) and any limitations.

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

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

The tool has zero parameters, and schema coverage is 100% (empty schema). The description accurately reflects that no parameters are needed. Since no parameter documentation is required, a baseline score of 4 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 it lists joints with their name and type, and also provides counts for as-built-joints and rigid-groups. It identifies the resource (joints) and the specific fields returned. However, it does not explicitly differentiate from sibling tools like fusion_joint (which likely creates/modifies joints) or fusion_rigid_group, though the mention of counts hints at additional 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 given on when to use this tool versus alternatives. Given the presence of sibling tools like fusion_joint, fusion_as_built_joint, and fusion_rigid_group, explicit usage context would help the agent decide correctly. The description only states what it does, not when to use 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 already indicate readOnlyHint=true and openWorldHint=true. The description adds minor context about the fields returned, but does not disclose any additional behavioral traits beyond the annotations.

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

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

Single sentence, front-loaded with verb and resource, no extraneous words. 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 simplicity of a no-parameter list tool, the description is adequate but could be more complete by specifying the scope (e.g., current design or assembly). Lacks details about return format or any constraints.

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?

No parameters exist, so the description does not need to provide parameter details. Baseline for 0 parameters is 4, and the description offers no further parameter info.

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

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

Description clearly states the verb 'List' and resource 'component occurrences', and lists the included fields (name, grounded, visible, body count), making it specific and distinct from sibling list 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?

No guidance on when to use this tool versus the many other list tools (e.g., fusion_list_components, fusion_list_bodies). Usage is implied only by the name and description.

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

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

Annotations already indicate readOnlyHint=true, so transparency is adequate. The description does not add further behavioral context, such as whether an active document is required or how output is formatted.

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, providing all necessary information concisely.

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

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

Given no parameters and no output schema, the description is mostly complete. However, mentioning required context (e.g., an open Fusion document) would improve completeness.

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

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

The input schema has no parameters, so schema description coverage is 100%. The description does not need to add parameter semantics; baseline of 4 applies.

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

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

The description clearly states the tool lists all parameters (user + model) with expression, value, and unit. It uses specific verbs and resource, and distinguishes from sibling tools like fusion_get_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 needing to view all parameters, but provides no explicit guidance on when to use this tool versus alternatives like fusion_get_parameter or fusion_create_parameter.

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, so the description adds value by explaining the tool's role in the save workflow and what 'active' means. It also discloses the connection to fusion_save_document / _as, which is helpful behavioral context not present in 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 concise, grammatically complete, and front-loads the core function. Every word serves a purpose, and the clarification about active project is integrated smoothly.

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, zero-parameter tool with no output schema, the description is complete: it explains the tool's purpose, its relevance to save operations, and the active project concept. No additional information is needed for correct invocation.

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

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

The tool has zero parametersaine the schema is trivial. The description fully covers what the tool does without needing parameter explanations; there is nothing missing in this dimension.

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 lists Fusion projects a document can be saved into and identifies which is active. It uses specific verbs and resources ('project', 'active'), and distinguishes its purpose from related save tools by explaining how it relates to saving.

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 implicitly conveys usage context: to check available projects before saving a never-saved document. It does not explicitly exclude alternatives, but given the zero-parameter nature and clear function, the context is sufficient for an agent to select it appropriately.

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 readOnlyHint=true and destructiveHint=false. The description adds that it returns specific fields but does not disclose further behavioral traits like scope or ordering. Annotations cover the safety profile, so additional context is moderate.

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, concise sentence that directly states the tool's purpose and output. No extraneous 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 parameterless list tool with no output schema, the description adequately specifies what is returned. Minor missing context includes scope (e.g., current document) but is not critical.

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

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

There are zero parameters, so per guidelines the baseline is 4. The description correctly does not add parameter information since none exist.

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 'List', resource 'sketches', and the specific fields returned (index, name, number of closed profiles). It adequately distinguishes from sibling creation 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?

No guidance is provided on when to use this tool vs alternatives, such as when to list sketches vs other listing tools. The agent receives no context for selection.

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

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

Annotations already cover readOnlyHint and destructiveHint, so the description's 'without modifying it' adds little beyond that. It does add the scope of 'active or named component', which is useful context, but it does not describe return format, pagination, or any thread-specific details. The description is adequate but not rich.

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

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

The description is a single, well-structured sentence that front-loads the action ('Inspect thread features') and adds scope efficiently. Every word earns its place with no redundancy or filler.

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

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

For a simple read-only list tool with one optional parameter and annotations covering safety, the description is largely complete. It specifies the scope and the read-only nature, and the lack of an output schema is mitigated by the fact that the operation is inspection. However, it does not describe the structure of the returned thread data, which is a minor gap.

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

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

Schema description coverage is 0%, so the parameter 'component' has no schema description. The description clarifies that 'component' can refer to the active or a named component, giving meaning beyond the raw schema (string or null). However, it doesn't specify the expected format (name, ID, path) or behavior when null, leaving some ambiguity.

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-resource pair: 'Inspect thread features' and adds the scope 'in the active or named component'. This distinguishes it from general feature lists like fusion_list_features and from thread creation (fusion_thread). It doesn't name a specific sibling, but the purpose is unambiguous and not a tautology.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. It implies read-only inspection via 'without modifying it', but does not mention when to use fusion_thread for thread creation or fusion_list_features for a broader feature list. The agent must infer usage from the name and limited 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?

The description adds useful behavioral constraints beyond the sparse annotations: ordering matters, profiles must be closed, and the result is a smooth solid. However, it does not explain the behavior of the operation enum (new/join/cut/intersect) or what happens when a profile is open, leaving some behavioral ambiguity.

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

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

Two short, front-loaded sentences with no filler. The required input rule is stated immediately after the verb, and the additional constraint is separated cleanly.

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

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

The description covers the required parameter and core behavior, but with no output schema it leaves the operation parameter's effects and error/edge-case behavior unspecified. For a modeling operation, this is a meaningful gap.

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

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

Schema description coverage is 0%, so the description carries the burden. It adds real meaning to 'sketches' (indices/names, >=2, in order, closed profiles), but it says nothing about the optional 'operation' parameter beyond its enum values, which the schema already provides.

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

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

The description uses a specific verb and resource: 'Loft a smooth solid between profiles taken from a list of sketch indices/names (>=2), in order.' This clearly differentiates it from other modeling operations like extrude, revolve, or sweep, and states the core input condition.

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

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

It gives clear call context: require at least two sketches, pass them in order, and each sketch must contain one closed profile. It does not explicitly name alternatives or exclusions, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, making the non-destructive nature clear. The description adds that it returns degrees but does not clarify behavior for bodies with no faces or how 'first faces' are determined, leaving some ambiguity.

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

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

The description is very concise with a single sentence, no redundancy. However, it sacrifices detail for brevity, earning a high but not perfect score.

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

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

Given the tool's simplicity and no output schema, the description is somewhat complete for basic understanding but lacks details on parameter types, units, and edge cases. It meets the minimum viable bar.

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

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

The description mentions 'two bodies' but does not explain that body_a and body_b can be integer IDs or string names. With 0% schema description coverage, the description adds minimal value beyond the parameter names.

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

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

The description clearly states the tool measures the angle between the first faces of two bodies, which is a specific verb and resource. It distinguishes itself from sibling tools like fusion_measure_distance by specifying angle rather than distance.

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

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

The description implies usage when an angle measurement is needed, but does not provide explicit guidance on when to use this tool over alternatives (e.g., fusion_measure_distance) or conditions like body face availability.

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, nondestructive, open world. Description adds that it returns distance in millimeters, but lacks details on error handling or return format.

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