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

The description explicitly states 'without changing it', reinforcing the non-mutating behavior already indicated by annotations. No side effects or error conditions are described, but the annotations cover the key behavioral guarantees.

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

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

A single concise sentence with no filler, front-loaded with the action and resource. Every word contributes useful meaning.

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

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

For a simple read-only tool, the description is sufficient: it states what is returned and that no mutation occurs. It could mention behavior when no document is active, but this is a minor gap given the annotations and sibling context.

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

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

There are no input parameters, so no parameter clarification is needed. The description names the output fields, which helps set expectations even though the output schema is not detailed here.

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 'Return', specifies the resource 'active document', and lists the exact data fields returned. This clearly distinguishes it from connect/open/modify 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 phrase 'without changing it' implies read-only inspection, but there is no explicit guidance on when to use this tool versus alternatives. Usage is implied rather than stated.

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

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

The description gives no information about side effects or mutability. Despite annotations indicating destructiveHint=true and readOnlyHint=false, the text is silent on whether the tool modifies the document, so the agent is unaware of potential destructive consequences.

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

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

The description is concise and logically structured, packing essential information about the dispatch mechanism, operation list, and unit conventions into two sentences without redundancy or unnecessary detail.

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

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

The description lacks information about return values, output format, or error handling. It also does not clarify the relationship to the dedicated analysis sibling tools, so the agent would not know what to expect from the tool or when its breadth is necessary.

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

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

The description explains the operation discriminator and clarifies that unspecified fields fall back to module defaults and that units follow SI unless a unit field is provided. However, it does not elaborate on individual parameters (e.g., body_name, entity, options), relying on schema titles that lack 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 identifies the tool as a dispatcher for multiple analysis operations (bounding_box, mass_properties, etc.) and indicates the resource (a SolidWorks document) via the document parameter. It is specific about the actions but does not explicitly state the high-level goal of 'analyzing the active document', slightly reducing clarity.

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 the sibling tools like solidworks_mass_properties or solidworks_inspect. It does not mention typical use cases, preconditions, or scenarios where this dispatcher is preferred, leaving the agent without selection criteria.

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

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

The description explicitly warns: 'This is full API access: calls may modify documents, execute macros, or access local files.' This goes beyond the annotations by explaining concrete side effects and destructive potential, making the behavioral impact clear.

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

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

The description is dense but every sentence earns its place: purpose, argument syntax, return behavior, action guidance, and a safety warning. It is front-loaded with the core purpose and avoids unnecessary 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 generic full-API tool, the description covers the essential invocation mechanics, return shape, and safety caveats. It does not detail target handle acquisition or error behavior, but the presence of a separate output schema and sibling connection tools reduces the need for that detail.

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

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

The input schema has 0% description coverage, and the description adds meaningful details about argument encoding such as '{$ref:handle}', '{$variant:'I4',byref:true,value:0}', typed arrays, and '{$missing:true}'. It also explains return behavior via 'Returns value and out_args' and clarifies the action enum, though 'target' and 'member' remain somewhat implicit.

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

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

The description clearly states the tool's purpose: 'Invoke any exposed COM member,' making it distinct from the higher-level SolidWorks sibling tools. It also clarifies the action options and warns that this is 'full API access,' so an agent knows it is a generic low-level entry 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?

The description gives some guidance, such as 'Get managers with action=get' and 'Explicit action avoids confusing methods and properties,' but it never explicitly says when to prefer this tool over the many specific sibling tools. It does not name alternatives or state conditions like 'use this only when no higher-level tool fits.'

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

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

The description discloses the key behavioral trait that registration is not performed, and that path discovery is delegated to discover. The annotations already cover destructive/read-only aspects, so the description does not need to repeat them. No contradiction with annotations.

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

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

The description is one concise sentence with no filler or redundant wording. It packs the key information efficiently.

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

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

For a simple single-parameter loading/indexing tool, the description provides enough context about the input and the workflow. Output/return values are not described, but an output schema is present, so this is not a significant gap.

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

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

The lone required path parameter is implicitly clarified as pointing to a local .tlb/.dll API library, with discover suggested as a way to find valid paths. It could explicitly state whether the path is a file or directory, but the meaning is sufficiently inferable.

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 indexes a local .tlb/.dll API library without registration, which is a specific verb and resource. It also distinguishes from sibling tools like solidworks_api_search and solidworks_discover by focusing on loading/indexing rather than searching or discovering.

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 practical guidance: use it for a local vendor library and avoid registration, and use discover to find paths. It could be more explicit about when to choose this tool over alternatives, but the context is clear enough.

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

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

The description discloses a key behavioral trait: the tool operates on already-loaded libraries and fails or returns empty otherwise. This dependency is not captured in the annotations (which only state readOnly, idempotent, non-destructive). The description adds this operational requirement, going beyond the annotations.

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

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

The description is two sentences, highly concise and front-loaded with the core action ('Search loaded API libraries'). The second sentence provides a necessary prerequisite without unnecessary detail. No fluff or redundancy.

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

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

It gives specific context about the types of libraries (sldworks.tlb, swconst.tlb, camworks.tlb) and the requirement to load them. Since an output schema is indicated as present, the lack of return-value explanation is acceptable. The description is sufficient for an agent to understand the tool's scope and precondition.

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

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

The schema has no parameter descriptions (coverage 0%), and the description does not explain the meanings of 'query', 'limit', or 'offset'. While 'limit' and 'offset' are common pagination terms, and 'query' is obvious, the lack of any clarification about search syntax, matching behavior, or pagination defaults leaves ambiguity.

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

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

The description clearly states the tool's purpose: searching loaded API libraries for interfaces, methods, parameters, and enums. While it doesn't explicitly differentiate from sibling tools like solidworks_discover or solidworks_inspect, the specific focus on 'loaded API libraries' and the mention of .tlb files makes its role fairly 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?

It provides an explicit prerequisite: load a library (sldworks.tlb, swconst.tlb, camworks.tlb, or an add-in DLL) first. This tells the agent when to use the tool (after loading) and implies it should not be used before that. It doesn't mention alternatives or when to choose this over others, but the prerequisite is clear and actionable.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds that it preserves every item of large arrays, a modest behavioral detail, but does not address error cases or side effects.

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

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

