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

With no annotations to rely on, the description usefully discloses that the tool neither cancels execution nor undoes changes, and that it unblocks later edits. It also states a precondition (verify Fusion finished). This adds real behavioral context beyond the tool name.

Agents need to know what a tool does to the 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 short, front-loaded with the main purpose, and every sentence contributes useful information. The second paragraph clarifies boundaries and prerequisites without padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 action, timing, and non-destructive nature, which is decent for a simple acknowledgement tool. However, it omits parameter value guidance and any mention of return behavior or error cases, so the agent is left guessing about how to invoke it correctly.

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

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

The schema provides no parameter descriptions and the tool description does not explain what 'resolution' should contain or how 'operation_id' should be obtained. With low schema coverage, the description needed to compensate but did not.

Input schemas describe structure but not intent. Descriptions should explain 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 ('record the outcome') and a clear resource ('uncertain effects' / operation acknowledgement), and explains the effect ('unblock later edits'). It does not explicitly name sibling tools to differentiate from, so it loses one point.

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

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

It gives clear timing guidance: use after inspecting/recovering uncertain effects, and only after verifying Fusion has finished. It does not mention when not to use it or point to alternatives, so it is not a fully explicit distinction.

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

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

With no annotations, the description carries the disclosure burden. It explicitly reveals important safety behaviors: it rejects duplicate IDs and never saves or closes other documents. It does not fully describe response format or error behavior, but the main side-effect boundaries are clearly stated.

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

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

The description is two dense sentences with no filler. The core action is front-loaded, and the constrained behaviors are stated efficiently. Every clause earns its place.

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

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

Given no annotations, no output schema, and three required parameters, the description leaves significant gaps. It does not explain what the response looks like, how operation_id is used, or what happens to the currently active document. An agent would still need to guess about key invocation details.

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

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

Schema description coverage is 0%, and the description does not compensate for any of the three required parameters. It mentions 'by creation ID' but never maps that to target_document_id, and it does not explain current_document_id or operation_id. The parameter names are somewhat self-explanatory, but the description adds little semantic value.

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

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

The description uses a specific verb and resource: 'Activate exactly one already-open document by creation ID.' It also clarifies scope and constraints ('exactly one', 'already-open'), which distinguishes it from tools like fusion_open_archive or fusion_documents. Even without naming a sibling, the action is unambiguous.

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

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

The description implies when to use the tool: when the target document is already open and needs to be activated. However, it does not explicitly state when not to use it or mention alternatives such as fusion_open_archive or fusion_documents. Usage context is present but left to inference.

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

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

With no annotations, the description carries the full burden. 'Inspect' implies a read-only operation, but it does not explicitly state that it has no side effects, nor does it disclose behavior when no active command exists or what the return format is. The description is too sparse for a tool with zero annotation coverage.

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

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

The description is a single, focused sentence that front-loads the action and resource. There is no wasted wording, making it optimally concise.

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

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

For a tool with no parameters and no output schema, the description provides the basic purpose but lacks details on what constitutes an 'active command dialog' in Fusion, what 'current inputs' refers to, and what the response structure will be. It is minimally adequate but leaves room for agent uncertainty.

Complex tools with many parameters or behaviors need more documentation. 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 add any parameter information, but none is needed given there are no parameters to document.

Input schemas describe structure but not intent. Descriptions should explain 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 'inspect' and the specific resource 'active command dialog', along with what is inspected ('current inputs'). It is distinguishable from generic siblings like fusion_inspect because it targets the active command dialog specifically, but it does not explicitly differentiate itself.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 there is an active command dialog to inspect, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. The context of 'active' suggests a prerequisite, but it is not elaborated.

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

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

With no annotations, the description carries the full behavioral burden. It communicates that the search is regex-based, scoped to installed docs, and includes adsk.cam, which is useful. However, it does not state return format, whether output is just matches or full descriptions, or how broad the search is.

Agents need to know what a tool does to the 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 waste. It states the operation, the mechanism, and the important scope qualifier compactly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 three parameters, no parameter schema descriptions, no annotations, and no output schema. The description is too minimal to fully guide correct invocation; it lacks the meaning of category, the role of namespace_filter, and what the returned results contain.

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

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

Schema description coverage is 0%, so the description must compensate, but it only implicitly covers search_pattern via 'regular expression' and namespace_filter via 'including adsk.cam'. The category parameter is completely unmentioned, and no parameter is explicitly explained or mapped to the schema.

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

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

The description clearly identifies a specific action ('Search'), a concrete resource ('installed Fusion API docs'), and a distinguishing mechanism ('by regular expression, including adsk.cam'). This clearly differentiates it from all sibling tools, none of which are documentation-search 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 when to use it: whenever an agent needs to search the installed Fusion API documentation. However, it provides no explicit conditions, exclusions, or comparisons to alternatives, so some inference is required.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies mutation through 'create/add' but does not explain effects on the active document, how 'as-built' joints are resolved, whether changes are reversible, or what the response/error behavior looks like. The optional motion limits are disclosed, but key side effects are not.

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

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

The description is a single compact sentence that front-loads the main actions and optional limits with no filler. Slight awkwardness in 'create/instance' and the unqualified term 'as-built' keep it from being fully polished, but the length and structure are appropriate.

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

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

This is a multi-action assembly tool with nested parameters and no output schema, so the description should explain how to configure each action. The current text is only a high-level summary and leaves geometry, anchor selection, and action-specific behavior undocumented, making it insufficient for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. It does contextualize `motion`, `minimum`, and `maximum` by naming joint types and limits, but it leaves critical fields like `one`, `two`, `origin_token`, `translation_mm`, `component`, `source`, `axis`, and `allow_shared_definition_edit` unexplained.

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

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

The description states specific operations: create/instance components and add rigid, revolute, or slider as-built joints with optional motion limits. This is enough to distinguish it from inspection-focused siblings like fusion_assembly_tree or fusion_component_context, though 'create/instance' is slightly compressed and the assembly context is 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?

There is no guidance on when to use this tool versus alternatives such as fusion_create_feature or fusion_component_context. No prerequisites, exclusions, or selection conditions are provided, so the agent must infer usage from the action enum and sibling names.

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

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

With no annotations supplied, the description carries the full behavioral disclosure burden. The verb 'Read' clearly implies a non-mutating operation, but the description does not disclose pagination behavior, error conditions, or any side effects beyond being a read. It is helpful but 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?

One single, direct sentence that front-loads the action and lists the key outputs with no filler or redundant words. It earns its place and is 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?

The description names the primary return content but not the overall shape, pagination implications, or how limit/offset affect the tree. Since there is no output schema and no annotations, the one-liner leaves important operational details unstated, though it covers the semantic core.

