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

Annotations already indicate idempotent and non-destructive behavior. The description adds valuable context by disclosing that the call changes focus and redirects subsequent modelling calls, which is a non-obvious side effect. It also specifies the already-open prerequisite.

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

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

The description is a single clear sentence with no filler. The core action, prerequisite, and behavioral effect are all front-loaded and easy to parse.

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

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

For a simple one-parameter tool with high schema coverage and no output schema, the description is nearly complete. It could additionally mention error behavior when the document is not open, but that is a minor gap.

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

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

The schema covers the single parameter with 'Name or full path of the document.' The description adds the important constraint that the document must already be open, which is not stated in the schema. This extra semantic context helps agents choose a valid value.

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

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

The description states a specific action: bringing an already-open document to the front and making it the target of subsequent modelling calls. This clearly distinguishes it from related siblings like catia_open_document, catia_close_document, and catia_set_active_body.

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 the tool: after a document is already open and before performing modelling operations on it. However, it does not explicitly mention alternatives or state when not to use it.

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

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

Annotations already signal mutation (readOnlyHint=false), so the description does not need to restate that. It adds context that only existing CATPart/CATProduct files are inserted and that the target is the active assembly, but it does not disclose potential side effects like assembly tree modification, broken references, or requirements about the parent instance. No contradiction with annotations exists.

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

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

The entire description is a single well-structured sentence that front-loads the verb and object. It contains no filler and every word earns its place. The one-sentence format is ideal for this simple tool.

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

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

For a two-parameter tool with full schema coverage and no output schema, the description plus annotations are largely sufficient for an agent to invoke it correctly. The main gap is that it does not explicitly state that the active document must be an assembly or explain failure behavior for invalid paths/parents, but these are edge conditions rather than core invocation requirements.

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 already fully describes both parameters, but the description adds the file-type constraint (CATPart/CATProduct), which meaningfully narrows what values 'paths' may contain. It also confirms that one or more files can be inserted at once. This goes slightly beyond the schema without repeating 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?

States a clear verb-resource pair: insert existing CATPart or CATProduct files into the active assembly. The word 'existing' differentiates this from sibling creation tools like catia_add_new_part and catia_add_new_product. No ambiguity remains about what the tool does or where it operates.

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

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

The description implies the tool is for adding pre-existing components to an assembly, which gives basic usage context. However, it does not explicitly state when to choose this tool over adding new parts/products, nor mention prerequisites like the active document needing to be an open assembly. There is no guidance on exclusions or alternatives.

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

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

Annotations already communicate that this is not read-only, not idempotent, not destructive, and not open-world. The description adds meaningful behavioral context beyond that: the attached file's columns drive parameters and rows become configurations, which clarifies the outcome of the operation. It does not discuss edge cases like overwriting an existing design table, but the annotation baseline lowers the burden.

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

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

Two concise sentences deliver the core purpose and outcome without filler. The information is front-loaded and every clause contributes to understanding the tool.

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

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

For a tool with four parameters, one required, complete schema descriptions, and annotations covering safety, the description sufficiently explains what attaching a design table does and why it is used. It does not mention return values, but there is no output schema and the operation is an action rather than a query, so this is not a significant gap.

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

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

Schema coverage is 100%, so all four parameters are already documented with descriptions. The tool description adds some context about the file format ('Excel or tab-separated') and the resulting configuration behavior, but it does not explain the remaining parameters (name, comment, copy_data) beyond what the schema already provides. Baseline 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 opens with a specific verb and resource: 'Attach a design table', then explains its purpose with 'columns drive the document's parameters' and 'Each row becomes a selectable configuration'. This is distinct from sibling tools such as catia_list_design_tables or catia_set_design_table_configuration, so an agent could identify the right operation without inspecting the schema.

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 like catia_set_design_table_configuration or catia_list_design_tables. There are no explicit exclusions or conditions, so the agent is left to infer usage solely from the verb 'attach'.

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

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

Annotations already indicate this is not read-only and not destructive, so the description adds only the location constraint ('directly inside the active assembly'). It does not disclose what happens if no assembly is active, whether the part gets a default body, or what side effects occur on the assembly tree. For a mutation tool, this is a minimal behavioral disclosure beyond the annotations.

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

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

The description is a single, well-structured sentence that is front-loaded with the core action. Every word earns its place, and it is immediately clear what the tool does. There is no unnecessary fluff or repetition.

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

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

For a simple creation tool with only two optional parameters and no output schema, the description covers the essential purpose but leaves some gaps. It does not state the requirement of an active assembly (it implies it), nor does it explain failure modes or the expected state of the part after creation. Given the large number of sibling tools, it could benefit from clarifying when this is preferable to catia_new_part or catia_add_new_product.

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 100% (both parameters have descriptions), so the baseline is 3. The description adds a small extra context: 'directly inside the active assembly' implies the parent parameter is optional and that the part is placed in the active assembly when no parent is given. However, it does not elaborate on the syntax or format of the name or parent, so it adds limited value beyond the schema.

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

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

The description clearly states the action (create), the resource (a brand-new empty part), and the context (directly inside the active assembly). It is specific enough to distinguish from similar tools like catia_new_part or catia_add_new_product, though it does not explicitly name alternatives. The phrase 'empty part' and 'inside the active assembly' add valuable specificity beyond the name.

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 its siblings (e.g., catia_add_new_product, catia_new_part, catia_add_component). It does not mention prerequisites like having an active assembly open, nor does it explain when the parent parameter should be used. Agents are left to infer usage from the name and context.

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

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

The annotations already indicate readOnlyHint=false and destructiveHint=false, so the description is not required to restate that this is a mutation. It adds the useful context that the created sub-assembly is empty and added inside the active assembly. However, it does not disclose behavior around naming conflicts, parent resolution, or what happens if no active assembly exists.

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

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

A single clear sentence, front-loaded with the primary verb 'Create' and the resource 'new empty sub-assembly.' Every word contributes meaningful context, and there is no redundant or filler content.

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 create operation with two fully described optional parameters, the description is sufficient: it states what is created, its nature, and its location. Given the schema covers parameters and annotations cover mutability, the main missing context is when to choose this over sibling creation tools, which is addressed under usage guidance.

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

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

The input schema fully describes both parameters (name and parent) and covers 100% of the schema descriptions, so the baseline is 3. The description does not add extra parameter semantics beyond reinforcing that the operation creates a sub-assembly, which aligns with the parameter names and descriptions already present.

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

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

The description clearly identifies a specific action: 'Create a new empty sub-assembly inside the active assembly.' It names the verb, resource type, and scope. It does not explicitly differentiate from closely named siblings like catia_add_new_part or catia_new_product, but 'empty sub-assembly' is specific enough to distinguish the core intent.

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 for when to use this tool over alternatives such as catia_add_new_part, catia_new_product, or catia_add_component. The only implied context is 'inside the active assembly,' but there is no mention of prerequisites, exclusions, or criteria for choosing another sibling.

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

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

Annotations already indicate a non-read-only, non-destructive mutation, so the description adds useful behavioral context beyond that: applying a material changes subsequent mass-property reporting by supplying a real density. It does not mention overwriting existing materials, but this is not a serious gap given the annotations.

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

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

Two tight sentences, no filler. The first sentence states the action and target; the second gives a valuable downstream consequence. Information is front-loaded and every clause earns its place.

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

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

For a mutation tool with fully documented parameters and no output schema, the description is largely complete: it explains what the tool does, where it applies, and the observable effect on mass properties. It could mention what happens if a material is already applied or if the body does not exist, but these are not essential for correct invocation.

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

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

The input schema already documents all four parameters with descriptions, and schema coverage is 100%. The description's mention of 'active part or a named body' mirrors the body parameter but adds little beyond what the schema already provides.

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

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

The description names a specific action ('Apply a material'), a precise resource ('CATIA catalogue', 'active part or a named body'), and the consequence for downstream mass properties. This distinguishes it clearly from sibling tools like catia_list_materials and catia_mass_properties.

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 states the target scope ('active part or a named body') and the practical reason to use it (so catia_mass_properties reports a real mass). It does not explicitly mention alternatives or when not to use the tool, but the context is clear enough for an agent to select it appropriately.

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

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

Annotations are all false (readOnly=false, destructive=false, etc.), so the description carries the burden of behavioral disclosure. It does add context about how geometry tokens resolve (against every visible component) and that dimensional kinds require a value, which is useful. However, it doesn't disclose side effects such as adding a constraint to the assembly tree, error handling on invalid references, or any impact on existing constraints. It's transparent enough for a mutation tool but leaves gaps.

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

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

The description is compact and efficient: one sentence states the purpose, the second provides essential reference-token details and highlights the value requirement. Every sentence earns its place without repetition, and the critical purpose is front-loaded. No fluff or irrelevant text.

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

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

For a moderate-complexity tool (4 params, array input, no output schema), the description covers the main usage aspects: how to reference geometry, that dimensional kinds need values, and points to a helper tool (catia_list_faces). It does not explicitly mention prerequisites like needing an active assembly document, or common failure modes (e.g., invalid references), but the 'inside an assembly' phrase implies the environment. Overall, sufficient for an agent to call it correctly in most cases, with minor gaps.

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

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