Single sentence, to the point, with no unnecessary words. Well structured 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?

For a simple pagination tool, it is mostly complete, but the lack of parameter documentation makes it less than fully self-contained. The description covers the basic operation but not details such as default behavior or edge cases.

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

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

Schema provides parameter names and types but no descriptions. The tool description does not explain what handle, limit, or offset mean, leaving the agent to infer from names 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?

States a specific action: reading a paginated array via a handle. Clearly identifies the resource and operation, distinguishing it from siblings that perform other operations on arrays or documents.

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

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

Lacks explicit guidance on when to choose this tool over alternatives. It is implied for array handles but no comparison or context 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?

Annotations already mark this as destructive (destructiveHint: true) and not read-only, so the mutating nature is covered. The description adds useful behavioral details about fallback defaults and unit conventions, but does not explicitly state that operations modify the active assembly or require a connected document. This adds some value beyond the annotations but is not rich.

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

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

The description is two sentences, efficiently listing the operations and giving unit/default guidance. It front-loads the dispatch concept and avoids filler, though it is somewhat abstract and could benefit from a concrete example or a clearer effect statement.

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 (15 operation variants), the description is minimal. It relies heavily on the input schema, which is detailed, but it lacks guidance on when to select each operation, prerequisites like an open document, and how the tool interacts with the active assembly. The presence of an output schema mitigates the need for return-value descriptions, but overall completeness is only 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?

With schema description coverage at 0%, the description must compensate. It explains the fallback-default mechanism and unit conventions (SI unless a unit field is accepted), which are not fully captured in the schema's property defaults. However, it does not detail individual operation parameters beyond pointing to the schema, so the added value is moderate.

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

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

The description clearly states it dispatches on payload.operation to capability-module handlers for a specific list of assembly operations (bom, mate, move_component, etc.), making its purpose evident. It distinguishes itself from sibling tools by naming its operation set, though it remains somewhat generic as a dispatcher without describing the effect of each operation.

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

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

The description offers no explicit guidance on when to use this tool versus sibling tools like solidworks_assembly_tree or solidworks_mass_properties. It neither states alternatives nor provides exclusions, leaving the agent to infer usage from the operation list and the tool name.

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

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

The annotations already declare read-only and idempotent behavior, and the description's 'Inspect' aligns with this. The phrase 'with bounds' adds behavioral context, indicating that the tool will respect depth and component limits. No contradictions exist.

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

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

The description is extremely concise, consisting of a single sentence that captures the core functionality without unnecessary words. It is well-structured and immediately communicates the tool's purpose.

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

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

The description adequately covers what the tool does, but does not mention return format or output structure. Given the tool's simple inspection nature and that an output schema exists (though not shown), the absence of explicit output details is a minor gap. Overall, it is sufficient for an agent to understand when and how to use it.

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

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

The schema provides parameter names with defaults but no per-parameter descriptions. The description's 'with bounds' hints at the purpose of max_depth and max_components, but the meaning of 'document' is not elaborated. Parameter semantics rely heavily on self-explanatory names rather than explicit guidance.

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

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

The description clearly states the tool's purpose: to inspect assembly occurrences, parent relationships, suppression, and transforms. The verb 'Inspect' is specific, and the resource is clearly the assembly tree. It distinguishes itself from siblings like solidworks_inspect by focusing on the assembly hierarchy.

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 assembly tree information is needed, but it does not explicitly state when to prefer this tool over alternatives such as solidworks_inspect or solidworks_assembly. No exclusions or comparisons are given, making the guidance only 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?

Beyond annotations, it discloses ordering guarantees, stop-at-first-error behavior, reporting of completed steps, and that earlier mutations remain applied, explicitly denying rollback 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?

Three compact sentences front-load the purpose, then provide the reference syntax and the essential caveat. There is no filler or redundant detail.

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

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

Covers ordering, error behavior, side-effect persistence, and result referencing. With an output schema present it need not detail return shape, but background semantics and action meanings are not 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?

Adds meaning by explaining the {$result:'step_id',path:['value','$ref']} reference syntax for id/target/value, but does not explain the background parameter or the action enum values call/get/set.

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

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

States a clear, specific purpose: execute ordered API steps without interleaving. It distinguishes batch execution from single-step API calls and clarifies that it is not a rollback transaction.

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

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

Implies use for ordered/dependent steps and cautions against assuming rollback, but does not explicitly contrast with alternatives such as solidworks_api or solidworks_array or state when to prefer this batch variant.

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

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

The description discloses that unspecified fields fall back to module defaults and explains unit conventions, which are useful behavioral details not in the annotations. However, it does not elaborate on side effects beyond the destructiveHint annotation, nor does it mention error handling or return behavior. The annotations already cover the destructive nature, so the description adds moderate transparency.

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

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

The description is concise, consisting of three sentences that efficiently convey the dispatcher nature, the list of operations, and the fallback/unit behavior. It is well-structured and free of unnecessary detail, making it 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?

The description provides a high-level overview of the tool's functionality, including the discriminator field, the set of operations, and the fallback/unit conventions. It directs the agent to the input schema for per-operation details, but given the schema lacks descriptions, some details (e.g., return values, error cases) are not covered. For a dispatcher tool, this level of context is largely sufficient, though not exhaustive.

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 adds meaning beyond the raw input schema by clarifying that each operation has a typed field set and that unspecified fields fall back to defaults. It also explains unit conventions (SI unless a unit field is provided). Since the schema has no field descriptions, these clarifications are valuable, though individual field semantics are left to the schema's property names and defaults.

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 that the tool dispatches on payload.operation to various body-operation handlers, listing the specific operations. It identifies the resource as solidworks_body and the action as dispatching, which is specific. However, it does not explicitly differentiate from sibling tools, though the operation list makes its scope clear.

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

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

