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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is symmetric and defaults to all edges, which is useful, but it does not disclose whether the operation is destructive, whether it requires an open part, how it interacts with existing features, or what the output/return value is. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single sentence with no wasted words. It front-loads the action and resource, and the default behavior is stated efficiently. 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 3 parameters, no annotations, and no schema descriptions, the description is too sparse. It does not explain the offset parameter's units/semantics, how edge_indices are used, what the tool returns (despite an output schema existing), or any prerequisites. An agent would likely need to inspect the schema or guess at the chamfer dimensions. The description is not complete enough for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'edges of a body' and 'default all edges', which maps to body_id and edge_indices, and 'symmetric chamfer' maps to offset. However, it does not explain the meaning of offset (e.g., distance, angle) or the format of edge_indices, leaving some ambiguity. The description adds some value but does not fully compensate for the lack of schema descriptions.

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

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

The description states a specific verb ('Create') and resource ('a symmetric chamfer on edges of a body'), and adds the default behavior ('default all edges'). It is clear enough to distinguish from sibling tools like nx_edge_blend (which is likely a fillet/blend operation) and nx_extrude, though it does not explicitly name a sibling alternative.

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: it is for creating a chamfer on edges, with all edges as the default. It does not explicitly state when to use this tool versus nx_edge_blend or other edge operations, nor does it mention prerequisites like having a body selected or a part open. The context is clear but exclusions/alternatives are not addressed.

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

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

With no annotations provided, the description carries the full burden. It discloses that the original body is kept, that new instances are independent bodies (NOT united), and that count includes the original. It also clarifies that angle is total sweep, not per-instance rotation. This is strong behavioral disclosure for a patterning operation, though it does not mention whether the operation is reversible or if it modifies the original body in place.

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

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

The description is compact and front-loaded with the core action, then explains the two critical parameters and the behavioral caveat about independent bodies. Every sentence earns its place, and the note about nx_unite is a useful pointer without being verbose.

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

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

The description covers the essential semantics for a patterning tool: what it does, how count and angle work, and the independence of resulting bodies. It does not explain the 'reverse' parameter or the output schema, but the output schema exists and the reverse parameter is a simple boolean with a default. The description is complete enough for an agent to invoke the tool correctly in most cases.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the meaning of count (total instances including original) and angle (total sweep in degrees), which are not obvious from the schema alone. It also clarifies the center parameter as the axis point. However, it does not explain the 'reverse' parameter or the 'body_id' parameter, though those are relatively self-explanatory from 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 states a specific verb ('Pattern'), a resource ('a body'), and the manner ('circularly about an axis through center'). It clearly distinguishes this from siblings like nx_linear_pattern and nx_mirror by specifying circular patterning about an axis. The description also clarifies the semantics of count and angle, which are essential for correct use.

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

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

The description explains the key parameters and their semantics, and explicitly notes that the original body is kept and instances are independent bodies, with a pointer to nx_unite if merging is required. It does not explicitly state when to use this tool versus alternatives like nx_linear_pattern or nx_mirror, but the circular pattern behavior is clear enough to infer the appropriate context.

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

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

With no annotations provided, the description must convey behavioral traits itself. It states the action and the save option, but does not disclose that closing without saving (save=false) discards unsaved changes, that the operation may fail if no part is active, or that it is a destructive action. These are significant gaps for a state-changing tool.

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

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

The description is a single, compact sentence that leads with the primary action and immediately clarifies the optional behavior. Every word serves a purpose, with no redundancy or filler, making it highly efficient for an agent 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 tool with one parameter and no annotations, the description is too sparse. It does not cover error conditions (e.g., what happens if there is no active part), side effects (e.g., unsaved data loss when save=false), or any confirmation/return behavior. While the tool is simple, the description should disclose at least the destructive implication of not saving, which it fails to do.

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 single 'save' parameter is well-named and its type (boolean) and default (true) are self-explanatory. The description references the option to save, which maps directly to the parameter, but adds no further meaning beyond the schema. With 0% schema description coverage, the tool description partially compensates, but the semantics are still evident from the schema itself, so a baseline of 3 is appropriate.

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

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

The description uses a clear verb ('Close') and a specific resource ('active work part'), and states the optional save behavior. It distinguishes itself from siblings like nx_save_part (which only saves) and nx_open_part (which opens), making the purpose unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that it is for ending work on a part, nor does it contrast with nx_save_part or nx_open_part. There is no explicit when-to-use or when-not-to-use context, leaving the agent to infer 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates that the operation creates a counterbore and that the counterbore originates from the top face, but it does not mention side effects on the body, whether the feature is added to the feature tree, units, failure modes, or reversibility.

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

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

The description is two sentences with no filler. The core action and geometry are front-loaded, and the sibling differentiation appears in the second sentence without wasting words.

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

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