Schema description coverage is 100% and already documents each parameter (kind list, value units, elements as reference tokens). The description adds beyond the schema by explaining the token syntax ('face#3' and 'face@x,y,z') and reinforcing that dimensional kinds need a value, which clarifies how to fill in the 'elements' and 'value' fields. This adds meaningful semantic context, so it merits 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 clearly states the tool's action ('Constrain components to each other') and identifies the resource (components in an assembly). It distinguishes from sketch constraints by specifying 'components' and referencing assembly contexts. However, it doesn't explicitly say 'create a new constraint' or name alternatives like catia_sketch_constraint, so it's not a perfect 5.

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

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

The description implies usage in an assembly context and gives a pointer to catia_list_faces for reference resolution. It does not explicitly state when to use this tool versus alternatives (e.g., catia_sketch_constraint, catia_list_constraints, catia_delete_constraint), nor does it mention prerequisites like having an active assembly. Usage guidance is mainly implicit, earning a 3.

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

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

The annotations already establish that this is read-only and non-destructive. The description adds meaningful behavior by stating that the tool aggregates distinct part numbers with their quantities, source files, and using instances. It does not discuss depth-limit behavior or error conditions when no active assembly exists, but the safety profile is well covered.

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

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

The description is one front-loaded sentence with no filler: it states the verb, scope, and output fields immediately. Every clause contributes useful information.

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

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

For a tool with one optional parameter and no output schema, the description adequately specifies the returned BOM fields and the active-assembly scope. Minor gaps are the lack of an explanation for what happens with no active assembly and how max_depth affects the final result.

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 parameter, max_depth, is fully documented in the input schema with its type, default, minimum, maximum, and a description. The tool description adds no additional meaning beyond the schema, so the baseline score applies.

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

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

The description names a specific operation ('Build a bill of materials') and a clear scope ('active assembly'), then specifies the output details: distinct part number, quantity, source file, and instances. It is clear enough to distinguish from generic component listing, though it does not explicitly reference sibling tools like catia_list_components or catia_export_bom_csv.

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

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

No guidance is given on when to use this tool instead of related siblings such as catia_list_components or catia_export_bom_csv. The phrase 'for the active assembly' provides context, but there are no exclusions, prerequisites, or alternative-selection cues.

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

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

The description discloses that 'the tool body is consumed into the target body', which is a destructive side effect on the tool body. This contradicts the tool's annotations where destructiveHint is false. Per the rubric, a description that contradicts annotations must receive a 1.

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

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

The description is two sentences with no filler. The first sentence front-loads the core purpose and operation list, and the second delivers the essential side-effect warning. Every word earns its place.

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

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

The description covers the primary purpose and the key side effect, but it leaves gaps for a mutation tool: no mention of what happens to the target body after the operation, no return/result info (no output schema), no prerequisites, and no explanation of the name parameter's role. It is adequate but not complete.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by mapping operation values to familiar terms (add=union, remove=subtract) and by clarifying the tool/target body relationship through the consumption behavior. This goes beyond the raw enum strings in the schema.

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

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

The description clearly states the tool combines two bodies and enumerates the supported operations (add, remove, intersect, union-trim), making the purpose unmistakable. However, it does not distinguish itself from similar sibling tools like catia_solid_combine, so it stops short of a 5.

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

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

The description offers no guidance on when to use this tool versus alternatives such as catia_solid_combine, nor does it mention prerequisites or when not to use it. The only behavioral note about tool body consumption is a side-effect warning, not a usage guideline.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate that. It adds valuable behavioral detail by specifying the output (minimum/maximum corners and overall dimensions) and the scope ('element or whole solid'). It also clarifies the bounding box is axis-aligned, which is a meaningful behavioral trait not covered by annotations.

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

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

The description is two sentences with no filler. The first sentence states the action and outputs; the second provides practical use cases. All information is front-loaded and each sentence earns its place.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description adequately explains what the agent will receive (corners and dimensions). It does not mention units or coordinate system, but these are not critical for an agent to call the tool correctly. The description is sufficient for basic usage, though it could note that the element must be a referenceable object, which is implied by 'element'.

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

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

The schema provides 100% coverage for the single parameter 'element', describing it as a 'Reference token. Defaults to the part's main body.' The description's mention of 'element or whole solid' aligns with the parameter but does not add new syntactic or semantic details beyond what the schema already provides. Since schema coverage is high, 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 clearly states the tool's function: reporting the axis-aligned bounding box of an element or whole solid, including minimum/maximum corners and dimensions. It uses a specific verb ('Report') and resource ('axis-aligned bounding box'), and the context of sizing stock or envelope checking distinguishes it from generic measurement tools like catia_measure.

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 concrete usage scenarios ('sizing stock material' and 'checking a part fits an envelope'), which implicitly tell the agent when this tool is appropriate. However, it does not explicitly contrast it with sibling measurement tools (e.g., catia_measure, catia_measure_distance) or state when not to use it, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds valuable behavioral context beyond annotations: that the probe works by 'attempting the real calls' rather than relying on version numbers, and that results are installation-specific. This helps the agent understand why the tool behaves as it does.

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

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

The description is two sentences with zero filler. The first sentence front-loads the action and scope, and the second sentence explains the licensing rationale that distinguishes this probe from a simple version check. Every word earns its place.

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

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

For a tool with one optional parameter, a rich annotation set, and no output schema, the description is sufficiently complete: it states what the tool returns conceptually (a list of capabilities), why the probe is done this way, and how caching is handled via the `refresh` parameter. The only minor gap is not explicitly describing the return format, but that is not critical for a discovery tool.

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

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

Schema coverage is 100%: the only parameter `refresh` is fully documented in the schema with its type, default, and meaning. The description does not add additional parameter semantics, but the schema fully covers the parameter, 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 states a specific verb ('Probe') and a clear resource ('what this specific CATIA installation can do'), listing the capability domains covered. It is unmistakably distinct from the many sibling operation tools, which perform individual actions rather than enumerating available functionality.

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

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

The description gives clear context: this tool probes installation capabilities, and it explains that licensing rather than release numbers determines availability, implying the agent should call it to verify what is supported before attempting licensed features. It does not name explicit alternatives, but none exist among the siblings for this discovery purpose.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the description need not restate safety. It adds that the tool probes rather than merely reading the documented enumeration, but caching behavior is only disclosed in the schema's reprobe parameter, not in the description itself. This is useful but modest extra context.

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

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

The description is a single sentence that is front-loaded with the main action and resource. The final clause about probing rather than assuming the documented enumeration is valuable for differentiation and does not feel like 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-required-parameter, read-only report tool with no output schema, the description tells the agent what is reported (image formats) and why it differs from documented lists. The caching/reprobe behavior is already captured in the schema, so nothing critical is missing. It could optionally state the output type explicitly, but it is easily inferred.

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

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

Schema description coverage is 100% because the only parameter, reprobe, has a full description and default value. The tool description reinforces the probing concept and indirectly explains why reprobe exists, but it adds no syntax or value semantics beyond the schema. Baseline 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 states a specific verb ('Report') and resource ('image formats this CATIA installation can actually write'), and the 'determined by probing rather than by assuming the documented enumeration' clause distinguishes it from sibling listing/export tools. It could name an explicit sibling such as catia_list_export_formats, but the purpose is clear enough for an agent to understand 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 probing-vs-documentation contrast implies this tool is for obtaining ground-truth capabilities rather than trusting the documented enumeration. However, there is no explicit when-to-use or when-not-to-use guidance, and the agent is left to infer when to prefer this over catia_capabilities or catia_list_export_formats.

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 report readOnlyHint=false, idempotentHint=false, and destructiveHint=false, but the description adds little behavioral context beyond the verb 'bevel.' It does not disclose that the operation modifies the solid body, may fail on invalid edges, or whether it inserts a feature. No side effects or failure modes 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 two short sentences, front-loaded with the action 'Bevel one or more edges' before the mode explanation. Every clause earns its place, and there is no filler 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?

For an 8-parameter tool, the description is lean, but the schema covers all parameter semantics. The main gap is that the description does not state that a chamfer feature is created in the part tree or that the operation requires an active part context, though these are common to sibling CAD tools. Overall, an agent has enough to select and invoke the tool correctly.

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

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

The schema already documents all 8 parameters with descriptions (100% coverage), so the baseline is 3. The description adds conceptual meaning: length_angle is 'a length and an angle, the usual case' and two_lengths is 'a setback on each face,' which helps an agent choose the right mode and parameters. This additional context justifies 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 and resource: 'Bevel one or more edges.' It is distinct from siblings like catia_fillet, which rounds rather than bevels, though it does not explicitly name the alternative. The mention of modes ('length_angle' vs 'two_lengths') adds useful specificity.

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 chamfer rather than a fillet or other edge operation. It only instructs the agent to choose between two modes, calling length_angle 'the usual case,' which is more about parameter selection than tool selection. There are no exclusions, prerequisites, or named alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond that: it works without a CATIA connection and is intended as a pre-connect diagnostic step, which is valuable for the agent.

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

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