The description implies when to use the tool (when performing body operations like cavity, combine, delete, etc.) by listing the operations, but it does not explicitly state alternatives or when not to use it. It also refers to the input schema for details, but no explicit comparison to sibling tools is provided, so usage guidance is only implied, not explicit.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false. The description adds only that fields fall back to module defaults and that units follow a convention (SI unless a unit field exists). It does not disclose that operations like save_cam_data or set_* modify CAM data, nor does it mention side effects, prerequisites, or reversibility. It adds minimal context beyond the annotations, leaving the destructive nature unelaborated.

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 dense sentence listing 19 operations, which is necessary but could be better structured (e.g., bullet points or grouping). It front-loads the dispatcher concept and mentions the schema, defaults, and units. It is not excessively verbose given the scope, but the run-on nature and lack of paragraph breaks reduce clarity.

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

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

For a tool with 19 operations and many parameters, the description is severely incomplete. It does not explain what each operation accomplishes, prerequisites, side effects, or workflow order. It relies on the input schema for field details, but the schema is also incomplete. The output schema exists, so return values are covered, but the operational semantics are entirely missing, making it hard for an agent to choose and invoke the right operation.

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

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

Schema description coverage is 0%, meaning the description provides no parameter details. It merely says each operation has a typed field set (see the input schema) and mentions unit conventions. The schema itself is sparse for many parameters (e.g., target_operation, techdb_id have no descriptions). The description does not compensate for this lack, leaving an agent to infer parameter meaning from field names 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 that the tool dispatches on payload.operation to specific handlers and lists all 19 operations. This conveys a specific, broad CAM capability set that distinguishes it from siblings like solidworks_cam_connect or solidworks_cam_status. However, it doesn't explicitly say 'use this for all CAM operations' or contrast with those siblings, so it stops short of a 5.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any other tool or provide selection criteria. The operation list implies it's for those operations, but there is no explicit 'use this when you need to...' or exclusion of other tools. An agent must infer the scope from the list alone.

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

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

Annotations include destructiveHint=true, and the description does not contradict it, but it also does not explain what destructive side effects might occur from attaching. It does add the useful distinction between add-in presence and API/license availability, which is beyond the annotations, so some credit is given.

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

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

Two concise sentences with the primary purpose front-loaded and a caveat following. No redundant wording; every clause earns its place.

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

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

With an output schema present, return details need not be described. The description covers the essential distinction between add-in presence and API availability, which is critical for correct usage, making it sufficiently complete for a single-parameter connection tool.

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

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

Schema coverage is 0% and the description explicitly explains the single optional parameter as 'exact GUID/ProgID', providing meaning the schema lacks. This compensates well for the absence of schema descriptions.

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

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

The description clearly states the tool attaches to the SOLIDWORKS CAM add-in and GetCWApp API, which is a specific verb-resource pair. It distinguishes from the general solidworks_connect by naming the CAM add-in, though it does not explicitly contrast with that sibling.

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

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

The description provides a caution about add-in presence versus API availability but gives no explicit guidance on when to use this tool versus alternatives like solidworks_connect or solidworks_cam_status. No when-to-use or when-not-to-use conditions are stated.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which covers safety and side-effect expectations. The description adds a critical behavioral guarantee: 'never treats an installed library as a license.' This goes beyond the annotations by clarifying a specific non-behavior, increasing transparency about the tool's internal logic.

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

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

The description is extremely concise, consisting of two short clauses. Every word adds value: 'Report observed CAM connection state' conveys the core function, and 'never treats an installed library as a license' provides a meaningful boundary. There is no repetition, filler, or unnecessary detail.

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

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

For a zero-parameter status tool, the description is contextually complete. It tells the agent exactly what the tool does, what it does not do, and implies it is a read-only observation without side effects. The absence of parameters and output schema (though the context mentions an output schema, the description itself is sufficient) means no additional context is needed for correct invocation.

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

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

The tool has zero parameters, and the input schema is empty (100% coverage). There is no parameter information to explain. According to the rubric, when schema coverage is high, a baseline score of 3 is appropriate even without additional parameter descriptions. The description adds no parameter semantics because there are none to clarify.

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

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

The description clearly states the tool's function: 'Report observed CAM connection state.' It also explicitly states what it does not do ('never treats an installed library as a license'), which removes ambiguity and distinguishes it from potential license-related tools. The verb 'report' and the resource 'CAM connection state' are specific and unambiguous.

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

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

The description implies a monitoring/status-check use case without explicitly naming alternative tools or scenarios. The statement 'never treats an installed library as a license' serves as a caution and clarifies a boundary, but it does not explicitly state when to choose this tool over siblings like solidworks_cam_connect or solidworks_cam_workflow. Given the clear function, the usage context is mostly self-evident.

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

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

Annotations already indicate destructiveHint and readOnlyHint; description adds legacy/low-level context and the action list but does not disclose side effects or action-specific behavior beyond that.

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

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

Two concise sentences with no redundant content; all information serves to identify purpose and direct the agent to the preferred alternative.

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?

Description is sufficient to avoid misuse by steering toward solidworks_cam and listing the supported raw actions. Output schema exists, so return details are not required, though action-specific invocation details are sparse.

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?

Description lists the raw action values and frames the tool as action/args dispatcher, but does not explain the args object structure, background flag semantics, or per-action parameters. Schema coverage is 0%, so more detail would be needed for full parameter clarity.

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

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

Description clearly identifies the tool as a legacy low-level CAM action/args dispatcher for raw CAMService.workflow actions and distinguishes it from the preferred typed solidworks_cam tool.

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

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

Explicitly states 'Prefer solidworks_cam' and explains that the typed tool exposes the full CAM operation surface with proper per-operation schemas, giving clear guidance on when not to use this legacy dispatcher.

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?

Beyond the annotations (destructive, not read-only), the description adds valuable behavioral nuance: it can only cancel queued jobs and cannot safely abort running native calls, which is not captured by the annotations alone.

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

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

The description is extremely concise with no redundant information. Two sentences fully convey the purpose and limitation without any fluff.

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

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

For a simple tool with a single parameter, the description fully covers what the tool does, its scope, and its key caveat. No critical information is missing for an agent to decide on usage.

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

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

The sole parameter 'job_id' is self-explanatory by name, and the description gives domain context (queued job). However, it does not explicitly state that job_id refers to the identifier of the queued job, leaving minor room for interpretation.

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

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