For a 7-parameter CAD feature tool with no annotations and no schema-level descriptions, this is only minimally adequate. The output schema reduces the need to explain return values, but the description still lacks enough guidance on body_id, center coordinates, start_offset semantics, and clear routing between counterbore and countersink alternatives.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of prose explanations. It does add useful meaning by relating hole_diameter and counterbore_diameter as 'smaller' and 'larger', and hole_depth and counterbore_depth as 'deep' and 'shallow', but it leaves body_id, center, and start_offset semantically 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 a specific action ('Create') and a specific resource ('coaxial counterbore hole'), and provides a concrete geometric definition: a smaller deep through hole plus a larger shallow counterbore from the top face. It also explicitly distinguishes itself from the sibling tool nx_hole with the phrase 'Independent from nx_hole.'

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 conveys that this tool is for creating counterbore holes and that it does not depend on nx_hole, which offers some usage differentiation. However, it does not explicitly state when to choose this tool over the closely related nx_countersink_hole, nor does it give conditions or exclusions for 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the geometry (through cylinder plus conical countersink) and that it is independent, but it does not disclose potential side effects, such as whether it requires an active part or sketch, how it interacts with existing bodies, or whether it modifies the body in place. It also does not mention error conditions or prerequisites.

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

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

The description is concise, at roughly 25 words, and front-loads the key purpose early. It avoids unnecessary details, though it could better structure the information by adding usage guidance. Overall, it is efficient and no sentences are wasted.

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

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

The tool is moderately complex with 7 parameters, no annotations, and an output schema that is not described. The description provides the basic geometry composition but lacks critical context such as prerequisites (e.g., active part, coordinate system), how the tool affects the model (e.g., creates a feature on a body), and any parameter relationships (e.g., countersink angle range). The output schema exists, so the return format is covered elsewhere, but the input semantics are under-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?

The schema has 7 parameters with 0% description coverage, meaning the descriptions in the schema are minimal. The tool description mentions 'hole_diameter' and 'countersink_diameter' implicitly but does not define them beyond their names. It does not explain the meaning of 'start_offset' or 'countersink_angle' relative to the geometry, nor how the parameters relate to the conical shape. A 2 is justified because the description adds some context but fails to compensate for the lack of schema descriptions on critical parameters.

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

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

The description clearly states it creates a coaxial countersink hole with a conical shape, explicitly mentioning the smaller through cylinder and conical countersink from the top face. It also distinguishes itself from sibling tools by stating 'Independent of nx_hole / nx_counterbore_hole,' which helps differentiate it from similar hole-creation tools.

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

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

The description does not explicitly state when to use this tool versus alternatives like nx_counterbore_hole or nx_hole. It only says it is 'independent of' those tools, which implies it is a separate option but does not explain the conditions for choosing it, such as when a conical countersink is needed versus a counterbore or plain hole.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects and requirements. It only states the action, omitting details such as whether an existing part is overwritten, if a workspace must be configured, or what the response contains. This is insufficient for a mutation operation.

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

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

The description is a single sentence, which is concise, but it's under-specified rather than appropriately concise. It fails to include essential context, making it more of a placeholder than a useful description. The lack of structure or front-loaded key details reduces its effectiveness.

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 create operation in a CAD environment with an output schema present, the description still omits necessary context like workspace prerequisites, error conditions, or the meaning of the output. It is not complete enough for an agent to call it confidently, especially with no parameter documentation.

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

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

The schema description coverage is 0%, and the description provides zero information about the 'path' or 'units' parameters. An agent cannot infer what a valid path looks like or how units affect the part creation. This is a critical gap since the schema itself lacks 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 uses the verb 'create' with the resource 'part', clearly stating the action and target. However, it doesn't distinguish itself from sibling creation tools like nx_create_sketch, nor does it clarify what constitutes a 'part' (e.g., a CAD model file). It's specific enough to be understood but lacks differentiation.

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

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

No guidance is given on when to use this tool versus alternatives such as nx_open_part or nx_create_sketch. There is no mention of prerequisites like an active workspace or conditions under which this tool is appropriate, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that the tool both creates and activates a sketch, but it does not mention side effects, failure conditions, or whether previous sketch state is affected. This is sparse for a mutating operation.

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

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

The description is a single concise sentence with no filler, clearly front-loading the core action. However, its brevity leaves out contextual and behavioral information that would make it more useful.

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

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

The tool is simple and an output schema exists, but there are no annotations and the description is minimal. Missing usage guidance, parameter semantics, and prerequisites leave the agent without enough context to reliably decide when and how to invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only hints at the 'plane' parameter through 'principal datum plane' and says nothing about the 'name' parameter or its optional/nullable behavior. The schema enum and default help, but the description adds little parameter meaning.

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

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

The description states a specific action ('Create and activate') and a specific resource ('a sketch on a principal datum plane'), making the purpose clear. It distinguishes the tool from sibling sketch geometry, listing, and finishing tools, though it does not explicitly name any sibling alternative.

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

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

The description gives no guidance about when to use this tool versus alternatives such as nx_finish_sketch or sketch geometry tools. It also omits prerequisites like whether a part must be open or whether an existing active sketch must be finished first.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the default of all edges, which is a useful behavioral hint, but it does not state whether the operation is destructive, whether the body is modified in place, if it is reversible, or any side effects on the model. For a mutating operation like a fillet, this is a significant gap.

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

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

The description is a single, efficient sentence that communicates the core purpose and the default behavior. It is front-loaded with the action and resource, and every word serves a purpose. It is appropriately short for such a simple operation, though it could be slightly more detailed without losing conciseness.

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

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