Complex tools with many parameters or behaviors need more documentation. 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% property description coverage, and the description does not explain document_id, limit, or offset. It only describes the assembly-tree semantics of the read, leaving the agent to guess how paging and document selection interact with the returned tree.

Input schemas describe structure but not intent. Descriptions should explain 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 as read-oriented and names exact outputs: nested occurrence paths, component definitions, repeated-instance counts, and external-link flags. This separates it from siblings like fusion_bom or fusion_model_overview in intent, though it does not explicitly call out those alternatives.

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

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

No guidance is provided about when to prefer this tool over related siblings such as fusion_assembly or fusion_bom, nor are there any listed exclusions, prerequisites, or alternate conditions. The agent must infer when this is the correct read 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 states the operation is 'Return', which implies a read-only behavior, and 'flattened' reveals that it flattens the BOM hierarchy. However, with no annotations available, the description does not disclose whether there are any side effects, permissions, error conditions, or output format expectations beyond its terse statement.

Agents need to know what a tool does to the 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 one short sentence that front-loads the primary function and adds no redundancy. 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 low-complexity tool with a single parameter, the description covers the core function ('flattened BoM') but leaves gaps: there is no mention of whether the document must be an assembly, whether occurrence quantities are calculated at the top level or including nested, or what the return object looks like (especially since 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?

schema_description_coverage is 0%, but the description still adds no meaning to the only parameter, document_id. While 'document_id' is a self-explanatory name, the description could have said what kind of document (Fusion design, assembly) or how to obtain the ID, but it does not.

Input schemas describe structure but not intent. Descriptions should explain 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 'Return' and a specific resource ('flattened component bill of materials and occurrence quantities'). The phrase clearly indicates the tool provides BoM data, though it doesn't explicitly distinguish it from siblings like fusion_assembly or fusion_assembly_tree.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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. The description does not mention any prerequisites, conditions, or references to sibling tools, leaving the agent to infer usage from the name and basic semantics.

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

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

No annotations are provided, so the description carries full burden. It implies a non-destructive read operation but does not state it explicitly, nor does it mention side effects, permissions, or what the response contains. The description is too terse to disclose behavioral traits beyond the literal 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 a single sentence with no filler, front-loaded with the core purpose. It is highly efficient and well-structured, even though brevity sacrifices completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 3 parameters, no annotations, and no output schema, yet the description only clarifies part of the url behavior. document_id and the exact meaning of 'kind' beyond the enum are unaddressed, and the return format is unknown. An agent would need to infer or guess important details, making the definition 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 description coverage is 0%, so the description must compensate. It implicitly explains 'kind' via 'tool/post' and 'url' via the omit instruction, but document_id is left completely unexplained. With 3 parameters and no schema descriptions, the partial hints are insufficient for an agent to construct a correct call.

Input schemas describe structure but not intent. Descriptions should explain 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 'browse' and the resource 'tool/post library folders and asset URLs', and adds a specific behavior for the root. It doesn't explicitly differentiate from sibling tools like fusion_cam_tools or fusion_cam_inventory, but the purpose is specific enough to be distinct.

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

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

The description offers one usage tip for the optional url parameter (omit for root), but provides no guidance on when to choose this tool over its CAM siblings, prerequisites like document activation, or typical usage scenarios. There is no mention of alternatives or exclusions.

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

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

With no annotations provided, the description carries the full burden and it does disclose two real behavioral facts: the tool is 'Experimental, not yet live-validated' and produces an empty output folder without post-processing. These exceed what the schema conveys. However, it does not disclose authorization needs, side effects, or what the return looks like, leaving gaps for a mutation-style tool with zero annotation coverage.

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

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

It is compact — a single sentence with essentially no wasted words, and the safety-relevant 'Experimental' warning is front-loaded. But it is under-specified rather than merely concise; a structured split between purpose and limitations (e.g., a separate note on the empty output / pending post-process) would serve an agent better without adding bulk.

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

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

Given 3 required top-level parameters plus a nested spec with 5 fields, no descriptions in the schema, and no output schema, the description is materially incomplete. It does not explain that NC program creation follows an existing CAM workflow, nor what document_id/operation_id refer to, nor what the agent should expect in response. For an experimental tool this ambiguity is risky.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It fails to do so — only a passing reference to 'chosen post' and 'empty output folder' hints at post_url and output_folder. The critical parameters operation_ids, document_id, operation_id, and the filename pattern (^[A-Za-z0-9_-]+$) are left entirely unexplained.

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

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

States a specific verb ('prepare') and resource (NC program) with a chosen post and empty output folder. It distinguishes from the sibling fusion_cam_post_process by explicitly noting 'does not post-process yet'. The verb 'prepare' is slightly vague versus 'create', but the scope is adequately conveyed.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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. The phrase 'does not post-process yet' implicitly hints that post-processing is a separate later step, but the description never names fusion_cam_post_process or any other sibling, nor states when this tool is preferred over fusion_cam_create_setup or fusion_cam_create_operation.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool creates a CAM operation, requires an explicitly selected tool, and that toolpath generation is separate. It also notes that unknown expression names are rejected (in the schema, not the description). However, it doesn't disclose side effects like whether the operation is persisted, whether it modifies the document immediately, or whether it requires an active document. The description adds some behavioral context but not comprehensive.

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

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

The description is two sentences, front-loaded with the primary action and key constraints. The second sentence adds an important caveat about toolpath generation. No wasted words, but it could be slightly more informative 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?

This is a complex CAM operation creation tool with 3 required parameters, one of which is a nested object with 7 properties. There is no output schema, no annotations, and 0% schema description coverage. The description doesn't explain the operation_id semantics, the relationship to setups, or what happens after creation. An agent would need to open the schema and infer a lot. The description is not complete enough for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. The description mentions 'explicitly selected tool' and 'parameter expressions', which maps to tool_library_url, tool_index, tool_fingerprint, and expressions. However, it doesn't explain document_id, operation_id, setup_id, strategy, or name. The schema has some descriptions for strategy and expressions, but the top-level description adds little beyond those. With 0% coverage, the description should do more to explain the parameters.

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

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

The description states a specific verb ('Create') and resource ('CAM operation') and adds key constraints: explicitly selected tool and parameter expressions. It distinguishes itself from sibling tools like fusion_cam_create_setup and fusion_cam_generate, though it doesn't explicitly name them. The phrase 'Valid toolpaths must be generated and checked separately' clarifies that this tool only creates the operation, not the toolpath.

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

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

The description implies when to use this tool: when creating a CAM operation with an explicitly selected tool and parameter expressions. It also implies that toolpath generation is a separate step (use fusion_cam_generate). However, it doesn't explicitly state when not to use it or name alternatives like fusion_cam_create_setup or fusion_cam_parameters. The guidance is clear enough for an agent to infer the primary use case but lacks explicit exclusions.

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

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

With no annotations, the description carries full burden. It discloses two meaningful traits: it activates the Manufacture workspace and does not auto-select machine/fixtures. However, it omits side effects on existing setups, prerequisites, and failure/error behavior, so transparency is partial.

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

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

Two tightly written sentences with no filler. The primary action is front-loaded, and the second sentence delivers the most important caveat. 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 description covers the core workflow start (activation) and a key limitation (no machine/fixtures), but leaves operation_id unexplained, does not state prerequisites like an active design document or CAM availability, and gives no return/validation expectations. With no output schema, this gap is noticeable.

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

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

Schema description coverage is 0%, so the description must compensate. It adds high-level mapping hints: 'relative-box stock' relates to top_stock/side_stock and 'box-point WCS origin' relates to the origin enum. Yet it does not explain document_id, operation_id, or how spec fields should be populated, leaving the agent to rely on self-explanatory names.

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

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

States a specific action ('create a milling setup') with precise stock and WCS details ('relative-box stock', 'box-point WCS origin') and confirms workspace activation. This clearly distinguishes it from sibling fusion_cam_create_operation, which targets operations, not 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?

The description implies the CAM workflow context ('Activate Manufacture') but never explicitly says when to use this tool instead of fusion_cam_create_operation or other CAM siblings. No exclusions or alternative routing are provided; the machine/fixtures caveat is more of a behavioral note than usage direction.

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

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

With no annotations present, the description carries the burden of disclosing behavior. It clearly states the operation is asynchronous, returns a job ID, and should be polled rather than re-invoked. It does not mention side effects on the document or auth requirements, but the core execution model is well covered.

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

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

The description is compact, front-loaded, and contains no filler. Every sentence adds operational value: what it starts, what it returns, how to monitor it, and what not to do.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 asynchronous start-job tool, the description gives enough context to invoke it correctly: job creation, polling target, and timeout behavior. It does not cover error handling or the exact role of each parameter, but the core workflow is well specified.

Complex tools with many parameters or behaviors need more documentation. 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 adds no explanation for document_id, operation_id, or cam_operation_ids. The names are somewhat self-explanatory, but the distinction between the singular operation_id and the plural cam_operation_ids is not clarified, leaving meaningful 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 uses a specific verb and resource: "Start asynchronous toolpath generation" and "return a job ID." It clearly distinguishes this tool from sibling fusion_cam_job by telling the agent to poll that tool, making its role 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?

It gives explicit workflow guidance: start the job, poll fusion_cam_job, and do not resubmit on timeout. This is action-oriented instruction that prevents a common misuse pattern (retrying a long-running job).

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 are null, so the description carries the full burden of behavioral disclosure. It only lists what is read (setups, operations, errors, toolpath validity, NC programs) but does not state whether this is a safe, non-mutating operation (though the verb 'Read' implies it), nor does it discuss limitations, return format, or any side effects. The lack of output schema and annotations leaves the agent uninformed about the tool's behavior beyond the surface.

Agents need to know what a tool does to the 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 primary purpose. It is efficient with no fluff. However, it is slightly telegraphic; the list of items is clear but could use a brief note on context or 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?

Given the large sibling set with many CAM tools, the description is incomplete. It does not explain the scope of the inventory (e.g., all setups in the document?), nor does it clarify how it differs from fusion_cam_tools or fusion_cam_parameters. For a read tool with no annotations and no output schema, more context is needed to help an agent decide when to call it and what to expect in return.

Complex tools with many parameters or behaviors need more documentation. 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 is only one parameter, document_id, and the schema provides no description beyond the name. The description does not add any detail about the parameter's meaning or format. With 0% schema coverage.boot, the description could have elaborated on what document_id refers to (e.g., a Fusion 360 document ID) but does not. A neutral score is given because the parameter is self-explanatory (it's a document identifier), but the description adds no extra value.

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

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