The description clearly states the tool's function ('Cancel a queued job only') with a specific verb and resource. It also explicitly distinguishes it from actions on running native calls, which clarifies its 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?

It explicitly states when to use it (for queued jobs) and when not to (for running native SOLIDWORKS calls), providing clear conditions of use relative to the tool's limitations.

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 only mentions dispatch mechanics and does not disclose potential side effects (e.g., deletion, modification, activation) that some operations perform. While the annotations indicate destructive behavior, the description itself adds no transparency about the impact of individual operations.

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

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

The description is very concise, using only a few sentences to convey the dispatcher pattern and the list of operations. No unnecessary words or repetition, making it easy to read and understand.

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 dispatch mechanism and fallback behavior, but does not mention what the tool returns or how the output might vary by operation. Given that an output schema exists, a brief note on return shape would improve completeness, but it is not critical for basic usage.

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

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

The schema already provides detailed parameter definitions, defaults, and required fields. The description adds value by clarifying the unit convention for length/angle fields, which is not evident from the schema alone. This helps interpret the 'unit' parameter correctly.

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

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

The description clearly states that the tool dispatches on payload.operation to specific handlers for configuration operations, and lists all supported operations. This makes the purpose unambiguous and distinct from sibling tools focused on other SolidWorks aspects.

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

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

It explains that each operation has its own typed field set and that unspecified fields fall back to defaults, guiding usage. It does not explicitly state when to prefer this tool over siblings, but the operation list and name make it evident for configuration tasks.

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

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

Annotations already declare openWorldHint=true and destructiveHint=true, so the description is not expected to restate them. It does add the behavioral note that launch=true may start the application, which is useful. However, it does not disclose what happens if already attached, whether repeated calls are safe, or the nature of the destructive hint. Given annotations cover some context, this is adequate but not rich.

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

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

The description is one efficient sentence with a semicolon separating the action and the return value. It is front-loaded with the primary purpose and contains no filler.

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

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

While the output schema exists (and likely documents the app handle), the description lacks lifecycle context: no mention of when to release the connection, potential side effects of the destructive hint, or whether this is a persistent attachment. For a connection tool, this is incomplete but not severely so given the simple interface.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It explains 'launch' as potentially starting SOLIDWORKS, but says nothing about 'visible'. It also does not clarify what an 'app handle' means or how to use it. Partial coverage of one parameter out of two yields a marginal score.

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

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

The description clearly states the action ('Attach to SOLIDWORKS 2025'), specifies the revision, and notes the return value ('app handle'). It distinguishes from siblings like solidworks_discover (which likely finds instances) and solidworks_release (which detaches), even though it doesn't name them.

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

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

The description implies usage (attach before performing operations) and hints at the launch parameter for starting the app, but it does not explicitly state when to use this tool vs alternatives, mention prerequisites, or warn against misuse. The guidance is minimal and inferential.

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

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

The description adds a behavioral detail beyond the annotations: 'no app launch.' This clarifies that the tool is non-invasive and does not start the SOLIDWORKS application, which is not directly inferred from the readOnlyHint alone.

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

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

The description is a single sentence that is direct and front-loaded with the primary action. It contains 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?

Given the tool's simplicity (no parameters) and the presence of an output schema, the description is sufficient for an agent to understand the tool's purpose. The 'no app launch' clarification provides additional context.

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

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

The tool has zero parameters, so the schema is empty. The baseline for zero parameters is 4; the description adds nothing about parameters, but none are needed.

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

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

The description clearly states the tool's function: finding installed SOLIDWORKS versions, CAM/add-in registrations, and API libraries. It also specifies that it does not launch the application, which is a clear behavioral note.

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 does not explicitly mention when to use this tool versus its siblings. It only hints at a distinction by saying 'no app launch,' but it does not name alternative tools or conditions for using them.

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

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

The description adds behavioral details beyond the annotations by mentioning that unspecified fields fall back to module function defaults and that lengths/angles follow unit conventions (SI unless a unit field is provided). This gives insight into parameter handling and measurement behavior, complementing the destructiveHint and readOnlyHint annotations without contradicting them.

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

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

The description is reasonably concise, fitting into two sentences. The list of operations is long but necessary for completeness. The structure is clear: first sentence identifies the dispatcher role and operations, second sentence explains field defaults and units. No extraneous information is included.

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

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

Given the tool's complexity (multiple operations with distinct field sets), the description is incomplete. It does not explain what each operation accomplishes (e.g., what 'export' exports or how 'section_view' behaves), nor does it describe the document parameter's role. An agent would lack critical context to correctly select and configure an operation without additional external knowledge.

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

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

The schema has no parameter descriptions, and the tool description provides minimal semantic guidance. It tells users to consult the input schema for field definitions and clarifies unit conventions, but it does not explain the purpose or meaning of the core parameters (payload, document) or the individual operation-specific fields. The description relies on the schema, which is itself underdescribed, leaving parameters semantically opaque.

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

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

The description clearly states the tool is a dispatcher for drawing-specific operations, listing all supported operations (add_annotation, detail_view, etc.). This distinguishes it from sibling tools focused on other SolidWorks aspects like sketching or features, 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 implies usage for drawing operations through the list of operation names, but it does not explicitly state when to use this tool versus other SolidWorks tools (e.g., solidworks_open_document or solidworks_sketch). It lacks direct comparison or exclusionary guidance, so the usage context is only implicit.

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

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

Annotations already carry the safety profile (readOnlyHint=false, destructiveHint=true), lowering the bar. The description adds useful context about fallback defaults and unit conventions, but it does not disclose what destructive behavior means here — notably the schema's 'overwrite' field implies possible file overwriting that the description never addresses. No contradiction with annotations.

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

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

Three sentences and reasonably compact, but the opening phrase is technical jargon that reduces efficiency. The unit-convention sentence earns its place, while the schema-pointer sentence is somewhat redundant given it points to a schema that provides no descriptions.

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 high-complexity discriminated union with many per-operation fields, zero schema descriptions, and a destructive annotation. The description is incomplete: it does not explain the export formats, the meaning of options/overwrite, what import_data or arg_string do, or any destructive implications. An output schema exists, which may cover return values, but input semantics are largely missing.

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

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