Given the tool is a CAD operation that likely modifies a body, the description lacks essential context such as whether the body must be selected or open, the effect on the feature tree, or any return value. Although an output schema exists, the description does not explain what happens to the body or how to verify the result. The lack of annotations makes this gap more pronounced, leaving the agent with insufficient information to invoke the tool confidently.

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 (0%), so the description must compensate. It does clarify that edge_indices defaults to null meaning all edges, which adds meaning beyond the schema's default null. However, it does not explain the radius or body_id parameters, leaving them to be inferred from their names. Partial compensation is achieved, but not fully.

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

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

The description clearly states the action ('Create an edge blend') and the target ('on edges of a body'), which is a specific verb-resource pair. It also notes the default behavior ('default all edges'), which adds precision. However, it does not explicitly differentiate from the sibling nx_chamfer, which also operates on edges, so it misses a chance to disambiguate.

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

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

There is no guidance on when to use this tool versus alternatives like nx_chamfer, nor any mention of prerequisites (e.g., an open part with a body). The description implies it is for creating fillets but does not state any exclusions or contexts where it should not be used. An agent would have to infer usage from the name and schema.

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

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

With no annotations provided, the description carries the full burden. It discloses the main behavioral outcome—a STEP export of the active part into a workspace—but does not mention potential side effects like file overwriting, naming behavior, or failure if no part is active. It is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds meaning: the action, the subject, the format, and the destination are all stated directly.

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?

Although the tool is simple and has an output schema, the description still leaves the required 'path' parameter semantically ambiguous. An agent cannot reliably construct a correct call without understanding whether path is a file name, a folder, or a workspace-relative location. The missing parameter guidance is a significant gap.

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

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

Schema description coverage is 0%, and the description does not explain the required 'path' parameter beyond the schema's bare title. The phrase 'inside the configured workspace' hints at where the path resolves, but it does not clarify whether path is a filename, directory, relative path, or absolute path.

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

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

The description states a specific verb (export), a precise resource (active work part), a format (STEP), and a destination (configured workspace). This clearly differentiates it from siblings like nx_save_part or nx_release because it identifies the exact action and output type.

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 about when to use this tool versus alternatives such as nx_save_part or nx_release. The description implies an export workflow but does not state prerequisites, exclusions, or conditions where a different tool should be chosen.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the two operations (create and subtract) but omits side effects, requirements (e.g., whether a target body is mandatory for subtract), error conditions, or how the extrude interacts with the feature tree. This is minimal disclosure for a complex CAD operation.

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

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

The description is a single, direct sentence with no redundant words. It front-loads the core purpose and immediately distinguishes the two modes. This is exemplary conciseness.

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

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

Given the tool has 6 parameters, 2 required, no annotations, and a schema that leaves all parameters self-explanatory, the description is inadequate. It does not cover prerequisites, parameter meanings, failure modes, or expected outputs. An agent would need to infer too much, making the description 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?

Schema description coverage is 0%, so the description must compensate for parameter documentation. It hints at the 'operation' parameter (create vs subtract) and 'target_body_id' implicitly via 'existing target body', but it does not explain 'distance', 'reverse', 'start_offset', or the interplay between these. The description adds minimal value beyond the raw schema.

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

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

The description clearly states the verb 'Extrude' and the resource 'a sketch', and specifies the two distinct outcomes: creating a new body or subtracting from an existing target body. This differentiates it from sibling tools like nx_hole or nx_chamfer, which have different purposes.

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

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

The description implies usage (converting a sketch into 3D geometry or cutting) but does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites (e.g., the sketch must be closed or the part must be open). It provides context but no exclusions or alternative tool references.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'deactivate and finish', which implies ending sketch editing but does not explain side effects (e.g., whether changes are committed, if the sketch becomes immutable, or any error conditions). No prerequisites or consequences are mentioned.

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

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

The description is a single, efficient sentence with no filler. The action is front-loaded, and 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?

Although the tool is simple (one parameter, output schema present), the description omits usage guidance and behavioral details. Given the absence of annotations, an agent lacks enough context to correctly invoke it, such as when it is appropriate or what happens after finishing. The output schema covers return values, but the operational context is incomplete.

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

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

Schema description coverage is 0%, and the description adds no explanation of the sketch_id parameter beyond the schema's minimal title 'Sketch Id'. The description's phrase 'explicit sketch reference' is not clearer than the schema. Since it does not compensate for the lack of schema documentation, the score is low.

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 clear verb ('deactivate and finish') and resource ('explicit sketch reference'), indicating the action of ending a sketch. It is distinguishable from siblings like nx_create_sketch or nx_sketch_line, though the term 'explicit sketch reference' is somewhat jargon-heavy and could be clearer.

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. There is no mention of prerequisites (e.g., an active sketch) or when not to use it, leaving the agent to infer usage context from the name and 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?

No annotations are provided, so the description carries full behavioral burden. It states that the tool operates on the active modeling view, implying a non-destructive camera/view change, but it does not explicitly confirm that the model geometry is unaffected or describe any side effects.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word contributes to understanding 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?

For a zero-parameter view command with an output schema present, the description is nearly complete. It lacks only explicit behavioral guarantees like 'does not modify the model' or usage notes, but these are minor for such a straightforward tool.

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

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

The tool has zero parameters, so there is no parameter information to convey. The schema coverage is 100% trivially, and the baseline for zero-parameter tools is 4; the description cannot add meaningful parameter semantics beyond the schema.

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

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

The description uses a specific verb ('Fit') and resource ('active modeling view'), making the tool's function immediately clear. It is also implicitly distinguishable from all sibling tools, none of which target view fitting, so no ambiguity exists.

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

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