The description states a specific verb ('Read') and a clear resource ('CAM setups, operations, errors, toolpath validity and NC programs'). It clearly indicates a read operation on CAM inventory data. However, it does not explicitly distinguish from the many other CAM sibling tools like fusion_cam_tools or fusion_cam_parameters, which could overlap in scope.

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

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

The description gives no guidance on when to use this tool versus its many CAM siblings. It does not mention alternatives or conditions for selection, leaving the agent to infer that this is a comprehensive read tool. The sibling list includes several CAM-specific tools, but no exclusions or comparisons are provided.

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

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

With no annotations present, the description carries the behavioral burden. It adds meaningful traits: the tool is non-blocking ('without blocking Fusion's main thread') and job state can become stale ('Jobs become unknown after a Fusion restart'). These go beyond what the schema or annotations reveal.

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

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

Two short sentences deliver the core purpose, the non-blocking behavior, and a key lifecycle caveat. There is no filler, and the most important information is front-loaded.

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

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

The description gives enough to understand the tool's role and call it with the two required IDs, but it does not describe the return format, how to handle unknown jobs after restart, or how it relates to the CAM generation flow. Some inference is still required.

Complex tools with many parameters or behaviors need more documentation. 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 does not explicitly explain document_id or job_id. However, the parameter names are self-explanatory, and 'Jobs become unknown after a Fusion restart' adds a useful note about job_id validity beyond the raw schema.

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

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

The description clearly identifies the action ('Poll generation completion and toolpath validity') and the resource (a Fusion CAM job). It is specific enough to convey the tool's role, though it does not explicitly distinguish itself from related siblings like fusion_cam_generate or fusion_operation_status.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'Poll generation completion' implies that the tool is meant to check the status of a CAM generation job, likely after calling a generation-related sibling. However, it does not explicitly say when to use this tool versus alternatives, nor does it provide exclusions or name a preferred sibling for other 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?

There are no annotations, so the description carries the behavioral disclosure burden. 'Inspect' clearly signals a read-only operation, and 'names and expressions' indicates what the tool surfaces. However, it does not mention side effects, prerequisites, potential errors, or return shape, leaving some behavioral context implicit.

Agents need to know what a tool does to the 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 uses nine words to convey action, resource, and scope with no filler. Every word earns its place, and the structure is easy to parse quickly.

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

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

With no annotations and no output schema, the description is the only context for correct invocation. It explains the core purpose but omits how the setup flag routes to an operation versus a setup, what the returned names-and-expressions mapping looks like, and any prerequisites. This leaves meaningful gaps for a 3-parameter tool.

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

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

Schema description coverage is 0%, and there are 3 parameters, so the description needed to compensate. It only hints at the 'setup' boolean by saying 'operation or setup,' while document_id and cam_id remain semantically unexplained. This is insufficient for confident parameter construction.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Inspect') and a specific resource ('installed CAM parameter names and expressions') scoped to 'an operation or setup.' This clearly distinguishes it from mutation-focused siblings like fusion_set_parameter and from library-level tools like fusion_cam_inventory.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention fusion_set_parameter for editing parameters, fusion_cam_inventory for inventory-level data, or any when-not-to-use condition. The phrase 'operation or setup' only scopes the target; it does not explain tool selection.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is experimental and writes to an output folder, but it does not state whether it modifies the document, whether it is destructive, whether it requires prior generation, or what happens if the output folder is not empty. The warning to inspect results is useful but vague.

Agents need to know what a tool does to the 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 short and front-loaded with the experimental warning, but the second sentence is generic and adds little. It earns a middle score because it is compact, though not optimally informative.

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

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

For a 3-required-parameter tool with no annotations and no output schema, the description is incomplete. It does not explain prerequisites, side effects, expected outputs, or how to interpret the result. The experimental warning is the only contextual signal.

Complex tools with many parameters or behaviors need more documentation. 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 does not explain any of the three required parameters (document_id, operation_id, program_id). The agent must guess what 'operation_id' and 'program_id' refer to and how they relate to the post-processing step.

Input schemas describe structure but not intent. Descriptions should explain 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 says 'post-process the explicitly configured NC program to its empty output folder' which names a verb and resource, but the opening 'Experimental, not yet live-validated' and the vague 'Inspect results and machine/post suitability before machining' muddy what the tool actually does. It does not clearly distinguish from siblings like fusion_cam_generate or fusion_cam_create_nc_program.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 a workflow step ('before machining') but gives no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or explain how this differs from fusion_cam_generate or fusion_cam_job.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses a read action and the fingerprint-based change detection, which suggests a non-mutating inspection tool. It does not explain how fingerprints work, what triggers a change warning, or what happens when a change is detected, leaving some behavior unexplained.

Agents need to know what a tool does to the 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 filler. It is front-loaded with the main verb and resource, but the cryptic 'fingerprints' term could be explained more for the same word count.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four parameters, no output schema, and no annotations, this description is too minimal for an agent to invoke the tool confidently. It omits parameter semantics, result shape, and practical workflow details, so it only partially covers the context needed for correct use.

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

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

Schema description coverage is 0%, and the description adds no meaning to any of the four parameters. It does not mention document_id, library_url, limit, or offset, so an agent cannot determine how to populate these parameters from the description alone.

Input schemas describe structure but not intent. Descriptions should explain 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 reads tool definitions and uses fingerprints to detect changes between selection and use. It names a specific resource and purpose, which is enough to distinguish it from inventory, browsing, and other CAM utility tools, though it does not explicitly compare itself with any sibling.

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

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

The phrase 'between selection and use' implies the intended moment to call this tool and hints at a workflow purpose. However, it does not explicitly state when not to use it or point to alternatives, so the guidance remains inferred rather than 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?

With no annotations, the description bears the burden of behavioral disclosure. 'Discover' implies a read-only introspection operation with no mutation, which is useful. Still, the description does not state whether it requires authentication, whether output is cached/stale, or whether it reflects a live scan of the running system.

Agents need to know what a tool does to the 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-formed sentence that is perfectly sized for a zero-parameter introspection tool. Every word earns its place, and the key phrase 'native tool schemas' is front-loaded.

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

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

For a tool with no parameters and no output schema, the description is nearly complete: it tells the agent what the tool does and what it returns conceptually (tool schemas). It could add a note about the returned data being a mapping or list, but that is not essential 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?

There are zero parameters and the schema coverage is 100%, so the schema fully documents the call signature. The description adds no parameter detail, but none is needed; the baseline of 4 applies for a no-parameter 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 states a specific verb ('Discover') and resource ('native tool schemas') with the context of the running Fusion installation. It is clearly an introspection/capability tool, though it does not explicitly differentiate itself from the similarly-named fusion_api_docs sibling.

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

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

The usage context is implied: an agent would call this when it needs to know what tool schemas are available at runtime. However, there is no explicit 'when to use' guidance, no mention of alternatives, and no exclusions, so the routing decision is left to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions one exclusion (coincident faces) but does not disclose whether this is a read-only analysis, what it returns, how it handles errors, or any side effects. The minimal detail leaves the agent guessing about the tool's runtime behavior.

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

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

The description is a single concise sentence with no wasted words. It is appropriately front-loaded with the core purpose and the key exclusion, achieving clarity through brevity.

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

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

For a tool with no output schema and no annotations, the description is severely incomplete. It lacks information about return values, possible errors, what happens when entities are invalid, or how the interference results are presented. An agent cannot confidently call this tool based solely on the description and schema, as the required parameters are only minimally explained.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It hints that 'entities' refers to bodies/occurrences, which adds some semantic value, but it does not explain the format, expected values, or how document_id is used. The description is insufficient to fully understand the parameters.

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

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

The description states a specific verb (Analyze) and resource (interference between explicit bodies/occurrences) with a distinguishing qualifier (excluding coincident faces). It is clear about the tool's function, though it does not explicitly contrast with sibling tools like fusion_validate_design.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, when not to use it, or what distinguishes it from other analysis tools. The description only states what it does without any 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?

With no annotations available, the description must carry the behavioral burden itself. 'Inspect' implies read-only, and the listed outputs clarify what the caller gets backcher. However, it does not explicitly state that no mutations occur, nor does it warn about potentially large result sets from traversing all affected occurrence paths.

Agents need to know what a tool does to the 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 dense, front-loaded sentence communicates the action, the target, and the scope of returned information without repetition 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 two-parameter inspection tool, the description gives a good high-level picture and a list of returned context categories热的, but it does not describe the return shape, failure modes, or whether the operation can be expensive. It is adequate but 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?

The input schema has no parameter descriptions (0% coverage). The description mentions 'occurrence paths' as an output, which loosely connects to the occurrence_path parameter, but it does not explain how document_id or occurrence_path should be formatted, what they refer to, or how they interact. The description does not compensate for missing parameter docs.

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

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

The description uses a specific action ('Inspect') with a clear resource ('an existing component') and enumerates the exact kinds of context returned: native/proxy geometry, model parameters, feature origins, state fingerprint, and affected occurrence paths. This strongly distinguishes its purpose even without naming siblings.

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

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

The description gives no explicit guidance on when to use this tool versus siblings like fusion_model_overview, fusion_query_entities, or fusion_edit_component_parameters. It also omits prerequisites or exclusion criteria. 'Existing component' is the only implicit usage signal.

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

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

With no annotations provided, the description carries full behavioral disclosure. It explicitly warns that 'Geometry may be adjusted,' which is a key side-effect, and notes that the tool reports whether the sketch became fully constrained. This goes beyond the bare operation name.

Agents need to know what a tool does to the 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 long, front-loads the core operation, and every sentence adds useful information. There is no filler or redundant restating of the tool name.

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

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

For a mutating tool with four parameters, no output schema, and no annotations, this short description leaves significant gaps around parameter values, operation mechanics, and potential failure modes. It covers the core purpose but not enough context for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It does not explain document_id, operation_id, sketch_token, or allow_shared_definition_edit; only the vague notion of an 'existing sketch' is present.

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

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

The description names a specific verb ('Apply Fusion AutoConstrain'), a specific resource ('an existing sketch'), and a concrete outcome ('report whether it became fully constrained'). This clearly distinguishes it from sibling tools like fusion_create_sketch or fusion_create_feature.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'an existing sketch' implies the tool is used on sketches that already exist, which provides some usage context. However, it never explicitly states when to use this tool versus alternatives or 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?

No annotations are provided, so the description carries the transparency burden. It discloses that the tool is experimental, not yet live-validated, requires a specific API, and may start a cloud job. It does not explain what the agent should expect afterward, such as return values or how to track the started job.

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

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

The description is compact and front-loaded with the important experimental warning and main action. Each sentence adds necessary information without filler or repetition.

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

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

For a tool with no output schema and no annotations, the description provides a reasonable but incomplete picture: it has a prerequisite, a caveat, and a side effect. It does not clarify how output/status is returned, how operation_id relates to the cloud job, or whether the call is asynchronous.

Complex tools with many parameters or behaviors need more documentation. 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 understanding. It adds meaning by mapping the specification to standard, sheet, and auto-dimensions, which correspond to fields in the DrawingSpec object. However, document_id and operation_id remain unexplained, and the units field is omitted.

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

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

The description names a specific verb and resource: create an automatic cloud drawing from an already saved design. It also adds meaningful scope—configurable standard, sheet, and auto-dimensions—which clearly differentiates it from sibling tools like fusion_create_sketch or fusion_screenshot.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 preconditions: the design must already be saved and the Drawing API must be installed. It also warns that the tool may start a cloud job, but it does not explicitly name alternatives or state 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the need to query entity tokens beforehand and to inspect feature health afterward, which implies the tool depends on prior queries and may produce unhealthy results. However, it does not disclose side effects like whether bodies are modified destructively, whether operation is reversible, or what happens on failure. This is partial transparency – enough to hint at workflow but not a complete safety profile.

Agents need to know what a tool does to the 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 three concise sentences with no fluff. It front-loads the core purpose, then gives essential usage tips in a logical order (prerequisite, then post-check). Every sentence earns its place, and the structure is easy to parse.

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

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

Given the tool's complexity – 14+ parameters across 10 feature kinds, no output schema, and no annotations – the description is inadequate. It omits how to specify feature parameters (e.g., valid 'kind' values, units for distance/angle, how operation affects existing geometry). An agent would struggle to call this correctly without additional knowledge not present in the schema or 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?

The schema coverage is 0% for top-level parameters and only has a description for 'entities'. The description adds meaning to 'entities' (query tokens) and 'component' (owning component), but the many other parameters (distance, angle, operation, axis, etc.) are left entirely to the schema, which has no descriptions beyond enums. The description does not compensate for the missing schema documentation, leaving most parameters ambiguous for the agent.

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

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

The description opens with 'Create extrude/revolve/sweep/loft, fillet/chamfer/shell, booleans, or patterns', which clearly states the tool's purpose – creating a broad range of features. This verb-resource pair distinguishes it from siblings like fusion_create_sketch or fusion_create_holes, and the enumeration of feature types leaves no ambiguity about what it does.

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

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

The description gives explicit workflow guidance: 'Query entity tokens first; supply their owning component' and 'Inspect feature health after edits'. This tells the agent when and how to use the tool, including prerequisites and post-conditions. It does not explicitly name alternative tools or exclusion conditions, but the guidance is actionable and context-specific.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state that this is a mutating operation, that it requires an active document and operation context, that it may fail if the sketch points are invalid, or that it creates a feature in the parametric history. The description adds minimal behavioral context beyond the name and schema.

Agents need to know what a tool does to the 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 short sentence, which is concise, but it is under-specified. It front-loads the core action but omits essential context. It is not verbose, but it does not earn its place because it fails to convey the tool's role in the broader workflow.

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

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

Given the tool's complexity (3 required parameters, nested spec object, 0% schema coverage, no output schema, no annotations), the description is incomplete. An agent would not know how to obtain the required 'points' tokens, what 'operation_id' refers to, or what the tool returns. The sibling tools like fusion_query_entities and fusion_create_feature suggest a workflow, but the description does not connect to them.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It does not explain what 'points' means beyond the schema's 'SketchPoint tokens returned by an entity query,' nor does it clarify the meaning of 'diameter', 'depth', 'component', or 'allow_shared_definition_edit'. The description adds almost no parameter-level meaning.

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

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

The description 'Create depth-limited simple holes at selected sketch points.' identifies a verb ('Create') and a resource ('holes at selected sketch points'), but it is vague about the exact behavior: it does not specify that this is a Fusion 360 feature creation operation, nor does it distinguish itself from the sibling fusion_create_feature. The phrase 'depth-limited simple holes' is ambiguous and could be confused with other hole-related operations, and the description does not clarify the relationship to the operation_id/document_id parameters.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 that it should be used after creating a sketch and querying entities, nor does it explain when to prefer fusion_create_feature or fusion_create_sketch. The only implicit hint is 'at selected sketch points,' but there is no explicit when-to-use 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?

With no annotations provided, the description must carry the transparency burden. It discloses that the tool performs a creation, enforces full constraint, places the shape at the component origin, and returns profile references. It does not mention side effects, permission requirements, or asynchronous operation behavior, but the core behavior is transparent.

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

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

The entire description is one tightly scoped sentence plus a brief return-value note. It is front-loaded with the core action and contains no redundant words or filler.

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

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

The schema covers shape, plane, dimensions, and defaults, while the description covers behavior and return value. The absence of annotations and output schema leaves minor gaps around operation_id semantics and explicit alternatives, but for a simple sketch-creation tool the definition is substantially complete.

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

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

The schema already documents key parameter meanings, such as width being rectangle width or circle diameter, and plane/offset defaults. The description adds the 'dimension-driven' and 'component origin' context, which helps interpret width/height/plane. However, top-level parameters document_id and operation_id have no schema descriptions and the description does not compensate for those.

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

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

The description names a specific verb and resource: 'Create a dimension-driven rectangle or circle at the component origin'. It also conveys a key behavioral requirement, 'require full constraint', and states the return value, 'Returns profile references'. This clearly differentiates the tool from siblings like fusion_constrain_sketch or fusion_create_feature.

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

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

The description gives clear context for when this tool is appropriate: when a basic dimension-driven rectangle or circle is needed at the component origin with full constraint. It does not explicitly name alternatives or say when not to use this tool, 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?

No annotations are provided, so the description must convey behavior itself. 'List open documents' clearly implies a read-only operationaine and specifying 'creation IDs' tells the agent what output to expect. It doesn't mention edge cases like empty responses, but for a zero-parameter listing tool this is reasonable.

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

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

A single front-loaded sentence states the action ('List open documents') and the purpose ('with creation IDs for explicit activation and edit targeting') without filler. Nothing needs to be reworded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, parameterless listing tool with no output schema, the description is complete enough: it states what is listed, what the returned identifiers are for, and how the result should be used downstream. It does not document output format, but that is not necessary at this level of complexity.

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

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

The tool has zero parameters and the schema is empty, so there is no parameter information for the description to supplement. The baseline for zero-parameter tools applies; the description adds no parameter confusion.

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

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

Uses a specific verb ('List') with a specific resource ('open documents') and explicitly states the output purpose (creation IDs for activation and edit targeting), which differentiates it from sibling tools like fusion_activate_document and fusion_open_archive.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicit activation and edit targeting' gives a clear trigger condition for when to call this tool. It does not explicitly exclude alternatives such as fusion_open_archive, but the context is clear enough 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?

Given that no annotations are provided, the description carries full responsibility for behavioral disclosure. It explicitly states rejection of stale state, foreign parameters, external links, and unacknowledged repeated instances, and mentions recomputation and error checks, plus returning before/after states. This is thorough for a mutation tool, though it does not cover authorization or rollback details.

Agents need to know what a tool does to the 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, front-loading the purpose with 'Edit only the selected component's existing model parameters,' then adding constraints and consequences in a few sentences. Every sentence adds value and there is no redundant information.

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

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

The description covers behavioral aspects and return states, but omits parameter semantics and detailed return structure. Given the complexity of the nested spec and lack of output schema, more guidance on how to formulate the spec and what the before/after states look like would improve completeness. It is adequate but not complete.

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

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

The description makes no reference to any of the input parameters, despite schema description coverage being 0%. It does not explain path, expected_component, expected_fingerprint, expressions, or allow_shared_definition_edit. The schema itself has descriptions, but the tool description fails to add meaning or tie them together, leaving the agent to rely on schema alone.

Input schemas describe structure but not intent. Descriptions should explain 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 edits only the selected component's existing model parameters, using a specific verb and resource. It also distinguishes from siblings by emphasizing 'only' and 'existing', and lists rejection criteria, 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 description provides context on what the tool does but does not explicitly state when to use it versus alternatives like fusion_set_parameter. It implies that it is for editing component parameters with strict validation, but no direct comparison or exclusion is given.

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

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

With no annotations provided, the description carries the full burden. It discloses that exceptions may leave partial changes, that 'succeeded' only means the script returned without verification, that script code is trusted local code not sandboxed, and that explicit units are required. These are critical behavioral traits that fully inform an agent of the risks and 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?

The description is compact but information-dense, with the core purpose first, followed by essential caveats and requirements. Every sentence adds value—no filler or redundancy. The line breaks contribute to scannability without excessive 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 tool that executes arbitrary Python code with potential side effects, the description covers the critical aspects: prerequisite document id and operation_id, idempotency semantics, partial-change behavior, interpretation of 'succeeded', security implications, and unit guidance. Given the lack of an output schema and annotations, this is remarkably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains operation_id (unique for mutations, repeatable for retrieval) and expected_document_id (implied as the document id from fusion_inspect). It also gives guidance for the script parameter via 'Use explicit units'. read_only is not directly explained, but the mutation context strongly implies its role. The description adds meaningful meaning beyond the schema.

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

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

The description clearly states the verb 'Run' and the resource 'Python defining run(context) inside Fusion', with the additional scope of supporting all installed API namespaces. This is specific and distinct from sibling tools like fusion_create_feature or fusion_set_parameter, which target specific operations rather than arbitrary script execution.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context: mutations require a document id from fusion_inspect and a unique operation_id, and repeating an id retrieves the prior result. It also warns that success does not imply geometry correctness. While it does not explicitly contrast with alternative tools or state when not to use it, the conditions for mutations and the idempotency pattern are clear enough for an agent to decide.

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

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

Since no annotations are provided, the description must carry the full behavioral burden. It does disclose one meaningful trait: 'Existing destinations are rejected,' indicating a fail-if-exists behavior rather than overwrite. However, it doesn't state what happens on success (return value, output), whether the parent directory must exist, error handling, or permission requirements. Useful but incomplete.

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

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

Two tightly packed sentences with zero filler. Every clause earns its place: the format list, the path requirement, and the rejection behavior. The key scoping constraints are front-loaded before any detail an agent would only skim.

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

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

For a 3-parameter export tool with no annotations and no output schema, the description covers format selection and path requirements reasonably well. The main gap is the unexplained 'entity' parameter, which is likely essential for format-specific exports like DXF (choosing which sketch) or BOM (which component). That gap leaves an agent guessing on a required detail of the operation.

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

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

With 0% schema description coverage, the description must compensate for the schema. It does add meaning beyond the raw enum by expanding the format codes into readable names (e.g., 'f3d' → 'F3D archive') and by specifying that path must be 'a new absolute path.' However, the 'entity' parameter is not mentioned at all — an agent has no idea what entity refers to (likely the specific sketch for DXF or component to export) — and the description doesn't clarify which formats require an entity.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Export'), the exact resources (STEP, STL, F3D archive, sketch DXF, BOM JSON), and a critical constraint (new absolute path, existing destinations rejected). This clearly separates it from siblings like fusion_screenshot, fusion_bom, and the CAM tools — an agent can immediately identify this as the file-export operation.

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

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