Schema description coverage is 0%, so the description must compensate — but it only explains the dispatch-on-operation mechanism and unit convention, then points to 'the tool's input schema' for field meaning, and that schema has no descriptions. The export format fields (fmt, stl_units, dxf_version, parasolid_version, iges_representation) and import fields (arg_string, import_data) remain 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?

The description states specific operations ('[export, import]') on a concrete resource (SolidWorks document exchange), which conveys the tool's purpose. However, the phrasing 'dispatches on payload.operation to one of the capability-module handlers' is jargon-heavy, and with 38 siblings the description does not strongly differentiate this from related tools like solidworks_open_document or solidworks_save.

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. None of the sibling tools are named, no conditions or exclusions are given, and no hint of what distinguishes exchange from open/save/import-like siblings. An agent must infer usage entirely from the name.

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

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

Annotations already indicate destructive behavior (destructiveHint=true), so the bar is lower. The description adds dispatch behavior and default fallback details, but doesn't explicitly warn about side effects or document modification.

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

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

The description is dense but purposeful, listing operations and key usage rules in three sentences. No redundant or fluff content, though the long operation list makes it slightly heavy.

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 complex schema and presence of an output schema, the description covers the essential dispatch logic, field behavior, and units. It doesn't address error cases or return values, but those are likely covered by the 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 has 0% description coverage, so the description must compensate. It points to the schema for operation-specific fields and explains unspecified field fallback and unit conventions. However, it doesn't describe the exact payload structure or the operation field semantics.

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

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

The description clearly states the tool dispatches on payload.operation to specific feature handlers, listing all supported operations. It distinguishes itself from sibling tools by its operation set, though it doesn't explicitly contrast with solidworks_modify_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?

Provides practical guidance on typed field sets, default fallbacks, and unit conventions. It doesn't explicitly say when to use this tool versus alternatives, but the operation list and dispatch behavior make the use case clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that it returns feature types and error/warning codes, which is useful context. However, it doesn't explain the 'bounded' nature in terms of the max_features parameter or any other behavioral nuances beyond the annotations.

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

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

The description is a single, concise sentence with no filler. It front-loads the core action ('Inspect bounded feature tree') and immediately specifies the key details (feature types, error/warning codes). 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?

Given the tool has 2 parameters with no schema documentation and an output schema that is not explained, the description is insufficient. It doesn't clarify how to specify a document, what 'bounded' means in terms of limits, or what the output structure looks like. For a read-only inspection tool, it should at least mention the max_features parameter and its default behavior.

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

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

Schema description coverage is 0% and the description provides no explanation of the 'document' or 'max_features' parameters. With zero coverage, the description must compensate, but it doesn't mention either parameter. The agent has to infer that 'bounded' relates to max_features, but there's no explicit documentation of what these parameters do or their acceptable values.

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

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

The description clearly states the verb 'Inspect' and the resource 'bounded feature tree', and specifies what is included ('feature types and error/warning codes'). It distinguishes itself from sibling tools like solidworks_assembly_tree (which inspects assembly structure) and solidworks_feature (which likely modifies features). The purpose 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 this is the tool for inspecting the feature tree, but it doesn't explicitly state when to use it versus alternatives or when not to use it. There's no mention of conditions like needing a document open or limitations. The guidance is minimal and implicit.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context: it is a non-blocking poll (not entering the COM queue) and warns that failed jobs may have partial effects. This goes beyond the annotations and helps the agent anticipate side effects of the underlying 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 two short sentences with no fluff. It front-loads the primary purpose ('Poll job state/result') and then adds the key behavioral nuance. 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?

Given the presence of an output schema (which presumably describes the result format), the description covers the essential operational details: it polls, it is non-blocking, and it warns about partial effects on failure. It does not mention polling frequency or timeout behavior, but for a simple status check, this is adequate. It could be improved by hinting at how to obtain job_id, but that is likely covered by job-creation tools.

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

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

Schema coverage is 0% (no descriptions in the schema) and the description does not explain the job_id parameter beyond its name. The schema provides only type and title, which is minimal. Since this is a low-coverage case, the description should compensate, but it offers no guidance on what job_id is, how to obtain it, or its format. This is a significant gap for a single-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 clearly states a specific action (poll) and resource (job state/result). It distinguishes itself from sibling tools by noting it operates 'without entering the busy COM queue', implying it is the non-blocking way to check job status, unlike other tools that may interact with the COM queue.

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 on when to use this tool: to poll job state/result without blocking. It also warns about partial effects on failure. While it does not explicitly name alternative tools, the 'without entering the busy COM queue' phrasing implies a contrast with tools that do block, and the presence of solidworks_cancel_job suggests this is for status checks, not mutations.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds that computation uses current material and configuration, reinforcing a non-mutating, read-only 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 one concise sentence with no unnecessary words or redundant information.

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

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

The tool has an output schema and one undocumented parameter, but the description does not explain what 'document' refers to or what output format/units are returned. It is understandable at a high level but incomplete 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?

There is one parameter, 'document', with no schema description, and the tool description never mentions it. With 0% schema coverage, the parameter meaning is entirely unspecified.

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 'Compute' and a clear resource: model mass/volume/area and inertia. It is distinguishable from sibling tools like solidworks_inspect or solidworks_analyze.

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

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

The description implies the tool is used when mass properties are needed based on current material and configuration, but it does not explicitly state when to use it versus alternatives such as solidworks_analyze or solidworks_material.

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 mentions that unspecified fields fall back to defaults and that units follow conventions, but it doesn't disclose side effects or destructive behavior. Given the destructiveHint annotation, describing which operations are destructive would be valuable, but it's absent.

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 brief and to the point, using only two sentences. It avoids redundancy, though its brevity comes at the cost of substantive guidance.

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—five distinct operations with different required fields, plus a discriminator pattern—the description fails to provide essential context. It doesn't explain what any operation does, when to use them, or how they relate to each other. Highly 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 description only notes that each operation has a typed field set and unit conventions. It does not explain any specific parameters like config_name, rgb, entity_name, or density_index. With 0% schema coverage, this is insufficient.

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

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