The description implies when to use the tool: when the user wants to fit the active modeling view. However, it does not explicitly state any conditions, exclusions, or alternatives, relying entirely on the operation name and conventional CAD knowledge.

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

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

No annotations are provided, so the description carries the full burden. It explicitly discloses that the operation performs a boolean subtract on the target body, which signals a mutating, non-read-only operation. However, it does not mention permanence, reversibility, failure behavior, or what parts of the body are affected.

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

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

The description is a single front-loaded sentence with no filler or redundancy. It states the core action and mechanism immediately, which is appropriately concise for the information it conveys.

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

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

Given five parameters, no annotations, and a destructive CAD operation, the description is incomplete. It omits prerequisites (such as an open part and an existing body), numeric semantics for depth and start_offset, and any coordinate-system context, so an agent cannot reliably invoke it without additional information.

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 parameter guidance. It does not explain the meaning of depth, start_offset, the coordinate frame for center, or units, leaving the agent to interpret these from raw schema 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 names a specific verb and resource ('Create a hole on a target body') and explains the underlying method ('circle sketch + boolean subtract'), which clearly differentiates it from sketching or extrusion siblings. It does not explicitly name a sibling tool, but the action is unambiguous enough for an agent to select it.

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

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

There is no guidance about when to prefer this tool over alternatives such as nx_extrude, nx_create_sketch, or nx_sketch_circle. The description only implies a hole-creation use case, with no exclusions, prerequisites, or comparisons to sibling tools.

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

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

Annotations are not provided, so the description must carry the full burden of behavioral disclosure. It does mention key traits: the original body is kept, instances are independent (not united), and spacing is in mm. However, it does not disclose potential side effects like performance implications with large counts (max 1000), whether the pattern is associative/parametric, or what happens if the body_id is invalid. The schema provides constraints but not behavior. This leaves gaps for a mutation tool.

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, with three sentences that efficiently cover purpose, key semantics, and a critical caveat. It is front-loaded with the primary action and axis. Every sentence adds value with no redundancy.

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

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

For a cad tool with 5 parameters to infer the correct behavior. The description covers the main semantics but lacks information on the 'reverse' parameter and potential errors (e.g., invalid body_id) or output structure (though output schema exists). The tool is moderately complex (pattern with multiple axes and merging behavior), and the description is adequate but not exhaustive, missing minor but useful context.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'count' as total including original (count=4 yields 4 bodies) and 'spacing' as per-instance delta in mm, adding meaning beyond the schema titles. However, it does not clarify the 'direction' parameter's values (X/Y/Z are self-explanatory) or 'reverse' semantics, which the schema already defines with defaults. The description covers the core parameters but leaves some to be inferred.

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 ('Pattern'), a specific resource ('a body'), and the axis options ('X/Y/Z'). It clearly distinguishes from siblings like 'nx_circular_pattern' by specifying 'linearly'. This is clear and unambiguous.

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

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

The description provides clear context for when to use this tool: patterning linearly, versus circular alternatives. It also gives a critical usage note that the new instances are NOT united, and directs use of 'nx_unite' if merging is required. However, it does not explicitly say when NOT to use this tool beyond the circular alternative, but the guidance is strong enough for an agent to decide.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'list,' which implies read-only, but it never states that the part is not modified, what happens when no part is active, or whether hidden/blanked bodies are included.

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

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

A single, front-loaded sentence with no filler or redundancy. Every word contributes to identifying the action and scope.

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

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

For a zero-parameter list tool with an output schema, the description is nearly sufficient: it identifies the target resource and active-part context. The main gap is the lack of any behavioral caveat, such as requiring an open part or describing 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?

The tool has zero parameters and schema description coverage is 100%, so there is nothing for the description to add to parameter semantics. Baseline of 4 applies.

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

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

States a specific verb ('List'), resource ('bodies'), and scope ('active work part'). This differentiates it from sibling tools like nx_list_sketches and nx_list_features by resource type, so an agent can select the correct tool without needing more detail.

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 active-work-part scope provides clear context and an implicit prerequisite, but the description gives no explicit when-to-use guidance or alternatives. It does not say, for example, to use nx_list_features for features or what to do when no active part exists.

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

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

With no annotations provided, the description carries the safety burden and explicitly states 'Read-only' and 'Inspect every edge', making it clear this is non-mutating and comprehensive. It does not discuss errors or edge cases, but for a read-only inspection tool the disclosure is strong.

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

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

A single sentence front-loads the action and resource, then efficiently lists the returned fields. Every word earns its place and there is 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?

Given the simple one-parameter input and existing output schema, the description covers purpose, scope, and safety sufficiently. It is only missing explicit guidance about sibling tools, but that deficit is already accounted for in the usage-guidelines dimension.

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

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

The only parameter, body_id, is largely self-explanatory, and the description reinforces that it refers to the body being inspected. With 0% schema description coverage, however, the description does not add details about the expected ID format or how to obtain it.

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

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

The description states a specific verb ('Inspect every edge') and a clear resource ('a body'), and enumerates the exact data returned. It naturally differentiates from siblings like nx_list_faces and nx_list_bodies by focusing specifically on edges.

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

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