No guidance on when to use this tool versus alternatives. For example, an agent wanting BOM data has both fusion_bom and fusion_export with bom_json format available, but the description doesn't explain which to choose or in what scenario. The only usage hint is the rejection of existing destinations, which is a constraint rather than a when-to-use directive.

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

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

With no annotations, the description carries the full burden. It states 'Read' which implies non-destructive behavior, but does not disclose potential errors (e.g., no active document), response format, or performance characteristics. Key behavioral context is missing.

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

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

A single, information-dense sentence accurately summarizes the tool's purpose. Every phrase adds value—no fluff, no redundancy. The most important action ('Read') is front-loaded.

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

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

For a simple zero-parameter inspection tool, the description covers the core scope but omits important context such as output format, prerequisites (active document existence), and potential failure modes. Given the large sibling set with overlapping functions, some usage guidance would improve completeness, though it remains minimally adequate.

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

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

The tool has zero parameters and the schema is empty, so there is nothing to document. The description adds context about what data is read, which aligns with the schema's emptiness. Per guidelines, 0 params yields a baseline of 4, and the description adds no contradictory information.

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

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

The description clearly states a read operation on the active document, enumerating specific data groups (identity, design counts, parameters, feature health, CAM counts). It distinguishes itself from siblings like fusion_cam_inventory and fusion_model_overview by the breadth of data listed, but does not explicitly name them as alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives like fusion_model_overview or fusion_cam_inventory. The description merely implies general inspection but does not state conditions, exclusions, or how it compares to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly signals a read-only, non-destructive operation and hints that large designs may be expensive by recommending paginated queries. However, it does not describe response shape, limits, or potential errors, so it only partially discloses behavior.

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

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