Two tight sentences with no filler. The purpose and diagnostic items are front-loaded, and the usage trigger is placed clearly at the end.

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 diagnostic tool, the description covers purpose, checks performed, connection independence, and when to invoke it. Since there is no output schema, slightly more detail about the returned report structure would make it fully complete.

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

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

The tool has 0 parameters, so the description carries no parameter-semantics burden. Per the baseline for zero-parameter tools, this receives 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 opens with a specific verb, 'Diagnose the host,' and enumerates concrete checks: Python version and bitness, pywin32 import status, CATIA.Application COM registration, and MCP SDK. This clearly differentiates it from siblings like catia_connect and catia_status.

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

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

The description gives a strong trigger condition: 'run it first when catia_connect fails,' and notes it works without a CATIA connection. It doesn't explicitly name sibling alternatives or exclusions, so it falls just short of full guidance.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds little behavioral context. It does not mention whether the original feature is kept, whether the pattern is associative, or any side effects. The description does not contradict annotations, but it also does not enrich them beyond stating the action.

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

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

The description is concise and front-loads the main action, with no filler. It could add more value per sentence, but it avoids redundancy and is easy to scan.

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

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

For a creation tool with 8 parameters and no output schema, the description is too sparse. It does not explain expected results, prerequisites (e.g., an active part with a selected feature), or relationship to similar pattern tools. An agent would need external knowledge to invoke this correctly beyond parameter names.

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 provides complete descriptions for all 8 parameters (100% coverage). The description repeats the axis reference token types already present in the schema ('cylindrical face, an edge, or a line') without adding new semantic depth, so it meets the baseline for schema-heavy documentation.

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

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

The description states a specific verb and resource: 'Repeat a feature around an axis.' It clearly conveys this is a circular pattern operation. However, it does not explicitly differentiate from sibling tools like catia_rect_pattern or catia_user_pattern, though the tool name and 'around an axis' partially imply 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?

No guidance is provided on when to use this tool versus alternatives such as catia_rect_pattern or catia_user_pattern. The description only explains the basic action without conditions, prerequisites, or exclusions.

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

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

The description explicitly discloses the destructive nature: 'Unsaved changes are discarded unless save=true.' This goes beyond the annotations (destructiveHint=true) by detailing the discard behavior and the save mitigation. It also advises a safety check, adding valuable behavioral context.

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

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

A single, direct sentence conveys the core action, the risk, the mitigation, and a safety tip. No filler or redundancy; every part earns its place.

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

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

The description covers the essential behavior (closing, discard, save option) and even guides the user to check document lists. It lacks an output schema, but for a close action, no return value is expected. It is sufficiently complete 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 already provides descriptions for both parameters (save and document) with 100% coverage. The tool description adds no additional parameter-specific details beyond what the schema states, so it meets the baseline for a fully documented 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 'Close a document' with a specific verb and resource. It also implies the scope by mentioning the save option and pointing to catia_list_documents, distinguishing it from save and open operations. 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 suggests checking catia_list_documents first if unsure, which is a usage hint, but it does not explicitly state when to use this tool versus alternatives like catia_save_all or catia_save_document. It gives context for safe use but lacks explicit exclusions or alternative routing.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, covering safety. The description adds context that this command manually terminates sketch-editing mode and is complementary to solid tools, which auto-close. No contradiction with annotations.

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

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

Two short sentences, with the primary action and key usage condition front-loaded. No filler or repeated annotation values.

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, no-output-schema tool, the description covers the action, when it is needed, and when it is not. An agent can determine whether to invoke it without consulting additional sources.

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 takes zero parameters, so there is no parameter detail the description must supply. Baseline 4 applies for parameterless tools, and the description focuses on the operation rather than inputs.

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

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

The description states a specific verb and resource: 'Finish editing the current sketch' – clearly an action to exit sketch-editing mode. It also differentiates from solid tools by noting they do this automatically, so an agent can distinguish manual close from other operations.

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

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

It explicitly specifies when manual invocation is needed: 'only need it when you want to inspect a finished sketch or switch to another one.' It also gives the when-not: solid tools close the sketch automatically, so the call is unnecessary in those workflows.

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

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

The description is consistent with the readOnlyHint annotation ('Read' matches read-only). It adds value by specifying the exact output contents (translation, Euler angles, matrix), but it does not disclose any additional behavioral traits such as required permissions, potential errors, or performance implications. With annotations already covering the read-only safety profile, a 3 is appropriate – it adds some context but not rich behavioral detail.

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, tightly worded sentence. The verb and resource are front-loaded, followed by the specific data types returned. There is no filler or redundant information – every word earns its place.

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

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

For a read-only tool with one parameter, no output schema, and a clear description of the return data, the description is adequate. It tells the agent exactly what to expect (translation, Euler angles, matrix) and that it's a read operation. It lacks explicit return format details, but since there is no output schema, the description carries the burden – and it does so sufficiently for the tool's simplicity.

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 covers the single parameter instance_name at 100% ('Instance name of the component.'), so the baseline is 3. The tool description does not add any additional meaning about the parameter beyond what the schema provides, such as format examples or constraints. No compensation needed, but no enhancement either.

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

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