The intended use is implied: call this when you need detailed edge geometry and topology of a body. However, it does not explicitly say when to prefer this over nx_list_faces or nx_list_bodies, nor does it mention prerequisites such as the body already being loaded.

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

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

With no annotations, the description carries safety disclosure and explicitly adds 'Read-only', which is meaningful for an inspection tool. It also discloses a non-obvious output nuance: normal is reported only for planar faces. It does not cover invalid body_id or empty-body behavior, but this is a minor gap for a read-only listing operation.

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

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

Single purpose-built sentence, front-loaded with the verb and resource, followed by a bullet-like list of returned fields and the read-only flag. 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?

The output schema covers return value structure, and the description enumerates the returned face attributes, so an agent can predict the call's behavior. It omits prerequisites such as needing an open part or a valid body_id from nx_list_bodies, but the omission is unlikely to cause incorrect 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 only parameter is `body_id`, and although the schema gives no description, the phrase 'of a body' ties the parameter directly to the resource being inspected. For a single self-descriptive identifier this is sufficient compensation for the 0% schema coverage.

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

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

States a specific action ('Inspect'), a clear resource ('every face of a body'), and enumerates the exact data returned. This makes it immediately distinguishable from siblings such as nx_list_edges, nx_list_bodies, and nx_list_features.

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 makes the intended use obvious (face inspection) but does not explicitly state when to prefer it over alternatives or mention that edge/body/sketch listing has separate tools. The when-to-use is implied by scope, not stated as 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It states the operation is a read-only listing, which is useful, but it does not disclose what happens if no part is active, whether the list is ordered, or what the output structure looks like. The behavior is simple enough that 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 a single, short sentence that states the action and the target resource. Every word earns its place, and there is no redundant or vague 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 zero-parameter list tool, the description is mostly complete: it names the resource and the scope. However, it does not mention what the output schema contains or any error conditions (e.g., no active part), and with no annotations, a bit more context about the expected result would improve completeness.

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

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

The tool has zero parameters, so the schema provides no parameter semantics to clarify. The description correctly identifies the scope ('active work part'), which is the only contextual input the agent needs. With no parameters, a baseline of 4 is appropriate.

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

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

The description uses a specific verb ('List') and a clear resource ('features in the active work part'). It distinguishes itself from sibling tools like nx_list_sketches and nx_list_bodies by naming the resource type, though it does not explicitly contrast with those siblings.

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

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

The description implies usage context: it operates on the active work part, so an agent can infer it should be used when features need to be enumerated. However, it does not explicitly state when to use this tool versus alternatives like nx_list_sketches or nx_list_bodies, nor does it mention prerequisites like having an active part open.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation by using 'List', but doesn't explicitly state non-destructiveness, required state (an active work part), or what happens if no part is open. No mention of return format or side effects. This is minimal transparency.

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

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

The description is a single, focused sentence that front-loads the action ('List') and the resource ('sketches'). There is no wasted wording, and it is appropriately sized for a tool with no parameters. It 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 simple list tool with no parameters and an output schema (which covers return values), the description is adequate but incomplete. It mentions 'active work part' but doesn't clarify prerequisites or edge cases (e.g., what if no part is active). It lacks any usage context that would help the agent decide when to call it. Given the simplicity, a 3 reflects that it meets the minimum but leaves gaps.

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

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

The tool has zero parameters, so per the baseline rule, a score of 4 is appropriate. The description doesn't need to explain parameters, and it doesn't add any parameter-related detail, which is fine.

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 verb ('List') and resource ('sketches') with a context ('active work part'). It distinguishes itself from siblings like nx_create_sketch and nx_finish_sketch, which imply creation or completion. No ambiguity about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., an open part) or suggest scenarios like 'before creating a sketch' or 'to review existing sketches'. The agent is left to infer usage from the tool name and 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?

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the key behavioral trait that the mirrored body is created as an independent body and is NOT united with the source, and explains how offset moves the mirror plane. It does not explicitly state whether the source body is preserved, but the wording strongly implies that the source is not consumed.

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

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

The description is three sentences, each delivering distinct value: the core operation, the parameter semantics, and the resulting body relationship with an alternative tool reference. There is no filler or redundant restating of the parameter schema.

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

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

The description covers the main operational semantics, names the relevant sibling tool, and explains the effect of both custom parameters. Since an output schema exists, return-value details are not required. The only small gap is that it does not explicitly state whether the source body is left unchanged, though it is reasonably implied.

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 property descriptions, so the description compensates by explaining plane's enum values and offset's meaning in mm with a default of 0. body_id is left to inference from its name and the phrase 'a body,' which is a minor gap but not a serious one given 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 opens with a specific verb-resource pair, 'Mirror a body about a datum plane,' and immediately clarifies the plane options. It also distinguishes itself from related operations by stating that the mirrored body is independent and not united with the source, which separates it from merge/boolean tools like nx_unite.

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 clear context for the operation and explicitly names the alternative when merging is required: 'use nx_unite if merging is required.' It does not enumerate all situations where mirroring should or should not be used, but the operation is specific enough that this minimal guidance is reasonably sufficient.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Open a part,' with no explanation of side effects on the current session, whether the part becomes the active part, what happens to previously opened unsaved parts, or what errors or state changes may occur.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is concise and easy to parse, though the brevity contributes to the under-specification of behavior and parameters.

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

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