Two sentences with no filler: the first front-loads the tool's scope, and the second provides a practical usage caveat. Every word contributes value, making it an appropriately sized description.

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

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

For a single-parameter, read-only overview tool with no output schema, the description covers what data is returned and warns about large designs. It does not explain return formatting or error behavior, but these are relatively minor given the simple input and the provided usage guidance.

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

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

Schema description coverage is 0%, and the description adds no meaning to document_id beyond the schema's 'Document Id' title. The single parameter is fairly self-explanatory, but the description does not compensate for the missing schema documentation.

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

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

The description opens with a strong, specific verb ('Read') and lists four concrete content areas: parameter expressions, timeline, feature diagnostics, and component structure. This clearly distinguishes it from siblings like fusion_inspect and fusion_query_entities, and the final sentence reinforces the 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?

The description explicitly advises preferring paginated entity queries for large designs, giving an actionable alternative condition. It does not spell out a broader when-to-use policy, but the enumerated contents imply the appropriate use case clearly 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?

With no annotations, the description is the only source of behavioral information. It discloses important traits: the design is separate and unsaved, and the default mode requires no active document. However, it omits side effects on any current design, persistence expectations, and the role of the required operation_id.

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

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

Two tight sentences with no filler. The primary function is front-loaded, and the document-context condition is stated immediately after. Every sentence adds 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 three-parameter tool with no annotations and no output schema, the description is incomplete: the required operation_id is entirely unexplained, and name is ignored. An agent would need extra reasoning or external knowledge to invoke this correctly, especially for the required parameter.

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

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