The description states a specific verb ('Read'), a specific resource ('a component's placement in the assembly'), and enumerates the returned data (translation, Euler angles, raw CATIA matrix). This clearly distinguishes it from sibling tools like catia_move_component, which writes, and catia_list_components, which lists components rather than their placement.

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

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

The description implies when to use it (when you need placement data) but does not explicitly state when not to use it or name alternatives. There is no mention of scenarios where other tools like catia_measure or catia_point_coordinates would be more appropriate. The usage context is clear but not explicit about exclusions.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the description adds value beyond them: it discloses that launch=true starts a new instance (with slowness and license cost) and that the tool returns release and family info. This is useful context that isn't in the annotations. No contradiction.

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

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

Three sentences with no fluff. The core purpose is front-loaded in the first sentence, the usage nuance in the second, and the return value in the third. Every sentence earns its place.

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

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

No output schema exists, but the description mentions it returns release and family, which is enough for the agent to tailor later calls. It doesn't explicitly state the failure mode when no CATIA is open and launch=false, but that is strongly implied by the default-attach description. Given the tool's simple scope, this is nearly complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description enriches the launch parameter by explaining its real-world consequences (slow, license checkout), which is beyond the schema's simple 'Start CATIA if no running instance is found.' That added semantics justifies 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 clearly states the verb ('Attach') and the resource ('a running CATIA session'), and also positions it as the entry point with 'Call this first.' This distinguishes it from all sibling tools that operate on an already-connected session, so its 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?

It explicitly instructs 'Call this first' and explains the default behavior (attach to open CATIA) and how to override it with launch=true, including caveats ('slow, and it checks out a licence'). This gives the agent clear when-to-use and behavior-modifier guidance, and since it's the entry point, no alternative is needed.

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

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

The description adds some context about expression syntax and units, but does not disclose side effects like persistent formula creation, validation failures, or idempotency issues. With annotations indicating a write operation (readOnlyHint=false), the description does not go beyond that to explain consequences of repeated calls or invalid expressions.

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

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

Three concise sentences front-load the purpose, give an example, and add a use case. No fluff.

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

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

The description covers the essential information needed to call the tool - the expression format and target parameter example. It lacks information about error conditions or whether the target must already exist, but given the schema coverage and example, it is fairly complete for a typical call. It does not mention that the formula is a persistent relation, but that may be 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?

Schema already describes both parameters with examples. The description reinforces the expression format and notes feature dimensions as valid targets, providing additional context beyond the schema. However, it does not cover the optional name/comment parameters, but those are self-explanatory.

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

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

The description clearly states the tool's function: driving one parameter from an expression. It provides an example and notes feature dimensions as valid targets. It does not explicitly distinguish from sibling tools like catia_set_parameter, but the purpose is unambiguous.

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

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

It explains the use case - making a model self-adjusting - which implies when to use it. It does not explicitly mention alternatives or exclusions, but the context is clear enough.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the mutation and non-destructive safety profile is clear. The description adds useful context about the parameter's role in the model, but it does not disclose behavioral details beyond that, such as behavior on duplicate names or whether the active document must be a part.

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

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

The description is a single, well-structured sentence that front-loads the core action and purpose. Every clause adds meaning without repetition or filler, making it easy for an agent to parse quickly.

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

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

For a simple creation tool with full schema coverage and minimal annotations, the description is nearly complete: it defines the object, its types, and its intended use. The only gaps are implied prerequisites like an active part document and behavior on name collisions, which are common to many CATIA tools and not explicitly required here.

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

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

Schema description coverage is 100%, so the schema fully documents all five parameters, including types, defaults, and units. The description adds minimal semantic value by grouping parameter types as 'length, angle, number, string or flag,' which mostly mirrors the schema's 'length | angle | real | integer | string | boolean' enumeration.

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 specific verb 'Create' with the resource 'user parameter' and states its purpose: to drive the model and be referenced by formulas and feature dimensions. This clearly distinguishes it from related sibling tools like catia_set_parameter or catia_delete_parameter, which have different operations on the same resource.

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

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

The description implies when to use the tool ('to drive the model' with named lengths, angles, etc.) but does not explicitly state when not to use it or name alternatives such as catia_set_parameter for modifying an existing parameter. The intended usage is inferable but not directly contrasted with siblings.

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

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

Annotations only say readOnly=false and destructive=false, which are thin. The description adds the crucial behavioral fact that the tool both creates and opens an active sketch context, and that subsequent sketch calls target this sketch until closed or replaced. This stateful behavior is exactly the kind of side effect an agent needs to know.

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

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

Two sentences carry all the essential information: the purpose, the support syntax, and the stateful behavior. There is no filler or redundant restatement of the schema.

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

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

For a 5-parameter creation tool with no output schema and sparse annotations, the description covers the main invocation workflow and the active-sketch lifecycle. It does not mention prerequisites such as an open document or existing body, but the schema's body default and support descriptions fill in most 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 schema already documents all five parameters with descriptions, so the baseline is 3. The description goes beyond the schema by explaining the support token semantics: origin planes, face references ('face#3', 'face@x,y,z') for faces of the solid, and construction-plane names. It does not add detail for origin or horizontal_direction, but the schema handles those.

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

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

The first sentence names the exact action ('Create a sketch'), the target ('on a plane or a planar face'), and the mode ('open it for drawing'). It also references the sibling family 'catia_sketch_*' as downstream consumers, so an agent can distinguish this entry-point tool from the individual sketch-drawing tools.

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

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

The description gives clear sequencing: create a sketch, then draw with catia_sketch_* until you close it or create another. This tells an agent when this tool is the right entry point, though it never names the explicit alternative catia_close_sketch or warns against creating a new sketch while one is already being drawn on.

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

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

Annotations already declare destructiveHint=true, so the description's 'delete' adds no new behavioral information. No mention of irreversibility, failure behavior, or any side effects beyond the annotation.

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

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

Single sentence, front-loaded with the action and resource, no filler. Every word earns its place.

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

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

For a simple one-parameter destructive tool, the description plus schema and annotations provide adequate context: the operation, the required parameter, and the destructive nature. It could mention failure behavior but is sufficient for a simple delete operation.

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

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

Schema coverage is 100%, so the schema already documents the 'name' parameter and its source. The description's 'by name' adds no additional semantic meaning, matching the baseline for full schema coverage.

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

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

The description states a specific action (delete), a specific resource (assembly constraint), and the selection criterion (by name). It clearly differentiates from sibling tools like catia_delete_element (generic delete) and catia_remove_component (removes components), and aligns with catia_list_constraints for obtaining names.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any preconditions or exclusions. The only hint is in the parameter schema ('from catia_list_constraints'), which is not part of the tool description itself.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is covered. The description adds valuable context about dependent features going into error and recommends verifying with catia_list_features, which goes beyond the annotation.

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

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

Two concise sentences with no wasted words. The primary action is front-loaded, and the dependency warning is placed immediately after, 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 simple delete tool with one parameter and no output schema, the description covers the essential action and the critical risk (dependent features). It could mention the result of deletion or reversibility, but annotations already indicate destructiveness, so nothing critical is missing.

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

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

Schema coverage is 100% and the token parameter is clearly described as 'Reference token of the element to delete'. The description adds no additional meaning beyond the schema, so it meets the baseline for high coverage.

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

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

The description states the action clearly ('Delete a tree element') with a specific verb and resource. It distinguishes itself from sibling delete tools like catia_delete_constraint and catia_delete_parameter by focusing on tree elements, though it doesn't 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?

No guidance on when to use this vs other delete tools. It does provide a caution about dependencies and suggests checking catia_list_features afterwards, which is useful but not about selecting this tool over alternatives.

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

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

Annotations already declare destructiveHint=true, and the description's verb 'Delete' aligns with that. The description adds no extra behavioral context such as irreversibility, permissions required, or effects on dependent relations. Since the destructive nature is already captured by annotations, the description contributes minimal additional transparency; however, there is no contradiction, so a baseline 3 is appropriate.

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

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

The description is a single, compact sentence: 'Delete a user parameter.' It is front-loaded with the action and object, contains zero filler words, and is appropriately sized for the tool's simplicity. Every word earns its place; no unnecessary details or redundancies exist.

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

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

Given that the tool has only one parameter, no output schema, and no nested objects, the description covers the essential action. The destructive hint is provided via annotations, and the target (user parameter) is clearly stated. It could potentially mention that the parameter is deleted from the active document, but that is reasonably implied by the tool's context and sibling tools. The description is sufficient for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, meaning the only parameter 'name' is fully documented in the input schema as 'Parameter name.' The description does not add any further detail about the parameter's format, valid values, or relationship to the document. With full schema coverage, the baseline of 3 applies; the description adds no additional meaning beyond what the schema already provides.

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

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

The description 'Delete a user parameter.' states a clear action (delete) on a specific resource (user parameter). This distinguishes it from sibling tools like catia_get_parameter, catia_set_parameter, catia_create_parameter, and catia_list_parameters, all of which perform different operations on parameters. The verb-resource pair is explicit 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 no guidance on when to use this tool versus alternatives. It does not mention preconditions (e.g., the parameter must exist), when not to use it, or how it differs from deleting a constraint or element. There is no context about the active document or scope. For a simple tool this may be acceptable, but the definition offers no explicit usage direction.

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

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

The description only restates the destructive action already declared by annotations (destructiveHint=true). It does not disclose additional behavioral traits such as cascading effects on dependent formulas, irreversibility beyond the annotation, or any required permissions. With annotations covering the destructive hint, the description adds no extra behavioral context.

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

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

The description is a single, compact sentence that front-loads the action ('Delete') and immediately clarifies the scope. Every word earns its place, with no fluff or redundancy.

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

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

For a simple single-parameter destructive tool, the description covers the essential action and target. However, it omits any usage context (e.g., when deletion is appropriate) and does not elaborate on side effects beyond the annotation, which might be expected for a destructive operation. It is adequate but not rich.

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

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

The schema provides 100% coverage for the single 'name' parameter with the description 'Relation name.' The tool description does not add any further semantics or constraints beyond what the schema already states, so it meets the baseline without improvement.

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 action (delete) and a specific resource (relation) with enumerated types (formula, rule, check, design table). This distinguishes it from sibling deletion tools like catia_delete_parameter and catia_delete_element, which target different entities.

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

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

No guidance is given on when to use this tool versus alternatives such as catia_set_relation_active or catia_list_relations. There is no mention of prerequisites, exclusions, or context about the relation lifecycle, leaving the agent to infer appropriate usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable context: the output format, the inclusion of reference tokens for later modelling, and a performance hint via the include_types parameter (cost per level). This goes beyond what annotations alone provide.

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

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

Two sentences with zero wasted words. The first sentence defines the operation and output; the second adds the reference-token detail and the usage guidance. Everything earns its place and the key information is front-loaded.

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

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

For a read-only inspection tool with well-documented parameters and no output schema, the description covers the essential aspects: scope (active document), output type (nested JSON), element categories, and the reference-token mechanism. Minor omissions like behaviour on empty documents or performance characteristics are acceptable given the parameter hints.

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

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

Schema description coverage is 100% – all three parameters (max_depth, max_children, include_types) have descriptive text. The description itself adds no new parameter semantics; it only alludes to the output structure and reference token, which are output-related. Baseline 3 is appropriate when the schema already documents parameters well.

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

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

States a specific verb (walk), a resource (specification tree), and a precise output (nested JSON of bodies, geometrical sets, sketches, features, and component hierarchy). It distinguishes itself from the many specific list tools (catia_list_bodies, catia_list_features, etc.) by positioning itself as the starting point when the document's contents are unknown.

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?

Gives an explicit when-to-use instruction: 'Start here when you do not know what is in the document.' It implies that for known specific needs, more targeted tools should be used, though it does not name them explicitly. The guidance is clear enough for an agent to decide when to call it.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, so the description adds value by specifying the exact side effects: releasing the COM reference while leaving CATIA running and documents open. This is useful context beyond the annotations, though it doesn't discuss error cases 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 two short sentences, front-loaded with the core action, and every clause earns its place. No fluff or redundancy.

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

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

For a zero-parameter tool with no output schema, the description fully covers what an agent needs: what the tool does, its side effects, and its boundary relative to closing documents. Nothing essential is missing.

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

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

The tool has zero parameters, so there is nothing to explain. Per the rubric, a baseline of 4 is appropriate when there are no parameters to document, and the description correctly avoids inventing parameter details.

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

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

The description states a specific action ('Release this server's COM reference to CATIA') and clearly distinguishes it from related tools like catia_connect and catia_close_document by explicitly noting that CATIA keeps running and no document is closed. This makes 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 implies when to use it—as the counterpart to catia_connect—and explicitly states what it does not do (close a document), which helps an agent decide between this and catia_close_document. However, it doesn't name alternative tools or provide explicit 'when not to use' guidance, so it's slightly below a 5.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the description only needs to add context beyond safety. It adds the scoping to 'active document' and enumerates returned information, but it does not disclose behavior when no document is active or output size/format expectations. No contradiction with annotations.

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

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

A single front-loaded sentence with no filler. Every phrase adds meaningful detail about the document aspects the tool returns, making it efficient and easy to parse quickly.

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

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

For a zero-parameter, read-only introspection tool with no output schema, the description covers the main return categories well: type, path, save state, tree contents, and product properties. It could mention the 'no active document' failure case, but overall it is sufficiently complete for an agent 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?

The tool has zero parameters and schema coverage is vacuously 100%, so there are no parameter descriptions needed. The description still clarifies that the implicit target is the active document, which is sufficient given no inputs exist.

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

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

The description uses a specific verb ('Describe') and resource ('the active document'), then lists concrete content: type, path, save state, tree contents, and product properties. This makes it distinguishable from siblings like catia_describe_tree and catia_status, though it does not explicitly name any 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?

There is no guidance about when to use this tool versus catia_describe_tree, catia_status, or catia_list_documents. The description implies a metadata-overview use case, but it does not state exclusions or conditions for choosing an alternative.

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

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

Annotations provide no safety profile (readOnlyHint=false, destructiveHint=false), so the description carries the full burden. While it states that a draft angle is applied, it does not disclose side effects such as feature creation, body modification, reversibility, or prerequisites beyond the listed inputs. This is a significant gap 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?

Two sentences with zero fluff. The main purpose is front-loaded, and the necessary inputs are mentioned succinctly. Every sentence earns its place.

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

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

For a CAD feature that modifies geometry, the description is adequate but not complete. It does not explain what the result looks like (e.g., a feature in the tree) or mention how default behaviors work (like pulling_direction defaulting to neutral element, which is in schema). With no output schema and no safety annotations, more context about the resulting feature and side effects would be helpful.

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 100%, so parameters are already documented. The description adds value by explaining the neutral element's role ('the draft pivots about') and clarifying the pulling direction concept, which goes beyond the schema's field descriptions. This justifies a score above the baseline of 3.

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

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

The description clearly states a specific action—'Apply a draft angle to faces'—with a clear purpose ('so a moulded or cast part can be released from the tool'). This distinguishes it from sibling operations like fillets, chamfers, or shells, and no other tool covers this exact functionality.

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

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

The description provides clear context for when to use the tool (for moulded or cast parts needing release) and lists the required inputs (faces, neutral element, pulling direction). However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of the top score.

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 all false (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), providing no behavioral signals. The description adds one behavioral detail: 'make it current,' indicating a side effect on the active sheet. However, it does not disclose potential errors, side effects on existing sheets, or any other behavioral traits. With neutral annotations, the description carries some burden but only partially fulfills it.

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

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

The description is a single, concise sentence that front-loads the action and the key effect. There is no redundancy or unnecessary detail, making it efficient and easy to parse.

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

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

The description adequately covers the core operation and its immediate effect, and the schema covers parameter details. It does not explicitly state that an active drawing must exist, but the phrase 'active drawing' implies it. There is no output schema, so return value explanation is not expected. The description is sufficient for a simple mutation tool, though it could be slightly more explicit about prerequisites.

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

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

Schema description coverage is 100%, with all four parameters (name, scale, landscape, paper_size) having descriptions. The tool description does not mention any parameters, so it adds no additional meaning beyond what the schema already provides. The baseline of 3 is appropriate given high schema coverage.

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

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

The description clearly states the action: 'Add a sheet to the active drawing and make it current.' It specifies the verb (add), the resource (sheet), the context (active drawing), and an additional effect (make it current). This distinguishes it from sibling tools like catia_drawing_add_view (adds a view) and catia_drawing_list_sheets (lists sheets).

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

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

The description implies usage by mentioning the 'active drawing' as a prerequisite, but it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or conditions. It provides minimal context but no explicit guidance on selection among drawing-related 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?

The description is consistent with the annotations: 'Place' implies a write operation matching readOnlyHint=false and is not presented as destructive. However, it adds little behavioral context beyond the annotations, such as whether each call creates a new annotation or how the tool interacts with the current/active document.

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

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

The description is a single, tightly worded sentence with a clear action, target resource, and illustrative examples. It is front-loaded and contains no filler.

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

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

For a relatively simple creation tool with a complete parameter schema and annotations, the description is largely sufficient. It leaves minor details unstated, such as the need for an active drawing document and the absence of return-value information, but neither is critical to selecting or invoking this 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 100%, so the parameter details are already fully documented in the schema. The description adds no extra semantic detail about the parameters such as position, sheet, view, or height.

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

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

The description uses a specific verb and object: 'Place a text annotation on a drawing sheet,' with content examples like note, title, or revision mark. This makes the tool's function unambiguous and clearly distinct from the many sketch, solid, and drawing-management siblings.

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

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

No explicit when-to-use guidance, exclusions, or prerequisites are given. The description does not mention that a drawing document must be active, nor does it point to alternatives among the drawing-related 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?

The description adds behavioral context beyond annotations: it notes that the view geometry is not computed until catia_drawing_update is called, and it implies the operation modifies the drawing sheet. Since annotations already declare readOnlyHint=false and destructiveHint=false, the description's mention of the update requirement adds value by clarifying the incomplete nature of the operation without contradicting the annotations.

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

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

The description is two sentences with no filler. It front-loads the core purpose, mentions key adjustable attributes (orientation, placement, scale), and ends with the critical follow-up action. Every sentence earns its place, making it highly concise and well-structured.

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

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

For a 7-parameter tool with all parameters defaulted and fully documented in the schema, the description covers the essential workflow: add a view, specify its placement and orientation, then update. It mentions the prerequisite of an open 3D document and the need for a follow-up call, which is sufficient for an agent to invoke the tool correctly. It does not describe return values or error conditions, but given the simple, non-output-schema tool, this is adequate.

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

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

All 7 parameters are fully described in the schema (100% coverage), so the baseline is 3. The description's mention of 'standard orientation, where the view goes on the sheet, and its scale' loosely mirrors the schema fields but adds no new meaning beyond what the schema already provides. It does not clarify units, defaults, or edge cases beyond what the schema states.

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

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

The description clearly states the action ('Add a generative view') and the resource ('to a drawing sheet'), specifying the type of view and the context (open 3D document). It distinguishes from siblings like catia_drawing_add_text or catia_drawing_add_sheet by focusing on view creation, and the verb 'add' plus resource is unambiguous.

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

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

The description provides a clear follow-up action ('Call catia_drawing_update afterwards') and implies a prerequisite (an open 3D document). However, it does not explicitly contrast with alternative view-related tools like catia_set_view or catia_drawing_delete_view, nor state when not to use this tool. The usage context is implied rather than explicit, leaving some room for an agent to select incorrectly.

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

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

Annotations already declare destructiveHint=true, so the agent knows this is destructive. The description adds the specific target (a view on a drawing sheet) but doesn't disclose consequences like whether dependent elements are also deleted, whether the operation is undoable, or whether the sheet must be active. With destructiveHint covering the main safety concern, a 3 is appropriate.

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

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

The description is a single, efficient sentence that states the operation clearly. It is appropriately sized for a simple tool with two parameters, though it could add a brief usage note without becoming bloated.

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

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

For a destructive operation with no output schema, the description is adequate but minimal. It doesn't mention prerequisites (e.g., whether the drawing must be active), error conditions, or what happens to associated elements. The annotations cover the destructive nature, but an agent might still be uncertain about edge cases.

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

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

Schema description coverage is 100%, so both parameters (view and sheet) are documented in the schema. The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is correct when the schema does the heavy lifting.

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 'Delete a view from a drawing sheet' clearly states the verb (delete), the resource (view), and the context (drawing sheet). It is specific enough to distinguish from generic delete tools like catia_delete_element, though it doesn't explicitly differentiate from other drawing-related tools.

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

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

The description implies usage context (drawing sheet views) but provides no explicit guidance on when to use this tool versus alternatives like catia_delete_element or catia_sketch_delete_element. The sibling list contains many delete-type tools, so an agent would benefit from explicit routing guidance, but the drawing-specific scope is reasonably clear.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the concrete output content (paper size, scale, views), which is useful behavioral context beyond the annotations. It doesn't introduce any contradictions and provides a reasonable level of transparency for a simple read 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, concise sentence with no unnecessary words. It front-loads the verb and resource, and immediately states what information is returned. 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 zero parameters and no output schema, the description is nearly complete. It states the action, the scope, and the return content. The main omission is an explicit statement about requiring an open drawing document, though 'active drawing' strongly implies it. Error conditions or behavior when no drawing is active are not mentioned, but are minor for a simple read 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?

There are no parameters (schema coverage 100% trivially), so the baseline is 4. The description correctly avoids describing parameters, as none exist. It adds no extra parameter semantics, but none are needed.

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

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

The description uses a specific verb 'List' and resource 'sheets of the active drawing', and explicitly names the output fields (paper size, scale, views). This clearly differentiates it from other listing tools like catia_list_features or catia_drawing_add_sheet, making its purpose unambiguous.

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

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

It clearly states the scope 'active drawing', which implies the prerequisite that a drawing must be open and active. While it doesn't explicitly mention alternatives or when not to use it, the context is clear enough for an agent to infer when to call it. A small addition about not being applicable to part documents could improve it.

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

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

Annotations already declare non-readOnly and non-destructive behavior. The description adds no further behavioral context, such as immediate application, state requirements, or side effects. It does not contradict annotations.

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

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

The description is a single, tightly worded sentence: 'Change the scale of a sheet or of one view.' It is front-loaded with the core purpose and contains no redundant 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 simple mutation tool with full schema coverage and no output schema, the description is sufficient for an agent to select it. It lacks explicit mention of default behavior (e.g., active sheet), but these details are already in the parameter descriptions.

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 100%, and each parameter has a clear description. The tool description only restates the sheet/view distinction already present in the schema, adding minimal value beyond what structured fields provide.

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 ('Change'), resource ('scale'), and scope ('of a sheet or of one view'), clearly distinguishing it from sibling tools like catia_drawing_add_view or catia_set_view. It is unambiguous 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 conveys the tool's purpose but gives no explicit guidance on when to use it versus alternatives. It implies its usage (when scale needs adjustment) but does not mention any alternative tools or conditions where it should not be used.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false, and the description does not contradict these. Although it does not explicitly mention that the operation is non-destructive, it implies regeneration, which is non-destructive. The description adds value by specifying the scope (every generative view, from current state) which is useful context beyond the annotations.

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

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

The description is a single concise sentence and a trailing instruction. It is front-loaded with the main action and followed by usage context. Every word is purposeful, with no 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 tool with only two optional parameters and no output schema, the description is adequate. It lacks details on return values or error handling, but such information is not required given the tool's simplicity and the annotations covering idempotency. The trigger for usage is explicit, making it reasonably complete for agent decision-making.

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

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

Schema description coverage is 100%, so the schema already documents the parameters. The description does not add additional semantics beyond what the schema provides (e.g., default behavior for sheet name). Thus, the baseline 3 is appropriate.

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

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

The description clearly states the action (regenerate), the resource (generative views on a sheet), and the trigger (after changing the 3D model). It is specific and distinct from sibling tools like 'catia_update' (which likely updates the drawing) by focusing on generative views.

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

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

The description explicitly says 'Run this after changing the part,' which gives clear context for when to use it. It does not explicitly name alternatives, but it is self-contained for its purpose, and the trigger is clear enough for an agent to infer when to call it.

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

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

The description adds useful behavioral context about format resolution ('format is taken from the file extension unless you name it explicitly') and supported formats per document type. However, with annotations carrying little safety detail, it does not disclose side effects like whether the default overwrite=true replaces existing files, whether the export blocks, or what the function returns. It is not misleading, but it leaves some behavioral burden uncovered.

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

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

Two sentences carry all the crucial information: what the tool exports, to which formats, and how format selection works. The active-document scope is front-loaded, and every phrase contributes value without repetition or filler.

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

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

For a three-parameter export tool with no output schema, the description covers the main inputs and scope well. It is incomplete in that it does not mention return behavior, error conditions, or the overwrite default behavior, though the overwrite parameter is documented in the schema. Overall it is adequate but not fully comprehensive.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by listing accepted neutral formats and clarifying which formats apply to 3D documents versus drawings, and by explaining the extension-vs-explicit-format precedence. This helps the agent choose valid path/format combinations.

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

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

The description clearly states a specific action ('Export the active document'), a resource ('active document'), and a concrete scope ('neutral format'). It enumerates supported formats for both 3D documents and drawings, which distinguishes it from sibling export tools like catia_export_all_open and catia_export_bom_csv without requiring the agent to inspect their schemas.

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

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

The description implies usage by saying 'active document' and enumerates format categories, but it does not explicitly route the agent toward alternatives such as catia_export_all_open for exporting all open documents or catia_export_bom_csv for BOM data. Usage context is present, but exclusions and direct sibling comparisons are absent.

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

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

Annotations are all false, providing no safety profile. The description says 'export every open 3D document' but doesn't disclose potential side effects like creating files on disk, overwriting existing files, or handling of unsaved documents. It also doesn't mention any errors or limitations. Since annotations don't cover these, the description carries the burden and only partially discloses behavior.

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

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

Two sentences, both informative, with no waste. The purpose is front-loaded. The second sentence gives a use case and example format, which is concise and helpful.

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

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

The tool is simple with only 2 params and no output schema, but the description doesn't explain the success/failure behavior, whether a progress report is returned, or any prerequisites (e.g., documents must be saved). It's adequate for basic use but could be more complete for error handling and edge cases.

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

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

Schema coverage is 100%, so the schema documents both parameters. The description adds a hint that format has a default of 'step' and mentions 'STEP files' as an example, but otherwise doesn't add meaningful semantics beyond the schema. It doesn't clarify accepted format names or directory requirements.

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

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

The description clearly states the tool exports all open 3D documents to a directory in one format, using a specific verb and resource. It distinguishes itself from siblings like catia_export (which likely exports a single document) and catia_save_all (which saves, not exports). However, it doesn't explicitly name those siblings, so it falls short of a 5.

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

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

The description implies usage for batch exporting a session's work, which is clear. It doesn't explicitly contrast with catia_export or list when not to use it, so it lacks explicit exclusions. The example of STEP files gives a concrete use case, but no alternative routing.

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 mark it as not read-only and not destructive, so the write side effect is already implied; the description adds that it writes to a CSV file. It does not disclose whether an existing file is overwritten, whether the operation requires saving, or what happens if no assembly is active.

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

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

The description is a single, front-loaded sentence that states the operation, target, and output contents without wasted words. Every clause adds value.

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

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

For a two-parameter, no-output-schema tool, the description covers the core purpose well. Missing context includes what the tool returns or confirms after writing, whether the destination file is overwritten, and how max_depth interacts with nested assemblies, leaving some non-trivial behavior undocumented.

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 100%, so both path and max_depth are already documented. The description adds useful context about which BOM fields are exported but does not clarify how max_depth affects the BOM content beyond the schema's 'Recursion depth' note.

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 ('Write'), identifies the exact resource ('active assembly's bill of materials'), and specifies the output artifact (CSV file) and the included fields. This clearly distinguishes it from generic export tools and the read-oriented catia_bill_of_materials sibling.

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

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

The phrase 'active assembly' implies it should be used only when a CATIA assembly is active and the caller wants a CSV BOM export. However, it does not explicitly state when to prefer this over siblings like catia_bill_of_materials or catia_export, nor does it mention failure cases or alternatives.

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

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

Annotations already signal readOnly=false and destructive=false, so the mutation status is known. The description adds behavioral context beyond annotations by clarifying the geometric precondition (faces need not share an edge) and the domain (CATIA's Face-Face Fillet). It does not disclose side effects, but this is minor given the annotation coverage.

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

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

The description is two sentences with no filler. The main action is front-loaded, and the usage guidance follows immediately. Every word earns its place.

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

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

For a tool with four simple parameters and no output schema, the description provides enough for selection and invocation: what it does, when to use it, and its distinguishing characteristic. It lacks a note about prerequisite face selection or failure conditions, but these are not essential given the schema and annotation 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 100%, so the parameters first_face, second_face, radius, and name are already documented in the schema. The description adds no parameter-specific semantics beyond the schema, which matches the baseline of 3.

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

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

The description states a specific verb ('Round the junction') and resource ('two faces that need not share an edge'), and explicitly names the CATIA Face-Face Fillet feature. It differentiates itself from edge fillet by noting it works where an edge fillet cannot reach, so an agent can distinguish it from sibling fillet 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?

It gives an explicit usage rule: 'Use it where an edge fillet cannot reach, such as across a step.' This tells the agent when to select this tool over an edge fillet alternative and provides a concrete example of the intended scenario.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds value by specifying the input must be planar and by detailing the returned components, including the outward normal's orientation. It does not mention failure behavior for non-planar faces, but this is implied by the precondition.

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 tight sentences: the first defines the tool's action and output, the second gives the motivating use case. No filler or repetition; the key benefit is front-loaded.

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

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

With no output schema, the description carries the full burden of describing return values, and it does so clearly. The read-only annotations cover safety, the single parameter is documented, and the tool's role in the sketcher workflow is explicit, making it complete for this low-complexity 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 schema already describes 'face' as a reference token, and the description adds the crucial constraint that the face must be planar, which affects how the parameter should be chosen. Since schema coverage is 100%, the description provides useful extra semantics beyond the baseline.

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

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

The description uses a specific verb ('report') and a clear resource ('plane of a planar face'), enumerating the exact outputs: point, two in-plane directions, outward normal. It also gives a concrete use case (deciding the top face before sketching) that separates it from sibling tools like catia_measure or catia_gsd_plane.

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

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

The description explicitly states when to use this tool: when you need to decide which face is 'the top one' before sketching on it. It provides clear context but does not name alternatives or say when not to use it, so it falls short of full routing guidance.

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

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

Annotations only provide basic flags, so the description carries real behavioral weight. It adds valuable non-obvious behavior: edge tokens like 'edge#4' and 'edge@20,0,10', the latter surviving model changes, and the default propagation across tangent-continuous edges. It could go further by noting failure behavior when an edge token is invalid, but it materially exceeds the annotated baseline.

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

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

Two tightly packed sentences front-load the core action and then explain the two most important behavioral nuances. Every clause earns its place: reference token syntax, model-change robustness, and tangent-chain default. There is no filler or redundancy.

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

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

For a CAD feature tool, the description plus 100% schema coverage gives an agent what it needs to select edges, set radius, and understand tangency propagation. It does not mention prerequisites such as active workbench/body or what the tool returns, but these are less essential for a straightforward fillet operation, making it nearly complete.

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

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

Schema coverage is 100%, satisfying the baseline, and the description goes beyond it by explaining the edge token formats and the difference between index-based and point-based references. This is genuinely useful semantic context that the schema examples alone do not convey. Radius and propagation semantics are already well covered by the schema, so the description does not need to repeat 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 opens with a specific verb and resource: 'Round one or more edges with a constant radius.' The qualifier 'constant radius' clearly separates it from sibling tools like catia_variable_fillet, and 'edges' separates it from face-based fillets. It also previews key behavior (tangent chains), so the tool's purpose is unmistakable.

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

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

The description makes clear this is the tool for constant-radius edge rounding and explains that a single token usually rounds a whole tangent-continuous chain. It does not explicitly name alternative tools or state when not to use it, but the 'constant radius' and 'edges' framing gives enough context to select it correctly among 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the tool returns reference tokens for each match, which is not present in the annotations or schema. This gives the agent useful information about the result format without contradicting any annotations.

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

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

Two sentences, front-loaded with the action and scope. Every word earns its place: search, active document, pattern matching, and return value. 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 read-only search tool with complete schema coverage and no output schema, the description provides all necessary information: scope (active document), filter (name pattern), and return type (reference tokens). Nothing an agent needs to call this tool correctly is missing.

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

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

Schema coverage is 100% for both parameters, so the schema already supplies basic meaning. The description adds value with concrete wildcard examples ('Pad.*', '*Hole*') and clarifies that these are shell-style wildcards, going beyond the schema's generic 'Name pattern with * and ? wildcards.'

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

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

Description uses a specific verb ('Search'), identifies the resource ('active document for elements'), and clearly defines the operation (name-pattern matching with wildcards). This differentiates it from siblings like catia_list_elements, catia_select_elements, and catia_list_features, which have different search/selection semantics.

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 sets the context: search within the active document by name patternasi. It does not explicitly name alternatives or exclusions, but the tool's specific purpose is obvious from the description alone, so the agent knows when to invoke it.

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

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

Annotations already declare non-destructive and idempotent behavior, and the description does not contradict them. It adds the scope of 'everything visible' and the result 'fits in the window', but offers no additional behavioral traits such as whether the view change affects all windows or if there are any side effects. The extra value over annotations is minimal.

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

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

The description is a single, tightly worded sentence with no unnecessary words. The key action and outcome are front-loaded, making it immediately digestible.

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, no-output view command, the description is sufficient: an agent can correctly predict the behavior without needing return-value specs. It could clarify whether 'everything visible' means all loaded geometry or only the current viewport, but that ambiguity is minor.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately communicates that no input is needed, and the schema's 100% coverage confirms the complete absence of 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 uses a specific verb and resource ('Zoom and centre the view') and clearly states the outcome: everything visible fits in the window. It distinguishes itself from sibling catia_zoom, which likely performs a different kind of zoom, by specifying the fit-all behavior.

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 like catia_zoom or catia_set_view. The context of use is only implied by the name and action; no explicit conditions or exclusions are stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the formula is included when driven by one, which is useful behavioral context. It does not describe error behavior or return format, but given the annotations, this is acceptable.

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-loaded with the action and object, and includes a valuable qualifier about formulas. No wasted words.

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

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

For a simple read-only tool with one parameter and no output schema, the description covers the essential purpose and the formula detail. It does not specify return structure or not-found behavior, but these are minor for such a tool, and annotations cover safety.

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

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

Schema description coverage is 100% ('Exact parameter name.'). The description's mention of 'exact name' is redundant with the schema, adding no new meaning. Baseline 3 is appropriate since the schema already documents the parameter 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 uses a specific verb 'Read' and identifies the resource 'one parameter by its exact name'. It also adds that it returns the formula if driven by one, which clarifies scope. It does not explicitly name a sibling like catia_list_parameters for differentiation, but the purpose is unambiguous.

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

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

The description implies usage: use this when you know the exact parameter name. It does not explicitly contrast with listing tools (e.g., catia_list_parameters) or mention when not to use it, leaving alternatives unaddressed.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the description is not required to restate those. The description adds the key behavioral fact that this is a subtractive operation ('Cut material'), which is useful context beyond the annotations. However, it does not disclose details like whether the sketch must be closed, how the axis is resolved, or what happens if the groove cannot be computed.

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, information-dense sentence that front-loads the core action ('Cut material by revolving a sketch profile around an axis') and immediately adds the sibling relationship. Every word earns its place; 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?

For a feature-creation tool with 100% schema coverage and no output schema, the description is largely complete: it states the operation, the input concept, and the sibling relationship. The only minor gap is that it does not mention prerequisites (e.g., an active part, an existing sketch) or failure behavior, but these are not critical for an agent to invoke the tool correctly given the 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 100%, so the schema already documents all four parameters (axis, name, angle, sketch). The description adds the conceptual meaning of the parameters (revolving a sketch profile around an axis) but does not add syntax, defaults, or constraints beyond what the schema provides. Baseline 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 states a specific verb ('Cut material'), a specific resource ('revolving a sketch profile around an axis'), and explicitly names its counterpart (catia_shaft). This clearly distinguishes it from the many other feature-creation tools in the sibling list.

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

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

The description identifies the tool as the subtractive counterpart of catia_shaft, which gives an agent a clear context for when to use it (when a revolved cut is needed rather than a revolved add). It does not explicitly list exclusions or alternative tools beyond catia_shaft, but the counterpart framing provides sufficient usage guidance.

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

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

Annotations already signal a non-read-only, non-destructive write operation, and the description's 'Create' aligns with that. It adds only that a new local reference frame is produced; it does not disclose prerequisites such as an active document or behavior when X and Y directions are not perpendicular. No contradiction with annotations.

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

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

A single sentence front-loaded with the verb and resource, followed by a compact purpose clause. Every phrase earns its place; 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?

Adequate for a moderately complex creation tool: the concept, key parameters, and a use case are covered, and the schema documents every parameter. Gaps include no mention of the return value (the created axis system reference), given there is no output schema, and no caveat about CATIA's orthogonalization behavior when X/Y are not perpendicular.

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

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

Schema description coverage is 100%, so the baseline holds. The description adds modest interpretive value by connecting origin ('at a point') and the two direction arrays ('explicit X and Y directions') into the concept of a reference frame, but it does not add semantics beyond the schema such as normalization or Z-axis derivation.

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 and resource ('Create an axis system') with clarifying scope ('at a point with explicit X and Y directions') and names its role as a local reference frame. This is enough to distinguish it from GSD siblings like catia_gsd_point and catia_gsd_plane without opening schemas.

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

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

The phrase 'useful as a local reference frame for positioning and measurement' provides a concrete use-case context for when an agent should invoke this tool. It does not name alternatives or exclusion conditions, but the situational guidance is explicit and actionable.

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

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

Annotations already declare the operation is not read-only, not idempotent, and not destructive. The description adds that it creates a transition surface, which is the key behavioral outcome. However, it does not mention side effects such as where the surface is placed, whether it appears in the active geoset, or how optional supports affect the result.

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

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

The description is a single clear sentence with no filler: it names the action, the inputs, and the outcome in that order. It is concise while still conveying the essential purpose.

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

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

The description is adequate for a straightforward parametric surface creation tool, and the schema fills in parameter details. However, it does not explain the purpose of the optional support surfaces, what a successful call returns, or how this tool relates to similar GSD surface tools. These gaps are meaningful for an agent deciding whether and how to invoke it.

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

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

Schema description coverage is 100%, so every parameter already has a meaningful description. The tool description does not need to repeat that detail; it simply frames the operation at a high level. This fits the baseline for a fully documented schema without adding extra parameter-level insight.

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 (Blend), a clear resource (two curves or edges), and the resulting output (transition surface). It is easy to understand, but it does not explicitly distinguish itself from nearby GSD surface tools like fill, sweep, or multi-section, so it stops short of a 5.

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

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

The description gives a basic sense of what the tool does but provides no guidance on when to use it instead of alternatives such as catia_gsd_fill, catia_gsd_sweep, or catia_gsd_multi_section. No exclusions, prerequisites, or selection criteria are given, leaving the agent to infer appropriate usage.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the description carries the burden of disclosing mutation behavior. The description only says 'Create' without elaborating on side effects, such as whether it adds an element to the tree, requires an active geometry set, or may fail if prerequisites are missing. It does not mention error conditions or what the operation modifies.

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

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

The description is a single, efficient sentence that front-loads the core purpose and then enumerates modes. It has no fluff and uses semicolons to compactly present the mode logic. However, it omits some context that could be added without length, but overall it is well-structured and concise.

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

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

With 8 parameters, no required fields, and no output schema, the description leaves significant gaps. It does not explain how the tool behaves without required parameters for a given mode, what it returns (e.g., a reference token), or how it integrates with the broader GSD workflow. The schema covers parameter definitions, but the description fails to provide the contextual framing needed for safe and correct usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the three modes and the parameters each requires (e.g., center_radius needs a center point, support plane, and radius). This goes beyond the schema's per-parameter descriptions and clarifies how the parameters interrelate across modes.

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 'Create a circle or arc' which clearly identifies the verb and resource. It does not explicitly distinguish from similar sibling tools like catia_sketch_circle or catia_sketch_arc, but the 'gsd' prefix and the listing of distinct modes provide enough differentiation. The purpose is clear but lacks explicit sibling differentiation.

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

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

The description lists three modes but gives no guidance on when to use this tool versus alternatives (e.g., sketch-based circles, other GSD curves). It does not state when to select each mode or mention prerequisites like requiring an active part or document. There is no explicit 'use this when' or 'prefer that if' language.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the agent knows this is a modifying operation. The description adds the precondition of watertightness and the tip to join/heal first, which is useful context. However, it doesn't describe the exact result or side effects, but given annotations cover the safety profile, this is adequate.

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

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

The description is one concise sentence that front-loads the action, states the condition, and offers a practical tip. No redundancy or wasted words.

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

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

For a simple operation with no output schema, the description provides the essential precondition (watertight) and a remediation tip (join/heal). It's complete enough for an agent to know when and how to use it. Minor gap: it doesn't explicitly state that the result is a new solid feature, but that's implied by 'into a solid'.

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 100%, with both parameters (name and surface) having descriptions. The description doesn't add parameter-specific details but provides context about the surface needing to be watertight, which is relevant. Baseline 3 is appropriate since the schema does the heavy lifting.

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 'close' with a specific resource 'watertight surface' and result 'solid'. It clearly distinguishes from sibling tools like join and heal by defining the condition that must be met, making the tool's unique 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?

It explicitly advises to 'join and heal the pieces first if needed', which implies when to use this tool (only on watertight surfaces) and when not to (when surface is not watertight). While it doesn't name alternative tools, the reference to join and heal serves as clear guidance for preparation.

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 all neutral/false, so the description carries most of the behavioral burden. It discloses that the tool creates a geoset and makes it the target for subsequent calls, but it does not describe what happens if a set with the same name already exists or whether the previous active target is changed.

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 wasted words. The primary action is front-loaded, and the second sentence provides useful rationale without padding.

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

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

The tool is simple with two optional parameters and no output schema, and the description covers purpose and typical usage. However, it leaves gaps around naming behavior, what happens with the default empty name, and what the caller receives in return.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents both parameters. The description adds the conceptual point about named sets but no additional parameter-specific semantics beyond what the schema provides.

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

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

The description states a specific action ('Create a geometrical set'), the resource it operates on, and its purpose ('hold surface and wireframe geometry'). It also clarifies that the created set becomes the target for subsequent GSD calls, which clearly differentiates it from siblings like catia_gsd_set_active_geoset.

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

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

The description gives clear context: use this when you need a new named container for GSD construction geometry and want it to be the active target. It does not explicitly say when to prefer catia_gsd_set_active_geoset instead, so it lacks explicit exclusions, but the usage context is clear.

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

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

Annotations provide no meaningful safety hints (readOnlyHint=false, destructiveHint=false). The description adds behavioral context by stating the result is 'independent' and that extraction is a clean reuse of topology – implying a non-destructive copy. It does not detail failure modes or what happens to the source, but the 'independent' phrasing covers the key trait.

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

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

Two sentences, with the core operation and result front-loaded. The second sentence earns its place by framing the use case. No filler or redundancy.

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

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

For a 4-parameter tool with full schema coverage and no output schema, the description covers what is produced (independent surface/curve) and why to use it. It omits an explicit note that the source geometry remains intact, though 'independent' implies this – a minor gap.

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

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

Schema description coverage is 100% for all four parameters, so the schema already documents each parameter adequately. The description adds only loose alignment ('face, edge or connected elements' maps to `element`) without extra syntax or selection 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 uses a specific verb ('Extract') with a distinct resource ('face, edge or set of connected elements') and a clear result ('into an independent surface or curve'). It clearly differentiates from siblings like catia_remove_face (removes) and catia_list_faces (lists).

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 second sentence gives clear context for when to use this tool ('the clean way to reuse solid topology in surface work'), which signals a specific use case. However, it does not name alternative tools or explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint=false, indicating a modifying operation, and the description adds that it creates a surface, which is consistent. However, the description does not disclose any further behavior such as side effects, required context (e.g., active document), or failure conditions. It adds minimal value beyond the annotation.

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, clean sentence that is front-loaded with the core purpose. No wasted words. It is appropriately concise for a tool with a well-defined schema.

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

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

For a tool with six parameters and no output schema, the description is thin. It does not explain what a 'profile' refers to, how direction is interpreted (e.g., relative to sketch plane), or any behavior when parameters are omitted (e.g., default direction). An agent may need to infer from the sibling tools or schema, which is insufficient.

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

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

Schema description coverage is 100%, so each parameter (profile, direction, length, length_reverse, name, geoset) already has a description in the schema. The tool description adds no extra meaning beyond the schema, so baseline 3 applies.

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

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

The description clearly states the action: extrude a profile along a direction to make a surface. It specifies the resource (profile) and outcome (surface), which distinguishes it from solid extrusion tools like catia_pad. However, it does not explicitly differentiate from other GSD surface tools like revolve or sweep, though the name implies 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?

No guidance is provided on when to use this tool versus alternatives such as catia_pad (solid extrude) or catia_gsd_sweep/revolve. There is no mention of prerequisites, nor exclusions. The description only states what it does, not when to choose it.

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

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

The description plainly implies a surface-creation operation, which is the crucial behavioral fact. Annotations are unhelpful (all false), so the description carries some burden, but it does not disclose whether an existing element is overwritten, where the new surface is placed, or what happens with an invalid boundary.

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 conveys the core operation with no filler. The essential information 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?

For a relatively simple surface-creation tool, the description covers the core operation and the schema covers parameters. Missing elements include typical failure modes, output/return behavior, and guidance on how boundaries should be selected or combined, but these gaps are not critical given the schema's parameter descriptions.

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 100%, so the schema already documents all three parameters with descriptions. The description adds marginal meaning by clarifying that boundaries can be curves or edgesholars, but it does not elaborate on name or geoset 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 states a specific verb, 'fill', a specific resource, 'closed boundary of curves or edges', and the result, 'a surface'. It is clearly distinguishable from most GSD siblings like extrude or revolve, though it does not explicitly contrast with the nearby catia_gsd_close_surface.

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

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

The usage context is implied: use this when a closed boundary of curves or edges exists and a filled surface is needed. However, it gives no explicit when-not-to-use guidance or alternatives for open boundaries or other surface-creation scenarios.

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

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

Annotations are all negative hints (readOnlyHint=false, destructiveHint=false), so the description carries the burden of explaining side effects. It does not state whether the original surfaces are modified or a new healed geometry is created, nor does it describe behavior when gaps exceed merging_distance beyond a basic purpose.

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. It states the action, the target resource, and the purpose efficiently.

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

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

There is no output schema and the description is too sparse for a complex GSD healing operation. It omits return/result behavior, side effects on input surfaces, and clear differentiation from closely related sibling tools, so an agent lacks enough context to invoke it with confidence.

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

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

Schema description coverage is 100%, so parameter meanings are already fully documented in the input schema. The description adds little parameter-specific value, but the full schema coverage keeps this at the baseline.

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

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

The description uses a specific verb ('heal') and a specific resource ('small gaps between surfaces'), and explains the intended outcome ('so they can be joined or closed into a solid'). This clearly differentiates healing from sibling operations such as catia_gsd_join or catia_gsd_fill.

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

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

The phrase 'so they can be joined or closed into a solid' implies a preparatory use case, but the description does not explicitly state when to choose healing over related operations like catia_gsd_join or catia_gsd_close_surface. No exclusions, prerequisites, or alternative conditions are provided.

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

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

Annotations provide no safety hints (all false), so the description must carry the burden. It only states creation and does not disclose preconditions (e.g., required existing axis/start point tokens), side effects on the part, or return behavior.

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

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

One concise sentence, front-loaded with action and object, no wasted words. The structure is ideal for quick scanning.

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

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

With 8 parameters, no output schema, and no annotations easing the burden, the description is too sparse to fully guide usage; it lacks details on prerequisites, behavior when inputs are invalid, and what the result is (e.g., a new feature).

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?

All parameters are fully described in the schema with high coverage, so the description adds no extra parameter semantics; it only gives general context about springs/threads. Baseline score is appropriate since schema carries the details.

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

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

States a specific verb ('Create') and resource ('helix around an axis'), and even gives a use-case ('for a spring or a thread'), which differentiates it from other GSD creation tools like sweep or extrude. The description is precise and unambiguous.

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

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

Implies usage for helixes but does not contrast with alternatives such as catia_thread or catia_gsd_sweep. No explicit when-to-use vs other tools, and no exclusions, leaving the agent to infer from context.

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