For a tool with no annotations, one undocumented parameter, and sibling tools that perform similar lifecycle operations, the description is incomplete. It does not explain the expected path format, what 'open' changes in the workspace state, or when to choose this operation over related tools. The presence of an output schema does not make up for these gaps.

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

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

Schema description coverage is 0%, and the only parameter 'path' has no schema-level explanation. The description adds that the part comes from the 'configured workspace,' but it does not clarify whether the path is absolute, relative to the workspace, includes a file extension, or what format is expected. This is minimal compensation for an undocumented parameter.

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

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

The description states a specific verb and resource: 'Open a part' from the 'configured workspace.' It clearly communicates the core operation and is distinguishable from siblings like nx_create_part, nx_save_part, and nx_close_part by the word 'open,' though it does not explicitly name 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?

The description provides no guidance on when to use this tool versus nx_create_part, nx_close_part, or other siblings. It implies loading an existing part by saying 'from the configured workspace,' but it does not say when this is appropriate or when another tool should be used instead.

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

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

With no annotations provided, the description fully carries the burden of behavioral disclosure. It explains that the current command completes before release, the journal ends, NX becomes interactive without restart, and the bridge can be restarted via Alt+F8. This is comprehensive for a control operation.

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

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

The description is two short paragraphs, front-loaded with the purpose. Every sentence adds value: the first states the action and outcome, the second explains the sequencing and how to resume. No repetition or fluff.

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

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

For a zero-parameter tool, the description is complete. It explains what happens (command completes, journal ends, NX interactive), how to resume (launcher journal), and the lack of restart requirement. An agent has enough to invoke it correctly without additional context.

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

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

The tool has zero parameters, and the schema covers them trivially (100% coverage). The description explains the function's effect without needing parameter details. Baseline for zero params is 4, and the description adds context about the release behavior, so a 4 is appropriate.

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

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

The description clearly states the action ('Gracefully stop the bridge and release the NX GUI for manual editing') and identifies the resource (the bridge and NX GUI). It distinguishes from siblings by describing a control action rather than a modeling or query operation, which is unique among the listed tools.

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

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

The description explains the context for use: after the current command completes, the journal ends and NX becomes fully interactive. It also mentions how to start the bridge again later (run the launcher journal via Alt+F8). However, it does not explicitly state when NOT to use this tool or compare to alternatives, but the usage context is clear enough.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose a key behavioral trait: the operation creates a new solid only and does not unite or subtract. It also specifies the angle range (0 < angle <= 360) and that the axis is defined in sketch XY coordinates. However, it does not mention what happens if the sketch is not closed, whether the operation is reversible, or what the output schema contains. Given the lack of annotations, this is a moderate score.

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

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

The description is compact and front-loaded. The first sentence states the core action and constraint. The second sentence adds essential parameter semantics and the angle range. Every sentence earns its place, and there is no fluff or repetition of schema details.

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, so the description need not explain return values. The description covers the core behavior, the axis definition, and the angle constraint. It does not mention prerequisites like having a closed sketch or an active sketch context, but the sibling tools (nx_create_sketch, nx_finish_sketch) imply the workflow. Given the complexity of a revolve operation, a brief note about the sketch being closed would improve completeness, but the current description is largely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the meaning of axis_start, axis_end, and angle, which are the non-obvious parameters. It does not explain sketch_id or reverse, but sketch_id is self-explanatory and reverse is a common boolean flag. The description adds meaningful semantics for the most complex parameters, so it earns a 4.

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

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

The description states a specific verb ('Revolve'), a specific resource ('a closed sketch section'), and a key constraint ('around an in-sketch 2D axis'). It also clarifies the operation mode ('Creates a new solid only (no unite/subtract)'), which distinguishes it from other modeling operations like nx_extrude or nx_unite. This is a clear, specific purpose statement.

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 clearly implies when to use this tool: when you need to revolve a sketch section around an axis. It also explicitly states what it does NOT do ('no unite/subtract'), which helps an agent avoid using it when a boolean operation is needed. However, it does not explicitly name alternative tools or provide a when-not-to-use list, so it falls slightly short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action without addressing side effects. It does not say whether the save overwrites an existing file, what happens if no part is active, or whether the operation can fail.

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

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

The description is one short, front-loaded sentence with no filler. It supplies exactly the needed information for a parameterless command and does not waste tokens.

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 tool, 'Save the active work part' is nearly complete: it names the object and the action. It falls slightly short because it does not specify behavior when no part is active or whether the save is a persistent overwrite, but the output schema can cover result details.

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

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

The input schema has zero properties, so there are no parameter semantics for the description to add. Since there are no parameters, the baseline of 4 applies and the description appropriately references the contextual 'active work part' state.

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

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

The description uses a specific verb ('Save') and identifies the exact resource ('active work part'), making the tool's core function clear. It doesn't explicitly name or contrast sibling tools like nx_close_part or nx_release, but the action of saving is distinct enough that an agent can tell it apart.

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

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

The description gives no guidance on when to invoke this tool versus alternatives such as nx_close_part or nx_release. There is no mention of prerequisites (e.g., an active part must exist) or of typical sequences like saving before closing.

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

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