Schema description coverage is 0%, so the description must compensate for all parameters. It explains expected_document_id ('current document ID' and default requirement) but says nothing about the required operation_id or the name parameter, leaving the most important required parameter unexplained.

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

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

States a specific verb ('Create') and resource ('separate unsaved design'), which clearly conveys the tool's core function. It is distinguishable from siblings like fusion_create_sketch or fusion_create_feature because it targets a new design document rather than a feature within one. It does not explicitly contrast with siblings, so it misses a top score.

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

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

Provides clear context for the two invocation scenarios: supply the current document ID if one is open, otherwise rely on the default which requires no open active document. It does not mention exclusions or alternative tools, but the guidance is enough for a straightforward creation action.

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

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

With no annotations, the description carries full responsibility. It discloses a key behavior: 'preserve other open documents' explicitly states it does not close others. The caution about reinspecting document identity hints at potential state changes. Yet it omits details like side effects, error handling, or whether the operation is read-only vs mutating, leaving gaps for an agent relying solely on the description.

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

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

Two sentences, front-loaded with the primary action, followed by a concise caution. No wasted words, and the structure leads with the most critical 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 file-opening operation with 3 parameters, no output schema, and no annotations, the description leaves essential context missing: it does not specify what the tool returns, how operation_id is used, what expected_document_id does in practice, or error conditions. The 'Reinspect returned document identity' hint raises more questions than it answers, making the tool not fully usable from the description alone.

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

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