The description states the tool dispatches on payload.operation to handler modules for five operations, giving a general sense of purpose. However, it doesn't clarify what each operation does or how it differs from sibling tools, so it's only moderately clear.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention when material operations are needed or how to choose among the listed operations. The description is purely structural, not instructive.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds the workflow of discovering properties and using specific API methods, which provides some behavioral context but doesn't disclose side effects like model rebuilds or reference invalidation.

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-loading the core action and method. It is concise and avoids fluff, though it could be better structured with explicit parameter guidance.

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 destructive tool with openWorldHint, the description lacks details on prerequisites (e.g., connected document), side effects, or return values. It doesn't explain the parameters or output, leaving significant gaps for an agent to call it correctly.

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

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

Schema has no descriptions (0% coverage). The description mentions 'discover exact properties' as a hint for the properties object but doesn't explain the meaning of feature, document, component, or the expected structure of the properties map. It fails to compensate for the schema gap.

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

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

The description clearly states the tool edits a feature's definition, using AccessSelections/ModifyDefinition. It distinguishes itself from generic feature tools by specifying the action and method, though it doesn't explicitly name sibling 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?

It hints that properties must be discovered first and that generic API/scripts are for indexed/method-based definitions, implying when not to use this tool. However, it doesn't explicitly compare to alternatives like solidworks_feature or solidworks_parametric, leaving usage context vague.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, covering the mutation/safety profile. The description adds meaningful context: the template path must be absolute and existing, and the tool returns a handle to the created document. This goes beyond what annotations state without contradicting them.

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

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

A single, information-dense sentence that front-loads the action and result. No filler or redundancy; every word contributes to understanding.

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

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

The description covers the core operation and return value, and an output schema exists to define the response. However, it does not mention how to obtain a valid template path (e.g., via solidworks_templates) or potential error conditions. Given the tool's simplicity and the presence of an output schema, this is adequate but not exhaustive.

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

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

The schema has zero description coverage for the 'template' parameter. The description provides some meaning by specifying 'absolute existing template path', but it does not clarify acceptable file extensions or further constraints. For a single-parameter tool, this is a partial compensation but not complete.

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' with resource 'part/assembly/drawing' and scope 'from an absolute existing template path', clearly distinguishing it from open_document (which opens existing) and templates (which lists). An agent can tell it apart without needing to inspect other 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 this tool is for creating new documents from a template path, but it does not explicitly mention when not to use it or name alternatives like solidworks_templates for discovering valid paths. The context is clear enough that an agent can infer the use case, but explicit routing is absent.

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 mentions that it returns COM errors/warnings, which gives some insight into failure modes. However, it does not explain side effects or success behavior, though the annotations (readOnlyHint false, destructiveHint true) are present and not contradicted.

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 that conveys the essential information without any redundant or vague wording. It is immediately actionable.

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 minimal but sufficient for a basic open operation. Given that an output schema exists, return values are not required in the description, and the mention of errors/warnings adds some context. However, it lacks details on preconditions or expected behavior.

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

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

The description partially explains the document_type parameter by mapping values to part/assembly/drawing, but it does not clarify the path or read_only parameters. Since the schema provides no descriptions, the overall parameter coverage is incomplete.

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 (open) and the resource (document path) with explicit enumeration of the supported document types (part, assembly, drawing). It distinguishes this tool from siblings like new_document or save without ambiguity.

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

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

No guidance is provided on when to use this tool versus alternative tools such as solidworks_new_document or solidworks_active_document. The description only states what it does, not the context or conditions that warrant its use.

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

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

The description adds useful context about default fallback for unspecified fields and unit conventions (SI unless a unit field is accepted). However, it does not disclose the destructive nature (consistent with destructiveHint=true) or any side effects of operations like delete_equation or set_dimension. It neither contradicts annotations nor fully elaborates on them.

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

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

The description is a single dense paragraph that front-loads the dispatcher mechanism and operation list, then covers defaults and units. It is reasonably concise with no filler, though the density could be slightly improved with bullet points or clearer separation of concepts.

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

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

Given the tool's complexity (7 operations with distinct field sets) and that an output schema exists, the description is minimal. It lacks error behavior, side-effect warnings, and examples. The agent must rely heavily on the schema and annotations to understand each operation, which may be insufficient for correct invocation in many contexts.

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 that each operation has a typed field set (pointing to the schema), that unspecified fields fall back to module defaults, and that units follow SI unless a unit field exists. This provides high-level guidance but does not detail individual parameter meanings or formats, which are left 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 states the tool dispatches on payload.operation to handlers for a specific list of operations (add_equation, delete_equation, set_dimension, etc.). This gives a precise verb+resource scope and distinguishes it from the many sibling tools that cover other SolidWorks domains (sketch, feature, assembly, etc.).

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 does not state when to use this tool versus alternatives. It merely lists operations without explaining when parametric operations are appropriate compared to, e.g., solidworks_api, solidworks_sketch, or solidworks_modify_feature. No explicit 'use for X, not for Y' guidance is provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description is not contradicting them. It adds useful context about unspecified fields falling back to defaults and unit conventions (SI unless a `unit` field exists). However, it does not disclose that the tool modifies the model, requires an open document, or any other behavioral side effects. The description adds limited behavioral value beyond annotations.

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

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

The description is a single concise paragraph that front-loads the key dispatch mechanism and lists operations. It avoids unnecessary detail and stays focused. It is well-structured for the information it conveys, though it could be slightly more organized with bullet points, but it is not overly 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 tool with seven distinct operations, each with its own field set. The description only mentions the dispatch mechanism and unit defaults, omitting prerequisites (e.g., active document), expected outcomes, or any indication of the return value (though an output schema exists, it is not shown). The description is too sparse to fully guide an agent on how to correctly invoke this tool across all operations.

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

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

Schema description coverage is 0%, so the description must compensate. It provides general rules: each operation has its own typed field set, unspecified fields use defaults, and units follow documented conventions unless a `unit` field is present. This is helpful but does not explain the meaning of any specific parameter (e.g., seed_feature_names, boundary_sketch_name). The description gives high-level guidance but insufficient per-parameter semantics.

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

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