With no annotations, the description must disclose behavior. It explains that 'inward=True keeps the outer dimensions,' which is a key behavioral detail about how wall thickness is applied. It also mentions the single-face limitation. However, it does not explicitly state that the operation modifies the body in place or any side effects, but the output schema covers return details, so the description provides reasonable behavioral 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 two sentences with no filler. It front-loads the core purpose and immediately follows with the key behavioral detail about the inward flag. Every word earns its place, making it 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 tool has an output schema, so return values are already covered. The description provides the essential purpose, the inward behavior, and the single-face limitation. It does not explicitly explain how to choose the face index or what thickness units are used, but these are relatively minor gaps. Overall, it is complete enough for an agent to call the tool correctly in most situations.

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

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

Schema coverage is 0%, so the description should compensate. It explains the 'inward' parameter's effect ('inward=True keeps the outer dimensions'), adding meaning beyond the schema title. However, it does not describe 'body_id', 'thickness', or 'remove_face_index' directly, though their names and schema titles are fairly self-explanatory. The description adds partial value but does not fully document all parameters.

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

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

The description states a specific verb (shell) and resource (a body), and explains the operation: remove a face and keep constant wall thickness. It clearly distinguishes from sibling tools like extrude or revolve, which are different modeling operations. The purpose is unambiguous and immediately understandable.

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

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

The description implies when to use this tool: when you want to hollow out a body with a single opening. It notes a limitation ('First version removes a single face'), which helps agents decide if this tool is appropriate for multi-face scenarios, but it does not explicitly name alternatives or state when not to use it. The context is clear enough for most cases.

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

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

No annotations are provided, so the description carries the full behavioral burden. It clearly says the operation is additive ('Add') and scoped to an explicit sketch reference, and that angles are in degrees. It does not disclose sketch-state prerequisites, angle origin/direction, or behavior on invalid references, but the core operation is transparent enough for a simple sketch-entity tool.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase contributes meaning: the operation, the entity type, the defining parameters, and the target sketch reference.

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 moderate-complexity tool with five parameters and no annotations, the description is minimally viable but not rich. It covers the purpose and all key parameters, but it omits usage guidance, angle convention, sketch-state requirements, and behavior when the sketch is unavailable, so the agent must rely on standard CAD assumptions.

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

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

With 0% schema description coverage, the description partially compensates by enumerating center, radius, start/end degrees, and the explicit sketch reference. It adds the meaningful detail that angles are in degrees, but it does not explain coordinate-system conventions, angle direction, or the Point2D format beyond what the schema already defines.

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

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

The description names a specific verb ('Add') and resource ('an arc ... to an explicit sketch reference'), and it identifies the defining inputs: center, radius, and start/end degrees. This makes it easy to distinguish from sibling sketch tools such as nx_sketch_circle, nx_sketch_line, and nx_sketch_rectangle.

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 intended use is reasonably implied: add an arc to an explicitly referenced sketch. However, the description does not explicitly state when not to use it or point to alternatives, such as using nx_sketch_circle for a full circle, leaving the agent to infer the choice from the tool name.

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

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

No annotations are provided, so the description bears the full responsibility for behavioral disclosure. It only says 'Add a circle,' which implies a mutation but does not disclose side effects (e.g., whether the sketch is modified in place, whether prior geometry is affected), error conditions (e.g., if sketch_id is invalid), or the return value despite the presence of an output schema. The description adds minimal behavioral context beyond the action itself.

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

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

The description is a single, direct sentence with no unnecessary words. The key action and object are front-loaded, and it avoids fluff. While it is terse to the point of under-specification, that is a completeness issue, not a conciseness one. It earns a 4 for being concise and well-structured, though not perfect because it omits critical context that could be added without bloat.

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

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

Given the tool has three required parameters, no annotations, and an output schema (which the description does not summarize), the description is incomplete. It fails to explain the meaning of sketch_id, the units or reference frame for center and diameter, what happens on failure, or what the tool returns. For a mutation tool with these characteristics, much more is needed for an agent to call it correctly and interpret results.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'center + diameter' which aligns with the center and diameter parameters, but it does not describe the sketch_id parameter at all (only obliquely as 'explicit sketch reference'). It also does not clarify units, coordinate frame, or the exact expected structure of center. This leaves the agent to rely on the raw schema definitions, which lack explanatory detail.

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

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

The description clearly states the action (Add) and the resource (a circle defined by center and diameter) to an explicit sketch reference. It is distinct from sibling sketch primitives like nx_sketch_line, nx_sketch_rectangle, and nx_sketch_arc because it names the circle shape directly. However, it does not elaborate on what 'explicit' means (e.g., that a sketch_id must be provided) or mention the coordinate system, leaving some room for interpretation.

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 state that it should be used when a circular profile is needed, nor does it mention any prerequisites (e.g., an active sketch or that the sketch must be open). No exclusions or alternative tool references are given, leaving the agent to infer usage context entirely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a line is added, but does not mention coordinate semantics, whether the line is appended to existing sketch geometry, failure conditions, or any side effects on the part or sketch state.

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

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

The description is a single, clear, front-loaded sentence with no filler or redundant information. It efficiently communicates the core operation without wasting tokens.

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

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

The tool is simple and has an output schema, so return-value documentation is not needed. However, with no annotations and a terse description, several behavioral and usage details are left to inference, making this only minimally viable for reliable agent invocation.

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

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

Schema description coverage is 0%, and the description does not compensate. It does not explain the meaning of sketch_id, start, or end, nor does it clarify units or coordinate space. The parameter names and Point2D schema are self-explanatory to some degree, but the description adds no semantic value beyond them.

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

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