Schema description coverage is 0% for the 3 parameters. The description only implicitly references 'local F3D/F3Z archive' (likely the path format) and 'document identity' (hinting at expected_document_id), but provides no explanation for operation_id or how the parameters interact. This is insufficient compensation for the total absence of parameter docs in the schema.

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

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

The description clearly states the verb 'Open' with a specific resource ('a local F3D/F3Z archive') and the context ('in a new document; preserve other open documents'), distinguishing it from siblings like fusion_new_design (create) and fusion_activate_document (activate). It is immediately clear what this tool does.

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

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

The description provides context for use: 'preserve other open documents' implies this tool is for opening an archive without disrupting existing work, and 'Reinspect returned document identity before editing' gives a caution for subsequent actions. However, 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?

There are no annotations provided, so the description carries the full burden of behavioral disclosure. The phrase 'without retrying it' is a useful behavioral trait, but the description does not disclose whether the status is persisted for long, if it can be stale, whether it requires a valid operation_id, or any error conditions (e.g., operation not found). It also doesn't specify if the operation may still be running and what happens in that case. The description gives a hint but leaves many behavioral aspects undisclosed.

Agents need to know what a tool does to the 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 is front-loaded with the action ('Retrieve persisted operation status') and immediately clarifies the key nuance ('without retrying it'). There is no filler or redundant content, making it appropriately sized and easy to parse.

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

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

Given the tool has one parameter with zero schema coverage ratio, no output schema, and no annotations, the description is too sparse to be fully contextual. It does not explain the return value (status details like success/failure/progress), how the operation_id relates to other fusion tools, or what 'persisted' means for the agent. A more complete description would specify typical usage (e.g., polling after an async operation) and the expected response structure.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. However, the description only mentions 'operation status' and does not explain what 'operation_id' is or how to obtain it, nor its format or constraints. The sole parameter is not elaborated beyond its schema title 'Operation Id', leaving the agent with minimal semantic 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 states a specific verb and resource: 'Retrieve persisted operation status' and notes the key behavior 'without retrying it.' It clearly indicates the tool is for fetching status, not initiating operations routes the agent away from retrying. However, it does not explicitly distinguish from siblings like fusion_acknowledge_operation or fusion_active_command, which might also involve operations, so it is adequate but not fully differentiating.

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

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

The description gives minimal usage direction: it implies that the tool is for when you need to check status without triggering a retry)Skip the potential retry behavior. However, it does not state when to use this tool versus alternatives like fusion_acknowledge_operation, fusion_active_command, or fusion_recompute. No explicit context about typical usage scenarios or prerequisites (e.g., operation_id from a prior command) is provided, so guidance is incomplete.

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

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