The description clearly states the tool dispatches on payload.operation to handlers for specific pattern types (circular, curve_driven, fill, linear, mirror, sketch_driven, table_driven). This identifies the tool's purpose as a pattern-creation dispatcher. However, it does not explicitly state that it creates or modifies patterns, nor does it differentiate from the sibling tool solidworks_array, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention solidworks_array or any other sibling, nor does it state conditions for use (e.g., requires an active document). The only usage hint is the dispatch mechanism itself, which is inherent to the schema. No exclusions or alternative routing are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the behavioral context that the encoded reference is used for reacquisition, which is useful beyond annotations. No contradictions found.

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

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

The description is a single, efficient sentence that front-loads the core purpose. There is no extraneous information, and every word contributes to understanding the tool's function.

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

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

Despite having an output schema, the description lacks any parameter explanations, examples, or edge-case guidance. For a tool that requires an 'entity' string, the description is insufficient to ensure correct usage, especially given the 0% schema coverage.

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

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

Schema description coverage is 0%, and the description does not mention the 'entity' or 'document' parameters at all. The agent receives no guidance on what constitutes an 'entity' or when to provide a 'document', leaving a significant gap for correct invocation.

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 ('Encode') and a specific resource ('entity's persistent reference'), and clarifies its purpose: reacquiring the entity after edits or reopening. It clearly differentiates from the sibling tool 'solidworks_resolve_reference', which performs the inverse operation.

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

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

The description provides clear context for when to use the tool ('after edits or reopening its model'), which implies the usage scenario. It does not explicitly name alternatives or when-not-to-use, but the purpose is self-evident and contrasts with the resolve sibling.

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

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

Annotations already indicate destructive, non-read-only, non-idempotent behavior, and the description adds the useful behaviors of reporting failure and needing a follow-up feature inspection for error codes. It does not contradict annotations and gives extra operational context beyond the structured metadata.

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

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

The description is two sentences with no filler: the first states the primary action and result, and the second gives a concise next step. 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 two-parameter tool with an output schema and rich annotations, the high-level context is adequate. However, the undocumented 'force' and 'document' parameters leave an important gap, and the description does not specify any prerequisites such as an open document or connected SolidWorks session.

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

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

With 0% schema description coverage, the description carries the burden of explaining the 'force' and 'document' parameters, but it mentions neither. The parameter names and defaults offer some clue, yet no semantic detail is provided in the description.

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

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

The description states a specific action — 'Rebuild a model' — and adds the key outcome of reporting failure, which distinguishes it from inspection, analysis, and modification tools. The follow-up instruction to inspect features for error codes reinforces the tool's unique role in the rebuild workflow.

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

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

The description implies usage by saying 'Inspect features afterwards,' which positions rebuild as a prerequisite for detailed error-code inspection. However, it does not explicitly state when to choose rebuild over sibling tools or mention any exclusions.

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

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

The annotations already indicate destructive=true, readOnly=false, etc. The description adds no specific side-effect information (e.g., that it creates features in the active document, requires an open document, or makes persistent changes). It only describes the dispatch mechanism and parameter defaults, which is not enough to disclose behavioral traits beyond the annotations.

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

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

The description is a single, focused sentence that front-loads the tool's dispatcher role and lists the supported operations. It avoids extraneous detail and is appropriately concise for the 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 complex discriminated-union schema with five operations each having several fields, the description is too high-level. It does not explain the differences between operations, which fields are required or optional, or what the tool outputs, leaving significant gaps for an agent to use it effectively.

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

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

The schema has zero field descriptions and the description only adds generic notes about typed field sets, defaults, and unit conventions. It does not explain what fields like 'references', 'constraints', 'point_type', or 'values' mean, leaving the agent to infer semantics from field names 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 that the tool dispatches on payload.operation to handle reference geometry operations for axis, coordinate_system, coordinate_system_numeric, plane, and point, which identifies its purpose as creating reference geometry. It does not explicitly use a direct verb like 'create' but the operation names make the resource clear; it is distinguishable from sibling tools by the reference-geometry focus.

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 some operational guidance, such as typed field sets, defaults for unspecified fields, and unit conventions. However, it does not explicitly state when to use this tool versus alternatives, nor does it compare with sibling tools that might create other geometry types.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds behavioral context beyond that: it specifies the action targets 'session handles on their COM apartment' and clarifies it does not close documents. This provides transparency about the scope and side-effects without contradicting the annotations.

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

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

The description is two short sentences with zero filler. The primary action is front-loaded, and the clarifying exclusion is placed second. Every word earns its place, making it highly efficient.

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

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

For a simple tool with a single parameter and an output schema present, the description is complete. It states the purpose, scope, and what it does not do. An agent has all the information needed to decide whether to call it and what to pass in.

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 'handles' parameter, so the description must compensate. It does so by explaining that the handles are 'unneeded session handles' to be released, giving semantic meaning to the parameter. It doesn't specify the exact format of a handle, but it clarifies the purpose, which is sufficient for a simple array of strings.

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 (release) and the resource (session handles on their COM apartment), and explicitly distinguishes itself from closing documents. This differentiates it from sibling tools that handle document operations, so an agent can tell it apart without inspecting schemas.

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

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

The description provides clear context (release unneeded handles) and an exclusion ('Does not close documents'), which implicitly guides the agent to use this tool when releasing handles rather than closing documents. However, it doesn't name specific alternative tools or conditions, so it stops short of explicit when/when-not guidance.

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

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

The annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds that it 'reports deleted/invalid entities,' which is extra behavioral insight not covered by annotations, though it does not describe other potential side effects or error conditions.

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

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

The description is a single, focused sentence with no redundant words. It effectively communicates the core action and a key outcome without unnecessary detail.

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

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

Given the two parameters and the existence of an output schema, the description lacks essential context. It does not clarify the format or meaning of 'reference,' the role of 'document,' or what the tool returns beyond reporting invalid entities, making it incomplete for an agent to use correctly.

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

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

Neither parameter ('document' and 'reference') is described in the schema or the tool description. The schema coverage is 0%, and the description offers no explanation of what a 'reference' is or how 'document' affects resolution, leaving parameter usage ambiguous.

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

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

The description clearly states the tool's action ('Resolve a persistent reference in its original document') and an additional behavior ('reports deleted/invalid entities'). This is sufficiently specific and distinguishes it from related tools like solidworks_persistent_reference.

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 does not provide any guidance on when to use this tool over alternatives. It lacks conditions, exclusions, or context about typical scenarios, leaving the agent to infer the intended usage from the name alone.

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

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

It reveals that format support depends on document type and that this tool does not handle export options, going beyond the annotations' destructive hint. It also mentions the workspace context, which is not in the annotations.

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

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

The description is concise and front-loaded with the primary action, using only two sentences. It avoids unnecessary verbosity while covering the core functionality.

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

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

It provides key context about workspace limitation and format support, and directs to SaveAs for advanced options. However, it lacks details about return values and the behavior of the overwrite parameter, which is important for safe usage. Overall adequate for basic usage.

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

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

No parameter descriptions are provided in the schema, and the description does not explain the path, document, or overwrite parameters. The agent is left to guess their semantics, especially how the extension in path determines format and what the document parameter defaults to.

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 (Save/export), the resource (by extension), and provides examples of file types. It distinguishes the tool's scope from advanced export options by directing users to API SaveAs.

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

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

It provides a clear condition for when not to use this tool (when export options are needed) by directing to API SaveAs. However, it does not contrast with specific sibling tools like solidworks_open_document or solidworks_exchange.

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

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

Adds significant context beyond annotations: 'not a sandbox' warns of full access, 'Prints are captured' describes output behavior, 'Globals: sw, cad, cam...' explains the environment, and 'Background jobs' explains concurrency. Aligns with destructiveHint and openWorldHint.

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 dense paragraph, front-loaded with the core action. Every sentence adds value: environment, capabilities, and notes on execution. Efficient and appropriately sized for a complex tool.

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

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

Covers the script environment, supported features, background execution, and non-sandbox nature. With an output schema present, it doesn't need to detail return values. It could be more explicit on how to assign results, but overall adequate for a script execution tool.

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

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

Schema coverage is 0%, so description must explain parameters. It mentions 'parameters' as a global but does not directly explain the 'source' or 'background' parameters. 'Background jobs' hints at the background parameter, but no explicit mapping. Fails to fully compensate for missing schema descriptions.

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

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

Clearly states 'Execute trusted Python on the COM apartment', specifying the verb and resource. Also differentiates from siblings by noting it's 'Full local code execution, not a sandbox', implying generic script execution vs. specific operations.

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

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

Provides some guidance: 'Background jobs allow lengthy CAD/CAM computation' suggests when to use background. But does not explicitly mention alternatives or when not to use this tool. The generic nature is implied but not contrasted with siblings.

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 does not mention side effects, destructive behavior, or safety considerations, relying solely on annotations (destructiveHint: true). It does not explain the behavioral implications of the operations, such as sketch modification or rebuild.

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 conveys the essential dispatch mechanism and parameter conventions without unnecessary verbosity. It is concise and well-structured.

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

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

The description lacks information about return values, output format, or examples of usage. It also does not clarify the relationship to sibling tools, making it difficult for an agent to fully understand the context and integration points.

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 provides general parameter semantics: specifies that unspecified fields fall back to defaults and that lengths/angles follow unit conventions (SI unless a `unit` field exists). However, it does not detail individual parameters, and the input schema lacks field descriptions, leaving many specifics ambiguous.

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

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

The description clearly states it is a dispatcher for sketch operations based on payload.operation, enumerating the supported operations. It identifies the resource (sketch) and the action (dispatch), but does not explicitly differentiate it from the sibling solidworks_sketch_begin tool, though the operation list incluses 'begin'.

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 dispatcher versus the specific sibling tools (e.g., solidworks_sketch_begin). The description does not mention alternatives or conditions for selecting this 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?

Annotations already flag destructive and non-idempotent behavior, and the description adds create/select and batch-add semantics without contradicting those flags. However, it does not disclose side effects such as whether an existing sketch is overwritten or how selection behaves.

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

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

The description is two concise sentences with no redundant filler. It front-loads the purpose and then provides a compact pointer to the richer alternative, making it efficient and scannable.

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 adequate for a convenience wrapper and an output schema exists, so return values need not be detailed. However, it leaves gaps around entity object formatting and behavior when a sketch already exists, which are important for correct invocation.

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

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

The description gives functional meaning to plane_name and entities by mentioning a plane and simple line/circle/rectangle entities, but it does not describe the optional document parameter or the exact structure of each entity object. With 0% schema description coverage, this is only partial compensation.

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

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

The description clearly identifies the operation as a legacy convenience for creating/selecting a 2D sketch on a plane and adding a batch of simple entities (line/circle/rectangle) in one call. It names the resource and action and distinguishes it from the more complete sketch operation dispatch.

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 directs users to solidworks_sketch's operation dispatch when the full entity/relation/dimension set is needed, providing a clear when-not-to-use and an alternative. It implies this tool is for the simple batch case, which is sufficient guidance.

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

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

The description's 'Read' aligns with the readOnlyHint and idempotentHint annotations, and there is no contradiction. However, it adds no additional behavioral details beyond what the annotations already convey, so it meets the baseline but does not exceed it.

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 well-structured and directly states the tool's function. There is no redundant or extraneous information.

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

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

Given that the tool has no parameters and is a simple read operation, the description is sufficiently complete. It clearly indicates what is read (template paths) and the scope (configured defaults), which is enough for an agent to invoke it correctly.

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

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

The tool has no parameters, so the schema coverage is effectively 100%. With zero parameters, the baseline is 4, and the description does not need to explain any parameter details. It appropriately focuses on the tool's purpose.

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

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

The description clearly states the action ('Read') and the specific object ('configured default part, assembly and drawing template paths'). It is unambiguous and distinct, though it does not explicitly compare to sibling tools, the specificity is sufficient.

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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or conditions. It is a simple read operation, but the lack of explicit usage context lowers the score.

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