The description uses a specific verb ('Add'), a concrete object ('a line'), and a clear target ('explicit sketch reference'). It distinguishes the tool from its geometry siblings like nx_sketch_rectangle, nx_sketch_circle, and nx_sketch_arc, and the word 'explicit' signal that it targets a named sketch rather than an implicit active one.

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 almost no guidance about when to choose this tool over alternatives, whether the sketch must already exist, or whether it is meant to be used while a sketch is active. The phrase 'explicit sketch reference' hints at a requirement, but no clear when-to-use or when-not-to-use context is provided.

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

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

With no annotations provided, the description carries the full behavioral burden. It only says 'Add a rectangle' without disclosing side effects, coordinate interpretation, orientation, prerequisites, constraints, or what happens if the sketch reference is invalid. Significant behavioral details are left unspecified.

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

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

The description is a single, efficient sentence with no wasted words. The action and target are presented directly and front-loaded, making it easy to scan.

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

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

For a 3-parameter tool with zero schema description coverage and no annotations, the one-line description is too sparse. It omits parameter semantics and behavioral details needed to call the tool correctly, despite the presence of an output schema.

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

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

Schema description coverage is 0%, and the description names none of the parameters. The meanings of sketch_id, corner1, and corner2 are completely undocumented, so the agent cannot infer that corner1/corner2 likely define opposite diagonal corners of the rectangle.

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 clear verb ('Add') and resource ('rectangle') plus an explicit target ('explicit sketch reference'), which distinguishes it from sibling sketch tools like line, circle, and arc. It does not clarify whether the rectangle is axis-aligned or arbitrary, but the core 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?

Usage context is only implied: the agent must infer that this tool is for adding a rectangle to a sketch. There is no explicit when-to-use guidance, no exclusions, and no direction toward sibling alternatives such as nx_sketch_line or nx_sketch_circle.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states the tool reports status information, which implies a read-only, non-mutating operation. However, it does not disclose details such as whether it requires an open part, what happens if no part is active, or the format of the report. The description is adequate but minimal.

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

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

The description is a single, compact sentence that front-loads the verb and lists the three report categories. Every word earns its place; there is no redundancy or filler.

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

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

For a zero-parameter status tool with an output schema, the description is mostly complete. It names the three status areas (bridge, NX version, active part). However, it does not clarify whether the tool can be called without an active part or what the output schema contains, though the output schema itself may cover the return structure. The description is sufficient for basic invocation but lacks edge-case 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 there is no parameter semantics burden on the description. The schema is empty and coverage is 100%, meaning there is nothing undocumented. The description correctly implies the tool takes no input and simply reports current state.

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

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

The description uses a specific verb ('Report') and names the resources it covers ('bridge, NX version, and active-part status'). It is clear about what the tool does, though it does not explicitly distinguish it from sibling tools. Among the siblings, none appear to be status-reporting tools, so the differentiation is implicit rather than stated.

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 a diagnostic/status tool to be used when you need environment or active-part information, but it does not explicitly state when to use it versus alternatives. There are no exclusions or alternative tool mentions. The context is clear enough for an agent to infer usage, but explicit guidance is missing.

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

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

With no annotations, the description must carry the behavioral burden. It communicates only that an operation is reversed, but does not explain whether the undo is destructive, whether it applies only to MCP-created operations, what happens when there is nothing to undo, or what 'visible' means.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to the core meaning, making it easy to scan.

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

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

For a low-complexity, parameterless tool with an output schema, the one-liner is largely adequate. However, the undefined 'visible' qualifier and lack of any note about undo-stack behavior or edge cases leave a small but meaningful gap 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 input schema has zero properties and is fully covered, so there are no parameters that need documentation. The description adds nothing about parameters, but none are required; per the 0-parameter baseline, this is appropriate.

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

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

The verb 'Undo' and the resource 'last visible NX MCP operation' clearly identify the action and target. It is distinguishable from the sibling tools (none of which are undo-like), though the qualifier 'visible' is not defined and weakens precision.

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

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

No guidance is given on when to call this tool versus alternatives, nor on what conditions make an operation eligible for undo. The intent is implied by the name, but a caller receives no explicit situational context.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose the critical side effects: tool bodies are consumed and disappear from nx_list_bodies, while the target body retains its id. It does not cover undo/reversibility or error cases, but the main destructive behavior is explicit.

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, front-loaded with the action verb and a clear object. Every clause adds information: the operation, the retained id, and the side effect on the tool bodies.

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 boolean operation with an output schema, the description covers the essential semantics and side effects. It could mention prerequisites or failure modes, but the core behavior is complete enough for correct invocation.

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

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

Schema coverage is 0%, so the description must compensate. It explains the roles of both parameters: tool_body_ids are 'one or more' bodies to be united, and target_body_id is the body that survives with its id. It also points to nx_list_bodies, helping agents understand where body identifiers come from.

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

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

The description opens with a specific verb and object ('Boolean-unite ... tool bodies into the target body'), making the operation clear. It also distinguishes itself from sibling modeling operations by noting the target body keeps its id and the tool bodies are consumed.

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 clearly implies the tool is for merging bodies, but it never states when to prefer it over alternatives or lists exclusions. An agent can infer usage, yet it has no explicit when/when-not guidance relative to the many sibling operations.

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