With no annotations, the description carries the full burden. It discloses a meaningful behavioral guarantee: filters are exact and ambiguous results are never silently chosen. It also flags scope requirements. It omits details like return format or pagination, but for a read-style query tool this is still strong 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?

Two crisp sentences with no filler. The core purpose is front-loaded, followed immediately by the most important scoping and behavioral constraints. Every sentence earns its place.

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

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

For a complex EntityQuery schema with no output schema or annotations, the description covers essential scoping and ambiguity behavior. Yet it lacks output format details, pagination semantics, and any relationship to sibling inspection tools, so it is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning by mapping entity kinds to required scopes (faces/edges→body; profiles/points/curves→sketch). However, remaining fields such as name, limit, offset, radius_mm, surface_type, and tolerance_mm are left unexplained.

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

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

The description clearly states a specific action and resource: 'Discover geometry and re-usable entity tokens.' It also distinguishes entity categories by scope, but it does not explicitly differentiate this tool from sibling tools like fusion_inspect or fusion_model_overview.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 concrete operational guidance: faces/edges require body scope, while profiles/points/curves require sketch scope. However, it never explicitly states when to prefer this tool over alternatives or mentions exclusions, leaving the comparison to siblings 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal one key trait: it will not fabricate replacements for broken references, which implies it only reports issues rather than auto-fixing them. However, it does not state whether the operation modifies the design, requires specific permissions, or what the response format is, leaving important side effects unaddressed.

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

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

The description is a single, compact sentence that conveys the core action and a key limitation. It is front-loaded with the primary purpose and adds the caveat at the end, with no wasted words. This is appropriately concise for the amount of information it carries.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 incomplete for an agent to call the tool correctly. It lacks an explanation of the parameters, any mention of prerequisites (e.g., an active document), and details about the output format beyond 'report remaining problems'. Given there is no output schema and no annotations, the description should cover these but does not, leaving significant ambiguity.

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

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

The schema defines two required parameters (document_id and operation_id) with zero description coverage, and the tool description does not mention them at all. The agent has no clue what these parameters represent or how they relate to the recompute operation, forcing it to guess from names alone. This is a critical failure for a tool with no 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 action ('Recompute the design') and the expected outcome ('report remaining problems'), and adds a specific behavioral distinction: it does not invent replacements for broken references. This differentiates it from siblings like fusion_validate_design or fusion_check_interference, making its purpose unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or mention of other tools, leaving the agent to infer usage context solely from the name and general description. This is a significant gap given the large sibling set.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool should not change the viewport's direction, which is meaningful. However, it does not state whether the tool returns an image, whether any model/document state is touched, or whether width and height change the viewport or only the output size.

Agents need to know what a tool does to the 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 focused sentence with no filler or repetition. The core intent is front-loaded, and the clause 'without changing its direction' is non-redundant behavioral detail that 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 description gives the core behavior and is minimally sufficient for a tool with no required parameters and defaults provided. However, with no output schema and silent width/height semantics, an agent cannot fully anticipate the return value or how the capture size behaves.

Complex tools with many parameters or behaviors need more documentation. 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 never mentions width or height. The agent gets no help from the description about what these parameters affect, how they relate to the viewport capture, or what will happen if they are omitted.

Input schemas describe structure but not intent. Descriptions should explain 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 ('capture') with a specific resource ('the current viewport') and adds the behavioral qualifier 'without changing its direction.' It is clear and identifiable, though it does not explicitly differentiate against the other fusion_* sibling tools.

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

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

The description implies a basic use case but provides no explicit guidance about when to choose this tool, when not to use it, or which alternative tools might be more appropriate. With a large sibling list like the fusion_* tools, such routing context is useful and is missing here.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does mention that the tool recomputes after setting a parameter, which is a useful side effect, but it fails to disclose other potential behaviors like whether the operation can corrupt existing parameters, requires specific permissions, or might fail under certain design states. The description is too sparse for a mutation operation.

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

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

The description is a single concise sentence that front-loads the core action and side effect. There is no redundant or extraneous text, and it is appropriately sized for the tool's complexity.

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

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

Given the complexity of the tool (nested spec, required document and operation IDs, and a design context), the description is incomplete. It does not explain how the tool fits into the broader design workflow, what operation_id refers to, any prerequisites, or what happens when a parameter already exists. The absence of an output schema also means the description should clarify what the tool returns, but it does not.

Complex tools with many parameters or behaviors need more documentation. 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 any of the parameters in the nested ParameterSpec object (name, expression, units, component, allow_shared_definition_edit). Schema description coverage is 0%, so the description must compensate, but it only mentions 'expression' without elaboration. It does not clarify how to specify components, units, or the meaning of the required IDs (document_id, operation_id).

Input schemas describe structure but not intent. Descriptions should explain 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: creating or editing user/model parameter expressions and then recomputing. It identifies the resource (parameters) and the verb (create/edit). It slightly differentiates from siblings like fusion_edit_component_parameters by mentioning 'user/model parameter' vs component, but does not explicitly contrast with any sibling.

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

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

No guidance is provided on when to use this tool versus alternatives such as fusion_recompute (recompute only) or fusion_edit_component_parameters (component-specific parameter edits). The description lacks any conditions, exclusions, or contextual triggers for when this tool is the appropriate choice.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It communicates that this is a non-mutating reporting operation, what kinds of results it produces, and a key limitation. This is solid but not exhaustive; it does not describe output format, failure behavior, or what exactly counts as an 'unhealthy feature.'

Agents need to know what a tool does to the 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 short sentences with no filler. The core behavior is front-loaded, and the second sentence adds a meaningful limitation without wasting 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 validation tool with no output schema and no annotations, the description gives enough high-level context to understand its purpose, but it leaves gaps: what the return value looks like, how checks are interpreted, and how the tool behaves when checks are empty or fail. It is minimally adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for explaining parameters. It does not explain document_id or the checks array structure beyond the vague phrase 'numeric body checks,' which only loosely maps to the MeasurementCheck schema. The naming and enum values in the schema carry most of the semantic burden.

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

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

The description uses a specific verb ('Report') and names concrete outputs: unhealthy features, underconstrained sketches, and numeric body checks. It also adds an explicit non-goal (does not certify manufacturability), which helps separate it from manufacturing-oriented tools, though it does not explicitly name a sibling to distinguish against.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 about when to use this tool versus alternatives such as fusion_check_interference or fusion_model_overview. The only usage-related hint is the negative statement that it does not certify manufacturability, which is more a scope disclaimer than a routing rule.

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