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

Annotations only declare destructiveHint=true, readOnlyHint=false, and openWorldHint=false. The description adds crucial behavioral context beyond that: the asynchronous nature ('job_id, status, cache_hit'), the dependency on ElmerSolver, the fact that it returns a degradation dict or job ID, and the exact return structure for both duct and cavity types. No contradictions with annotations.

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

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

The description is relatively long, but it is well-structured with distinct sections for duct and cavity modes, and every sentence adds substantive information about physics, parameters, or returns. It is appropriately front-loaded with the purpose and the sibling relationship, and the length is justified by the tool's complexity. A 4 reflects that it is not overly concise but each 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?

For a tool with 15 parameters, no output schema, and no required params, the description covers the two analysis modes, the physics, the return formats, the dependency on ElmerSolver, and the async behavior. It is fairly complete, though it omits explicit explanations for a few parameters (nx, ny, sif, n_elements, length_m) and the degradation dict is only mentioned without detail. Still, it provides enough context for an agent to understand the tool's purpose and likely usage.

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

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

With 0% schema description coverage, the description carries the full burden of explaining the 15 parameters. It gives meaningful semantic context for many key ones (kl, mode_nx, mode_ny, span_pct, n_steps, case_dir, lx_m, ly_m) through physics descriptions and formulas. However, it does not explicitly explain every parameter (e.g., nx, ny, sif, length_m, n_elements), leaving minor gaps, so a 4 is appropriate rather than 5.

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 (submit acoustic FEM) with two explicit modes (duct and cavity), and immediately distinguishes itself from the sibling acoustic_screen as 'the higher-order twin'. It clearly communicates the resource being acted upon and the physics being solved, making it distinguishable without opening any 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?

Explicitly names the alternative `acoustic_screen` and frames itself as the higher-order, more accurate FEM version, implying when each should be chosen. It also states the precondition `Requires ElmerSolver` and the graceful fallback when absent, which guides the agent about environment requirements and expected behavior.

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 readOnlyHint=false and destructiveHint=false, so the description carries the burden of explaining async out-of-process behavior, dependency conflicts, and degradation on missing venv. It does not fully disclose what happens to stale jobs, cache behavior, or potential resource consumption, but it covers the key operational facts.

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

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

The description is dense and information-rich, but it is fairly long and packs many details into a single paragraph without clear structure. It front-loads the core purpose and async caveat, though the parenthetical details about meshio and venv could be more compact. Overall, every sentence adds value, so it earns a 4 rather than a 5 for structure.

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

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

The description covers the three modes, the gating oracles, return shapes, degradation behavior, and the relationship to acoustic_fem_submit. However, there is no output schema and the description doesn't explicitly explain how the returned job_id should be polled or what timeout means in the async context. For a 15-parameter asynchronous tool with no output schema, it is close but not fully complete.

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

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

Schema coverage is 0%, so the description must compensate. It explains many parameters in context: a_m, u_amp, freq_hz, rho, c, h, ka_list, theta_deg, h_per_wl, model, scale_to_m, linear_deflection, problem. It still leaves timeout and some optional fields' exact ranges unexplained, but the major usage semantics are covered.

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

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

The description clearly states that this tool performs an exterior-acoustics boundary-element solve on Bempp, covering three problem modes (radiation, scattering, mesh_solve), and contrasts itself with analytic oracles and the acoustic_fem_submit sibling. It is specific about the resource and the operation.

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

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

The description explains when to use this tool: for exterior-acoustics BEM problems, and explicitly says it is the twin of monopole_sphere and rigid_sphere_scattering analytic oracles, with gating criteria. It also warns when it should not be used or when it degrades to a failure dict due to missing Bempp venv, which effectively guides an agent away from relying on it in unsupported environments.

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 goes well beyond the read-only annotation by revealing exact formulas, accuracy tolerances (±10 %, ±3 dB), sound-speed dependency, return fields, and the `escalate_to` signal. It also distinguishes exact vs approximate branches. No contradiction with annotations.

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

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

The description is dense and information-rich, but delivered as one long pipe-separated block; the front-loaded 'NO solver' is helpful. It could benefit from clearer per-kind bullets or a summary sentence, but every clause adds necessary behavior.

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 14-parameter tool with no output schema and no enum annotations, the description fully covers accepted kinds, required parameter combinations, return shape, and escalation route. An agent has enough to call it correctly without opening schemas.

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

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

With 0% schema coverage and no enums, the description carries the full burden of documenting 14 parameters. It maps each `kind` to exactly the required params (e.g., `lx_mm`/`ly_mm`/`lz_mm` for cavity_modes, `neck_area_mm2`+`neck_length_mm`+`cavity_volume_mm3` for helmholtz) and explains `t_ambient_c` vs `c_m_s`. This is comprehensive compensation.

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

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

The description opens by declaring a specific function—closed-form acoustic screening—and explicitly says it is NOT a solver. It enumerates each `kind` with its formula and application, which cleanly distinguishes it from the solver sibling `acoustic_fem_submit` and other acoustics 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 provides a clear decision rule: use this closed-form screen for estimates, and escalate to Elmer `acoustic_fem_submit` when margins are within ~2× the fidelity band. It does not enumerate comparisons to every acoustic sibling (e.g., `waveguide_cutoff`), so guidance is strong but not exhaustive.

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

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

Beyond the annotations (readOnlyHint: false, destructiveHint: false), the description adds meaningful behavioral context: it specifies the coordinate system (origin bottom-left, +Y up, mm) and the exact return value ({handle, name, text}). This helps the agent understand the side-effect of creation and the expected output without contradicting the annotation flags.

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: the first states the core action and positional context, the second lists the return fields. No filler words, and the most decision-relevant information (the spatial behavior) is front-loaded.

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

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

For a simple mutation with five parameterstons and no output schema, the description covers the key facets: what is added (free text), where (page position with mm), and what is returned. It lacks details about potential side effects or page identification nuances, but those are likely implicit in the CAD context. Given the tool's simplicity, this is sufficiently complete.

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

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

With 0% schema description coverage, the description must compensate. It explains x and y as page coordinates in mm with a defined origin and orientation, and implies text is free form. However, it leaves 'page' and 'name' semantics implicit (though their roles are somewhat predictable). The description partially fills the gap but not fully.

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

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

The description clearly states the action and resource: 'Add a free text annotation to a drawing page.' The phrase 'free text annotation' distinguishes it from dimension, feature note, GDT callout, and other annotation siblings. It doesn't name an alternative explicitly, but the specificity of 'free text' plus the coordinate placement details 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?

There is no explicit guidance on when to use this tool versus the many similar annotation tools in the sibling list (e.g., add_dimension, add_feature_note, add_gdt_callout, annotate_face). The only implicit hint is the phrase 'free text annotation,' but no conditions, exclusions, or alternatives are mentioned. An agent would have to infer usage from the name and description alone.

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

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

The description goes well beyond the annotations by detailing error conditions ('Raises ValueError if the designation is unknown... or if outer_diameter <= bore'), the return payload with field meanings (handle, designation, orderable, catalog), and the semantic distinction between an orderable designation and a raw dimensional envelope. It also clarifies that seal variants do not change geometry but are part of the orderable identity, which is non-obvious behavior. No contradiction with the readOnlyHint=false 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?

The description is front-loaded with the core purpose and geometry, then organizes the two specification modes, seal semantics, and error/return behavior in a logical flow. While it is long (about 300 words), each section carries necessary semantic detail and no filler. It could be more scannable with bullets, but the paragraph structure is coherent.

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

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

Given the tool has no output schema and the annotations are minimal, the description compensates by explaining the full return contract: the returned handle prefix, the None designation for explicit-dimension envelopes, and the orderable/catalog semantics. It also covers coordinate orientation, placement, and error cases. The only missing context is the 'name' parameter, which is a minor defaulted field.

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

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

With 0% schema coverage, the description must explain all parameters and largely does: bore, outer_diameter, width, designation, seals, and placement each receive explicit meaning and application (e.g., 'bore: inner-bore diameter mm (sizes the shaft)'). It even provides a known-designation list and an example mapping. The only omitted parameter is 'name', which is a generic defaulted string, so the gap is minor.

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: 'Add a deep-groove ball bearing as an assembly *envelope* solid'. It clarifies the geometric nature (annular ring, axis along +Z, balls/races not modeled) and distinguishes it from other mechanical component adders like add_gear or add_pulley. The mention of the coordinator's sizing needs further specifies its role.

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 states the intended use case: 'the fit envelope a coordinator needs to size the shaft, the housing bore, and the shoulder spacing.' It also explains the two mutually exclusive input modes (designation vs explicit dims) and when explicit values override table values. However, it does not name sibling alternatives or explicitly say when not to use this tool.

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

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

The description discloses the return shape, that the printed value is the true measured length (not foreshortened), and how tolerances are rendered. Annotations already flag the tool as non-read-only and non-destructive; the description adds useful behavioral specifics without contradicting them, though it does not detail document-level side effects like save/undo.

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 long but well-structured: a one-line purpose, bulleted modes, a parameter key, and a return-value note. It is front-loaded with the core purpose and each section earns its place, though a few details (e.g., 'issue #108', the machinist aside) are minor extras.

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 11-parameter tool with no output schema and no schema param descriptions, this is highly complete: it covers modes, tolerance semantics, view resolution, and the return value. It omits an explicit treatment of the required page parameter and error/edge cases, but those are minor given the overall clarity.

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

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

Schema description coverage is 0%, so the description carries the full weight, and it does: it explains every mode, the allowed kind values, tolerance JSON formats, point arrays, views naming, and half_angle. The only required parameter, page, is implied by the opening sentence; all other parameters receive explicit semantic meaning beyond the bare 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 opens with a specific verb and resource ('Add dimension(s) to a drawing page') and then enumerates five distinct modes, making the tool's purpose unmistakable. It is clearly differentiated from sibling annotation/note/GDT tools by its focus on measurements and dimension objects.

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 'Modes (pick one)' section acts as an internal decision tree, telling the agent exactly when to use auto vs. view+edge vs. view+face vs. from/to points. It does not explicitly name sibling alternatives or exclusions, but the context is clear and actionable.

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

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

The description adds substantial behavioral detail beyond the minimal annotations: threads are cosmetic, grade changes only the orderable designation, unrecognized grades are loud errors, non-stocked lengths still produce a solid, and return fields vary by kind. This gives the agent an accurate model of side effects and edge cases.

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 long but every sentence carries essential information, and it is well-structured with per-kind bullets and a grouped return list. It remains readable despite its density because the information is organized and 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?

There is no output schema, so the description must explain return values and edge cases, and it does so thoroughly: per-kind extra fields, mating hole guidance, designation/orderable semantics, and catalog findings. An agent has enough context to call 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?

With 0% schema description coverage and no enums, the description fully compensates by documenting every parameter: the kind values, valid ISO sizes, length requirements, grade semantics and standards, placement coordinate system, and name default. This is far richer than the bare input 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 and resource: 'Add a standard ISO metric fastener (screw / bolt / nut / washer) as a solid.' It clearly enumerates the four kinds and gives enough detail to distinguish the tool from sibling add_* tools like add_bearing or add_gear.

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 strong context for when to use the tool: adding standard ISO metric fasteners as solids, with detailed per-kind behavior. However, it does not explicitly mention alternatives or exclusions, leaving some of the when/not-when guidance implicit.

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

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

Annotations already signal this is not read-only and not destructive, so the description's main job is to add context beyond that. It does: it explains that text defaults to a sensible callout, that drawing_gate reads the note back as coverage, and that the tool returns a specific object shape. This meaningfully clarifies the tool's effect.

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

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

The description is dense but front-loaded: the core purpose appears first, followed by useful examples and the return shape. The parenthetical issue reference adds some noise, but overall every sentence contributes meaningful selection or invocation guidance.

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

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

Given the tool has 7 parameters and no output schema, the description covers the key external dependency (drawing_gate's enumerated_features), the return value, and the default text behavior. It is slightly incomplete around what 'page' refers to and where x/y place the note, but it is sufficient for an agent familiar with drawing-page tools 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 0%, so the description must compensate. It does explain the most important parameter, 'feature', with enumerated examples and its source, and it clarifies that 'text' defaults to a callout. However, required parameter 'page' is left unexplained, and x/y, kind, and name receive no semantic guidance beyond schema defaults.

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

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

The description states a specific action ('Attach an explicit manufacturing NOTE') and resource, and ties it to a concrete purpose: satisfying curved/periodic feature coverage that drawing_gate enumerates. It distinguishes itself from generic annotation tools by explaining that it handles geometry a single number cannot capture.

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 indicates when to use the tool: for freeform/BSpline profiles, tooth patterns, and cone angles that need per-CAD-model or profile-table coverage. It does not explicitly name alternative sibling tools or say 'use X instead', but the contrast with 'geometry a single number can't capture' implies the boundary against simple dimension/annotation tools.

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

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

Annotations provide only readOnlyHint/openWorldHint/destructiveHint flags, so the description carries the full disclosure burden. It reveals that the frame renders as a real compartmented symbol, that diametral controls render with a Ø, that inspection_plan/fai_report read the callout back as a characteristic, and that datums change the selected inspection instrument. This goes well beyond what annotations or schema 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?

The description is lengthy but organized: purpose first, then a clarifying contrast, then a scannable parameter list, then the return shape. Every section adds useful information, though the CMM/surface-plate explanation is slightly beyond what is strictly needed to invoke the tool correctly.

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

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

Given the 11 parameters, no output schema, and zero schema coverage, the description covers most invocation needs: parameter meanings, coordinate origin, return fields, and downstream inspection behavior. It is not fully complete because the required page parameter remains unexplained and optional view/name semantics are absent.

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

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

With 0% schema description coverage, the description compensates substantially: it documents control values, zone units, datums format, feature source, mmc_bonus, modifier, and x/y coordinate conventions. However, the required page parameter is never defined, and view and name receive no semantic guidance, leaving a meaningful gap for a required argument.

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 concrete verb-resource pair, 'Place a GD&T feature control frame on a drawing page,' and explains what the result is: a real compartmented symbol readable by inspection tooling. It explicitly distinguishes itself from gdt_check by framing this as declaring tolerance on the drawing rather than only checking a measurement.

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 instead of gdt_check: declaring the tolerance on the drawing is what makes it inspectable by inspection_plan and fai_report. It also adds useful downstream context about datum-based controls being CMM work versus datum-free form controls being surface-plate work, though it does not enumerate exclusions against other annotation tools such as add_annotation or add_dimension.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses that the result is extruded to a solid, lists the exact return fields, and explains meshing behavior for external gears (spacing equal to pitch_radius_a + pitch_radius_b plus half-tooth phasing). This adds meaningful behavioral context beyond what annotations convey.

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

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

The description is compact and efficiently structured: it opens with the core purpose, then systematically lists each parameter, followed by the return fields and a practical meshing note. Every sentence provides essential information without 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?

Given 7 parameters, no output schema, and minimal annotations, this description gives the agent everything needed to call the tool correctly: parameter meanings, formulas, defaults, return values, and even inter-gear spacing guidance. Nothing critical is missing for successful invocation.

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

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

With 0% schema description coverage, the description fully compensates by explaining teeth (minimum 3), module with the pitch diameter formula, height as extrusion thickness, pressure_angle with default, external as an internal/ring toggle, and placement as an optional translation. It omits only the trivial 'name' parameter which has a default.

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: 'Add an involute spur gear (FreeCAD's core involute generator), extruded to a solid.' It uses a specific verb and resource, and mentions the FreeCAD generator, which differentiates it from sibling tools like add_rack, add_sprocket, and add_pulley.

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 comprehensive parameter semantics and a pitch diameter formula, making the usage context clear. However, it does not explicitly mention alternatives or when not to use this tool, leaving the agent to infer from sibling names. This is a clear context without exclusions, but not fully explicit about alternative selection.

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

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

Annotations indicate readOnlyHint=false (so it's a write operation) and destructiveHint=false, but the description adds little behavioral context. It mentions the App::Link mechanism and references publish_interface for frames, which gives some insight into the linking behavior, but it does not disclose side effects like modification of the active assembly, error behavior when the source is invalid, or whether the operation is reversible. For a mutation tool with minimal annotation coverage, this is a significant gap.

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

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

The description is efficiently structured with a clear main sentence followed by bullet-like enumerations for source, placement, and mate. It avoids redundant phrasing and packs useful detail into a compact format. Length is appropriate for the complexity of the parameters, though the missing assembly/name explanations prevent a 5.

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?

Without an output schema, the description should ensure callers know how to invoke the tool correctly. It covers the complex parameters in depth but leaves 'assembly' and 'name' semantically undefined, and it does not mention prerequisites (e.g., an open assembly or how to obtain a handle). The reference to publish_interface implies prior knowledge. Given the nested structures and required parameters, the description is incomplete for an agent to reliably use it without additional context.

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

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

Schema description coverage is 0%, so all parameter meaning must come from the description. The description thoroughly explains 'source' (three formats), 'placement' (array or object), and 'mate' (structure and purpose), but it omits explanations for 'assembly' and 'name.' 'name' has a default but no semantic detail, and 'assembly' is a required string with no description of what it refers to (e.g., assembly handle, path, or ID). Thus it partially compensates for the missing schema but leaves gaps.

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

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

The description states a specific action ('Add a part to an assembly via App::Link') with a clear resource and method. It goes beyond a tautology by explaining the linking mechanism and differentiating from other add_* tools (e.g., add_primitive, add_gear) which create new geometry rather than link existing sources. 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 provides no guidance on when to use this tool versus alternatives or when not to use it. It explains how to specify sources and mates but never mentions conditions like 'if you need to reference an existing body or external file, use add_part.' There is no reference to siblings or exclusions, leaving the agent to infer usage from the name.

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

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

Beyond the annotations (readOnly=false, destructive=false), the description discloses important behaviors: the difference between FreeCAD's internal Name and the display label, the effect on list_objects, bom_extract, and drawing/manifest layers, the default-label behavior treated as an unnamed generic solid by BOM/designation checks, and the returned handle's role in later boolean_op calls.

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 front-loaded with its one-sentence purpose, followed by dense parameter explanations and a return-value contract. The longer name/label discussion is justified because it prevents a subtle misuse around FreeCAD Name stability and BOM labeling, with no redundant restatement of schema defaults.

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 seven parameters, no enums, and no output schema, the description is complete: it defines the kind vocabulary, per-kind dimension usage, placement units/format, naming semantics and downstream consequences, and the exact return shape including how the handle is used in subsequent boolean_op calls.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains the kind values, which parameters each kind uses (box uses w/d/h, cylinder uses r/h, sphere uses r), that placement is an optional [x, y, z] mm translation, and the precise meaning and side effects of the name parameter.

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

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

The description states a specific action and resource: 'Add a primitive to the active document,' then enumerates the exact supported primitive kinds (box, cylinder, sphere). This clearly distinguishes add_primitive from the many add_* sibling tools such as add_gear, add_bearing, or add_fastener.

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

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

It gives clear operational context: it targets the active document, supports optional placement and naming, and tells which dimension parameters apply to each kind. It does not explicitly name alternatives or state when not to use it, but the kind enumeration effectively scopes selection and no exclusions are necessary.

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

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

Annotations indicate the operation is not read-only and not destructive, which aligns with the 'add' action. The description adds useful detail about the views parameter and the concept of a multi-view projection group, but it does not disclose potential side effects, dependencies (e.g., needing an existing page), or failure modes. This is acceptable given the simple nature of the operation, but it is not overly transparent.

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

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

The description is concise (two short sentences) and front-loads the core purpose. It avoids unnecessary verbosity, though the views list could be formatted more cleanly. Overall, it is efficient and earns its place.

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

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

Given the schema provides no parameter descriptions, the tool description should explain all parameters and any required context. It only partially covers `views` and `body`, omitting `page` and `name`, and does not mention return values or prerequisites. This is a significant gap for a tool that requires two mandatory parameters and likely needs an existing drawing page.

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

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

With 0% schema description coverage, the description must compensate, but it only explains the `views` parameter (with example codes) and implicitly mentions `body`. It does not explain `page` or `name`, leaving their roles ambiguous beyond what the schema names indicate. This is insufficient for a 4-parameter tool with no schema-level descriptions.

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

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

The description clearly states the action ('add'), the resource ('a multi-view projection group of `body`'), and the destination ('to a drawing page'). This distinguishes it from sibling tools like add_section_view or add_dimension, making its purpose unambiguous.

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

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

The description offers no guidance on when to use this tool versus alternatives such as add_section_view or render_view. It does not mention prerequisites or contexts where this tool is preferred, leaving the agent to infer usage from the name and brief description.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds useful behavioral detail beyond those annotations: the +Z axis orientation, the z-span of the toothed belt face, the flange construction rule, the height-overrides-width behavior, and the exact return dictionary. It does not spell out the side effect on the active document, but the 'add' verb plus the non-read-only annotation make that clear.

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

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

The description is long but every sentence carries necessary information: formulas, defaults, geometry orientation, and return values. It is front-loaded with the core purpose and then systematically covers each parameter in order, with no filler or repetition.

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

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

Given 0% schema coverage and no output schema, the definition is nearly complete: it includes all parameter semantics, units, geometry behavior, and return fields. The only minor gap is that 'V pulley' is mentioned but no parameter or formula is provided for V-groove geometry, leaving that variant underspecified; the timing-belt path is fully covered.

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

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

Schema description coverage is 0%, so the description must fully document all 7 parameters, and it does. It explains teeth count minimum, belt_pitch units and pitch-diameter formula, width meaning, flange geometry, height override semantics, placement translation, and the name label. This far exceeds the minimum and gives the agent everything needed to call the tool correctly.

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

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

The description opens with a specific action and resource: 'Add a timing-belt (or V) pulley as a static solid.' It clearly identifies the tool's purpose and distinguishes it from sibling add_gear, add_sprocket, and add_bearing tools by focusing on pulley-specific concepts like belt_pitch, teeth, and flanged retainers.

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: when a timing-belt or V pulley is needed as a static solid, including mating geometry through pitch_diameter. It does not explicitly name alternative tools or give when-not conditions, but the purpose is specific enough that an agent can select it correctly without opening other schemas.

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

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

With sparse annotations (only readOnlyHint false, destructiveHint false), the description carries the burden of explaining side effects)Skip it: it details the resulting solid's geometry, orientation, plane, defaults, and return values. It does not explicitly state document-level effects, but 'Add ... as a solid' plus the annotations convey the mutation safely.

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 organized with a clear intro, a geometry paragraph, a parameter list, and a return/usage section. Some redundancy exists (e.g., tooth_height appears both in the profile description and the return list), but every piece earns its place for a parametric entity of this complexity.

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

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

Despite no output schema, the description enumerates return fields with formulas likely needed for downstream checks. It covers geometry, defaults, constraints, placement, and mating behavior with a spur gear, leaving no critical gap for invoking 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?

Input schema has 0% description coverage, so the description fully compensates by explaining every parameter: teeth, module, height, width, pressure_angle, placement, and name, along with units, defaults, constraints, and formulas. This is exactly the semantic depth needed for correct invocation.

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

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

The description uses a specific verb ('Add'), resource ('linear gear rack'), and a clarifying definition ('a spur gear's straight counterpart'), which immediately distinguishes it from the sibling add_gear. The dental geometry and context make the tool's purpose unmistakable.

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

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

The description provides clear application context: it explains how a rack meshes with a spur gear and the significance of matching pitch and length. It stops short of explicitly naming when to prefer this over add_gear, but the 'straight counterpart' framing makes the selection context unambiguous.

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

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

Beyond the annotations, the description discloses that the operation mutates the body by adding material, returns the whole body's volume after the rib (strictly greater than before), and details the fallback implementation: native PartDesign::Rib is unavailable, so it builds an equivalent midplane PartDesign::Pad, which may differ for intricate spines. It also lists exact error conditions (ValueError and RuntimeError). This is exceptionally rich behavioral disclosure.

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 front-loaded with a one-sentence summary, then clearly labeled Args, Returns, and Fallback sections. Although long, every section earns its place: parameter meanings, return shape, fallback behavior, and error cases are all operationally relevant. The structure makes the length navigable rather than 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 mutating CAD operation with no output schema and no schema descriptions, the description is complete. It covers all six parameters, the return dict structure, the fallback implementation, and error conditions. It even explains why volume is strictly greater. Nothing needed to invoke it 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?

The input schema has 0% description coverage, so the description must fully document parameters. It does: body, sketch, thickness, midplane, reversed, and name each have prose explanations, including constraints (thickness > 0, sketch must be open, midplane centering, reversed purpose). This completely compensates for the schema gap.

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

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

The description opens with a precise verb phrase: 'Add a reinforcing rib/web inside a PartDesign Body by thickening an OPEN sketch profile into a wall that fuses with the body's surrounding material.' This clearly states the operation, the resource (PartDesign Body), and the key distinction from siblings: the input must be an OPEN sketch profile. It fully explains what the tool does and makes it distinguishable from pad/pocket/extrude alternatives.

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

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

The description states the intended use case (adding a reinforcing rib/web) and gives critical preconditions: the sketch must be an open spine, not a closed loop, and the attachment plane sets orientation. It also provides fallback context explaining when the native Rib is unavailable. However, it does not explicitly name alternatives or say 'use pad/pocket for closed profiles,' so when-not-to-use guidance is only implied.

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

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

Annotations only declare readOnlyHint=false and destructiveHint=false, so the description carries the burden. It explains that the view is added conditionally when auto=True, that the cut runs lengthwise through a feature, and the return structure. It does not contradict annotations; it enriches them with conditional behavior and output details.

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

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

The description is logically structured: purpose and condition first, then parameter semantics, then return format. It is dense but without filler. The auto explanation is given in a dedicated paragraph, which is useful. It is slightly long but every sentence adds value, so it earns a 4.

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

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

Given the tool's role in a drawing workflow, the description covers the core decision (when to add), the key parameters, the return shape, and a related tool (drawing_gate) for pre-decision. It does not mention prerequisites like an existing drawing page, but those may be inferred from the page parameter. Overall it is sufficiently complete for an agent to invoke 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 0%, so the description must compensate. It explains the auto and process parameters meaningfully, including their effect on behavior. However, it does not describe 'page', 'name', or 'symbol', though these are mostly self-evident. This partial coverage leaves some parameters undocumented, so the description does not fully compensate for the schema's silence.

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 ('Add'), resource ('cross-section view'), and a triggering condition ('when the part has internal features... convey ambiguously — a counterbore, a blind hole/bore, or a pocket'). It is clear and actionable. It does not explicitly differentiate from the sibling 'section_view', but the conditional trigger helps distinguish it from a generic section tool.

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

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

It tells when to use the tool (when internal features are ambiguous) and describes the auto parameter that only adds the section if hidden geometry exists, otherwise returns a recommendation flag. It also references drawing_gate as a pre-check for section_recommended, giving a decision path. It does not name alternative tools, so it's not fully explicit on when not to use it, but the context is strong.

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 (readOnlyHint=false), and the description confirms the mutating 'Add' behavior without contradicting annotations. However, it adds no deeper behavioral context such as whether the constraint is resolved immediately, whether existing constraints are replaced, or what side effects may occur. The non-destructive nature is clear enough for a simple add operation.

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

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

The description is compact and well-structured: a one-line purpose followed by a concise parameter legend. Every line conveys useful information without filler, and the most important parameters are front-loaded.

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

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

The description gives enough to attempt a call, but it omits important operational details: which constraint types require value, how many refs each constraint type expects, and how the sketch parameter identifies a sketch. For a medium-complexity CAD mutation with no output schema and no schema-level descriptions, this is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it enumerates valid constraint types, explains refs as [geom_idx, vertex_role] pairs with numeric role meanings, and clarifies that value is for dimensional constraints in mm or radians. It does not describe the sketch parameter, but the other three parameters are significantly clarified beyond the bare 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 opens with a clear verb and resource: 'Add a constraint to a sketch.' The listed constraint types and refs format make the tool's purpose concrete. It does not explicitly distinguish itself from sibling tools like add_sketch_geometry, but the action and target are unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites such as having an active sketch or existing geometry. The intended context is only implied by the name and first sentence, so an agent gets little help choosing it correctly among the many sketch-related 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?

Beyond the readOnly/destructive annotations, the description discloses a non-obvious behavior: the projected element gets a negative geom index so subsequent constraints can reference it. It also clarifies that the result is construction geometry anchored to upstream geometry, which is exactly the kind of behavioral context annotations do not 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?

The description is dense and front-loaded: a one-line definition, a compact grammar for ref, a behavior note about negative geometry indices, and a motivating use case. Every sentence contributes information, and there is no filler or repetition of schema fields.

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

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

For a two-parameter tool with a nested object and no output schema, the description covers the essential input grammar, the result behavior, and why the user would want this. It omits prerequisites such as whether the sketch must be open, but the core invocation information is present and usable.

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

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

With 0% schema description coverage, the description compensates well by detailing the ref parameter syntax: {handle, edge: tag|'EdgeN'}, the face/vertex variant, and {handle, tag} with e_/f_ prefixes. The sketch parameter is not described, but its name is self-explanatory, and the difficult parameter is covered thoroughly.

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 begins with a specific verb and resource: 'Project an external edge/face/vertex into a sketch as construction geometry.' This clearly distinguishes the tool from siblings like add_sketch_geometry and add_sketch_constraint, and the phrase 'construction geometry' adds precise scope.

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

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

The description gives an explicit use case: 'Use this to make a sketch that stays anchored to upstream geometry' with a concrete example of a hole 5mm from a tagged edge surviving pad-length edits. It does not name alternatives or state when not to use it, but the intended 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 only say the call is not read-only and not destructive; the description adds that it appends geometry and returns Sketcher-assigned indices for use in constraints. It also discloses that arc angles are in radians and that 'construction' is optional on lines, which are useful behavioral details beyond the structured fields.

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

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

The description is compact and front-loaded: one sentence states the purpose, a bullet list defines the item variants, and a final line documents the return value. Every element adds information needed to call the tool, with 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 tool with no output schema and an empty items schema, the description provides the missing contract: item structures, units for arc angles, and the return shape. It doesn't explain how to identify a sketch, and it doesn't mention failure conditions or interaction with add_sketch_constraint beyond the returned indices, but those are minor gaps given the simple parameter set.

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

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

With 0% schema description coverage, the input schema provides no meaning for either parameter. The description compensates well for 'items' by specifying each accepted dict shape and field, but it leaves the 'sketch' string parameter undocumented, assuming the agent will infer it is a sketch identifier.

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

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

The description opens with a specific verb-resource pair ('Append geometric primitives to a sketch') and then enumerates the exact primitive types (line, circle, arc, point). This makes it distinguishable from siblings such as add_sketch_constraint and add_sketch_external without needing 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 purpose statement implies the tool is for adding primitives to a sketch, but it never says when not to use it or names alternatives like add_sketch_constraint. For an agent choosing among many CAD tools, the usage context is clear only by inference from the tool name and sibling list.

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 goes well beyond the sparse annotations by disclosing key limitations: only 'compression' is supported, end coils are not squared yet, and spring rate assumes steel with a fixed shear modulus. It also explains exactly what the tool computes and returns, giving the agent solid behavioral expectations.

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 long but tightly organized into definition, parameter details, geometry formulas, and return values. Every sentence carries distinct technical value, and the core purpose 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 thoroughly documents the return object and explains how to use derived values like free_length, solid_height, and spring_rate_n_per_mm. All input constraints and behavioral assumptions are covered, so an agent can invoke the tool and interpret results 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 0%, but the description fully compensates by defining each parameter with units, constraints, defaults, and geometric meaning. It adds important relationships such as outer_diameter > wire_diameter, fractional coils, and placement coordinates, plus derived output semantics.

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

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

The description names a specific verb and resource: 'Add a helical compression spring' and immediately defines the geometric construction. It clearly distinguishes this tool from other add_* and spring_check siblings by scoping it to compression-spring creation.

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 it clear that this tool creates a compression spring and lists its constraints and supported mode, but it never explicitly names alternatives or states when to prefer another tool. Usage context is implied rather than 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?

The description reveals important behavior beyond annotations: it produces a static solid plate, uses an approximate ISO 606 tooth form, is only for fit/visualisation, and returns a bore of 0. This adds meaningful context that annotations do not provide, and nothing contradicts the readOnlyHint/destructiveHint flags.

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 structured into compact sections: purpose, parameter meanings, construction approach, and return values. Every sentence adds useful information, and despite its length, there is no filler or repetition.

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

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

Given that there is no output schema and no parameter descriptions, the description provides everything needed to call the tool correctly: parameter semantics, defaults, construction behavior, and a full return-object explanation. It even explains the mating relationship between pitch diameter and chain pitch.

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

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

Schema description coverage is 0%, so the description fully compensates. It defines teeth with a minimum constraint, chain_pitch with a concrete example, roller_diameter as chain roller diameter, height with a default, and placement as an optional [x, y, z] mm translation. This adds substantial meaning the schema alone lacks.

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: 'Add a roller-chain sprocket (ISO 606 / ANSI), built as a static solid plate.' This clearly differentiates it from sibling tools like add_gear and add_pulley by naming the exact mechanical component and standard.

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

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

The description gives clear context for when to use it: whenever a roller-chain sprocket is needed. It also includes a when-not limitation ('not a load-rated profile') and a follow-up command (drill the bore with `hole`), though it does not explicitly contrast it against sibling part-creation tools.

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

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

Annotations carry almost no behavioral information, so the description carries the full burden. It discloses a fallback behavior (plain cylinder with modeled=False if the helical sweep fails), the exact geometric truncation rule, the grade designation logic for orderable studding, and the full return shape. This is far more than the annotations provide and is highly useful for predicting tool behavior.

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

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

The description is long but well-organized: core purpose, sibling contrast, parameter details, geometry note, fallback, return values, and mating guidance. Nearly every sentence earns its place, though some sections (e.g., the grade/studding explanation) are more elaborate than strictly necessary. Overall it is dense but structured enough to remain navigable.

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

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

For a complex 8-parameter tool with no output schema, the description covers all bases: parameter semantics, geometry model, fallback behavior, return fields, and practical mating usage. An agent has enough information to decide whether to call this tool, set parameters correctly, and interpret the result without additional lookups.

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

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

Schema description coverage is 0%, so the description must compensate, and it does comprehensively. Every parameter (diameter, pitch, length, internal, starts, grade, placement, name) is explained with units, defaults, semantic meaning (e.g., internal=True bore sizing), and special cases. The description adds meaning that the bare schema completely lacks.

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: 'Generate a REAL helical ISO-style 60-degree thread as a static solid.' It further distinguishes itself from siblings by explicitly contrasting with `hole`/`list_thread_options`, which only flag thread metadata. This leaves no ambiguity about what the tool does or how it differs from nearby alternatives.

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

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

It explicitly names alternatives and the condition for choosing them: 'Unlike `hole`/`list_thread_options` (which only flag a thread as metadata), this cuts actual helical geometry.' It also gives clear internal/external usage guidance, multi-start behavior, and mating instructions for tapped bores and clearance holes, making when-to-use and when-not-to-use explicit.

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

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

Annotations provide only readOnlyHint=false, openWorldHint=false, destructiveHint=false, so the description carries the burden. It discloses that the thumbnail is a vector line drawing, is pinned to the corner, is left put by fit_page, is never dimensioned or counted by the manufacturability gate, and returns a soft failure rather than overlapping content. This is rich behavioral context beyond annotations.

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

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

Every sentence adds distinctive information: purpose, technical rendering path, placement/pinning behavior, failure mode, and call timing. It is dense but not padded, and front-loads the core action.

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 rendering, placement, failure behavior, timing, and return values, which is strong. However, with 0% schema parameter coverage and no output schema, the lack of any parameter semantics leaves a notable gap for an agent to formulate correct arguments.

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

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

The schema has two parameters with zero description coverage, and the description does not explain what 'page' or 'name' refer to. The only hint is the default 'IsoThumb' in the schema. An agent would not know what value to pass for 'name' or what format 'page' expects.

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 ('Place a small isometric pictorial of the part in the top-right corner of the sheet') and clearly identifies the resource and location. It also distinguishes itself from related drawing tools by emphasizing it is a vector TechDraw projection pinned to the corner, separate from fit_page 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?

Explicitly instructs to call AFTER placing views, dimensions, and fit_page, so 'fits' is judged against the final layout. It also explains the best-effort soft-failure behavior when the corner is occupied. It does not name sibling alternatives for when not to use, but the placement timing is concrete.

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 persistence ('persists in the .FCStd as a JSON property bag', 'survives save/reopen'), update semantics ('re-using a name updates that annotation'), and the full return dict — all beyond the destructiveHint annotation. It accurately represents the mutation, and no contradiction 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 description is longer than average but every sentence earns its place: purpose, persistence, integration, parameter details, return value. The parameter block is clearly delineated with 'handle:', 'face:', etc., and the return format is summarized in a compact dict notation. Minor redundancy with the title but no filler.

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

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

Given no output schema, including the exact return dict is essential and done well. The description covers the tool's role, parameters, persistence, and return value. It doesn't mention potential errors or whether the updated document needs saving, but the persistence note implies it, and the destructiveHint covers the mutation risk. Complete enough for an agent to invoke 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 coverage is 0%, so the description carries the full burden. It explains every parameter: handle, face (with allowed forms f_* tag, 'FaceN', or int index), role (with explicit enum values), name (with defaulting and update behavior), and meta (with example). This adds critical meaning beyond the bare 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 opens with a specific verb and resource: 'Declare the semantic ROLE of a face — what it is FOR'. It clearly explains the purpose (intent-based editing) and differentiates itself from related tools by referencing check_airtight_path's downstream consumption. The title 'Annotate Face' is expanded, not just restated.

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: annotations are used 'so later edits can be checked against intent' and explicitly says 'Once declared, check_airtight_path accepts the role/name directly'. It doesn't explicitly mention when not to use it or alternatives like list_face_roles or declare_intent, but the downstream integration and persistence behavior imply the intended use case.

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

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

Annotations already indicate destructiveHint=true, and the description's 'Write a lockfile' is consistent with that. It adds useful behavioral context beyond the annotations: the lockfile contents, the default path, and the return shape. It does not explain overwrite behavior, but the annotation covers the destructive nature.

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 dense sentences with no filler. The core purpose is front-loaded, followed by a usage condition, default behavior, and return shape. 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?

There is no output schema, so the explicit return shape '{lockfile, components}' is valuable. The description also covers when to call it and what the lockfile records. It could mention overwrite behavior, but the destructiveHint annotation already signals that.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the lockfile parameter's default ('<manifest>.lock.json'), but it does not explicitly describe the required manifest parameter, leaving its exact format or meaning to inference.

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: 'Write a lockfile recording each component's content hash, published-interface hash, and mate dependencies.' This clearly distinguishes it from checking or validating a lockfile, especially with siblings like assembly_lock_check.

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

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

It explicitly states when to call the tool: 'Call after a clean merge.' This gives a clear usage condition, though it does not mention when not to use it or name 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?

Beyond the readOnlyHint/openWorldHint annotations, the description explains the logic of each classification, including the subset relationship of interface_changed within modified, what stale means, and the aggregate ok decision. This gives the agent a clear model of the tool's behavior and return semantics.

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

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

The front-loaded opening sentence states the core operation, followed by a tight bullet-like list of categories, the ok rule, and the return object. Every line carries distinct information, and the structure makes the taxonomy easy to scan.

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

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

The description thoroughly covers return values and category semantics despite the absence of an output schema. However, with a bare input schema, it leaves important input details unspecified, such as how to supply the manifest and lockfile and the meaning of the lockfile's null default. Adequate overall, but not complete enough to invoke without additional assumptions.

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

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

With 0% schema description coverage, the description must compensate. It clarifies that the manifest is the set of current component files and the lockfile is the comparison baseline, but it does not explain the expected string format, what a null lockfile means, or whether manifest is a path or serialized content. Partial semantics are provided, with clear gaps.

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

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

The description states a specific action — compare current component files to a lockfile — and enumerates the drift categories it produces. The classification vocabulary (modified, interface_changed, stale, new/removed, ok) makes it distinct from sibling tools like assembly_lock or change_impact.

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 the decision context 'safe to re-merge without re-dispatch', which implies when to use the check. It does not name alternatives or explicitly state when not to use this tool, so it falls short of a full 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?

Beyond minimal annotations, the description discloses key behavior: execution runs off the MCP channel, returns immediately, produces a deterministic result, supports content-hash cache hits, and returns {job_id, status, cache_hit}. This gives the agent a strong behavioral model 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?

Three compact sentences cover purpose, behavior, return format, polling, and caching. The key async behavior is front-loaded, and the aside about real solves is brief and useful.

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

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

For a simple demo tool with two optional parameters, the description covers launch semantics, return payload, polling routes, and caching. It does not describe possible status values or error conditions, but the core information needed to call and follow up is present.

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

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

Schema coverage is 0%, so the description must compensate. It explains duration_s as the compute time and mentions that identical (duration_s, value) pairs trigger a cache hit, but it does not define what 'value' represents or its units/constraints. Partial compensation only.

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: launch an async job that runs off the MCP channel and returns immediately. It clearly identifies the tool as a demo/reference for long-running solves and differentiates it from polling tools like job_status and job_result.

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 intended use case: avoid blocking the worker during multi-minute solves, and explicitly says to poll with job_status / job_result afterward. It does not explicitly enumerate when not to use it versus real FEM/CFD submits, but the 'demo' framing and 'real solve plugs into the same facility' provide clear context.

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

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

The description goes well beyond the annotations (destructiveHint=true) by explaining the identity semantics of balloon numbers: they are persisted, re-running reassigns nothing, additions append, deletions retire numbers, and renumber=True deliberately discards and invalidates records. It also discloses the return shape, which is valuable since there is no output schema. No contradiction with annotations.

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

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

The description is longer than average but organized into purposeful paragraphs: what it does, identity/persistence semantics, ordering, and return value. Nearly every sentence carries information, though some framing like 'This is the print a quality engineer actually works from' is contextual rather than strictly necessary. The important behavioral details are front-loaded.

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

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

For a tool with no output schema and sparse annotations, the description is highly complete. It covers what the tool does, when to call it, what renumbering means, how deleted numbers behave, and exactly what the return object contains. The only minor gap is the precise form of the page argument, but the surrounding drawing context makes the intent sufficiently clear 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 0%, so the description must compensate. renumber is fully explained, including its default behavior and consequences. However, the required 'page' parameter is only indirectly described as 'a drawing page' and 'fit_page has run'; its exact value format or identifier semantics are never clarified. This leaves one of two parameters under-described.

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: 'Number every characteristic on a drawing page with an inspection balloon,' and enumerates exactly what gets numbered (dimensions, feature control frames, feature notes). It also distinguishes this from related drawing operations by tying balloons to inspection_plan and fai_report, making the tool's unique role clear among siblings like add_dimension, add_annotation, and add_feature_note.

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

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

The description gives explicit sequencing guidance: 'Call it after the dimensions are placed and fit_page has run.' It also explains when renumber=True is appropriate and warns that it invalidates existing inspection records. It does not name alternative tools for the same job, but the ordering constraint and the renumber caution provide clear 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 goes well beyond the readOnlyHint annotation, disclosing detailed behavioral aspects: the exact formula, that mass/area/length cancel, contact duration, restitution, yield behavior, and the bilinear material cap. It also explains how material properties are sourced. This adds significant value beyond the annotations and gives the agent a precise understanding of the calculation's behavior.

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

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

The description is a single dense paragraph, but every sentence carries essential information: physics, formulas, parameter sourcing, output list. It front-loads the core purpose and then expands. While it is longer than a minimal description, it is efficient and well-organized, with no filler.

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

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

Given the tool's complexity (physics, material handling, yield) and lack of an output schema, the description is quite complete. It lists all returned fields, explains the theory, and mentions the twin solver. Minor gaps exist: it does not address error conditions, edge cases (e.g., very low velocity), or how 'fidelity' and 'band_pct' are determined, but these are secondary. Overall, it provides enough for an agent to 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?

With schema description coverage at 0%, the description compensates by explaining key parameters: it mentions 'youngs_gpa'/'density_kg_m3' and the 'material' option, explains 'area_mm2' adds force, and discusses 'yield_mpa' and 'tangent_mpa' in the yield context. However, it does not explicitly describe 'velocity_m_s' and 'length_mm' (though they are implied by the physics) or clarify the exact role of 'tangent_mpa' beyond the yield cap. Overall it adds substantial meaning but not exhaustive 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 tool's function: 'St-Venant bar impact, exact (NO solver): a uniform bar striking a rigid wall end-on.' It specifies the verb (compute impact) and resource (bar impact), and differentiates from the twin solver impact_dynamics_submit by calling it 'closed-form twin' and 'gated against'. 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 provides usage context by contrasting with impact_dynamics_submit ('closed-form twin ... gated against') and notes the theory ('Uniaxial-stress (slender bar) theory'). It implies this is a quick analytical alternative to a full solver, but does not explicitly state when to choose it over other impact tools (e.g., drop_impact) or list conditions where it should not be used. This is a clear but not exhaustive 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 declare destructiveHint=true)Skip to content, but the description does not disclose that creating a baseline may be a write/destructive operation (e.g., writing a sidecar file, potentially overwriting existing). It mentions 'write the git-diffable baseline sidecar there' but does not clarify if it modifies the registry or requires special permissions. With destructiveHint not being readOnly, the description should explicitly state side effects. The description does not contradict annotations (it says write, which aligns with destructive), but it fails to carry the burden of behavioral disclosure.

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 well-structured, with an initial summary sentence followed by a paragraph on fingerprinting and then parameter explanations. It is front-loaded with the core purpose. However, it includes extra context (issue #142, C3) which may be unnecessary for tool invocation, slightly reducing conciseness. Overall, it's efficient and readable.

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 6 parameterscars with complex semantics, the description covers each parameter and the return value ('Returns the baseline object'). It also mentions determinism. However, it doesn't explain error conditions or how the 'out' path interacts with the registry, but this is minor. With no output schema, the description's mention of the return object is valuable. Overall, it is quite complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains 'label' as the baseline label, 'registry' as path to items.json sidecar, 'items' as optional subset of item ids, 'base_dir' as artifact root, 'note' as optional description, and 'out' as optional path for writing the baseline. This adds meaning beyond the schema, which only has titles and defaults. The description gives clear semantics for each parameter, so it's strong.

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

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

The description clearly states it creates a labeled, immutable baseline snapshot with version/fingerprint semantics. It distinguishes itself from sibling 'baseline_verify' by explicitly mentioning 'for reproducible rebuilds' and referencing issue #142, C3. The purpose is specific and unambiguous.

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

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

The description implies when to use it (for reproducible rebuilds, pinning artifact bytes) but does not explicitly state when not to use it or compare to alternatives like 'baseline_verify'. It provides context on the registry and fingerprinting but lacks explicit exclusions. Since there is a sibling 'baseline_verify', some guidance would help, but the context is sufficient.

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

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

The description states that the tool 're-resolves every pinned item' and checks 'rev AND content fingerprint', and that it catches drifted inputs 'never silently accepted'. This adds behavioral detail beyond the readOnlyHint annotation, which is appropriate. It does not explicitly say it is read-only, but the annotation already covers that. The description provides useful behavioral context about what comparison is done and the guarantee of not silently accepting drift, which is valuable.

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 appropriately sized; it provides a clear, front-loaded explanation of the tool's purpose, then lists parameters, and finally describes the return value. Each sentence earns its place, including the behavioral guarantee and the default for base_dir. It is well-structured and efficient.

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

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

Despite no output schema and low schema coverage, the description explicitly states the return format ('{ok, label, drifted (item/field/expected/actual), missing}') and its meaning ('ok is True iff the rebuild reproduces the baseline exactly'). The annotations (readOnlyHint=true) cover the safety profile. For a verification tool with this complexity, the description is complete enough for an agent to call it correctly.

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

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

The input schema has 0% description coverage, but the description explains each parameter: 'baseline: path to the baseline sidecar', 'registry: path to the current items.json sidecar', and 'base_dir: artifact root for fingerprinting (defaults to the registry's directory).' This compensates for the lack of schema descriptions, providing meaning for all three parameters including the optional one.

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

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

The description clearly states that the tool verifies a rebuild against a pinned baseline, using a specific verb ('Verify') and resource ('a rebuild against a pinned baseline'). It explicitly distinguishes from other tools by naming it as the 'reproducible-rebuild gate' and describing its specific function of re-resolving pinned items, which is unique among siblings like items_validate or items_resolve.

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

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

The description implies when to use this tool: as the final gate for reproducible rebuilds. It mentions the context of issue #142 and C3, which adds specificity. However, it does not explicitly state when not to use it or name alternative tools for other verification tasks, though the purpose is clear enough that an agent could infer the right usage 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?

ReadOnlyHint covers safety, and the description adds genuinely useful behavior: it is closed-form with no solver, uses theoretical K factors, computes Euler above and Johnson below the transition slenderness, and returns a fidelity/band/valid_range screening package. It discloses the output contract including safety_factor and escalate_to.

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 front-loaded and information-dense, with the key no-solver screening identity first. It is slightly longer than strictly necessary, with details like the transition point equality (σ_y/2) being mathematically interesting but not required for tool selection or invocation.

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

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

Despite 11 parameters and no output schema, the description is complete: it enumerates the return object, covers all parameter groups, states the mathematical model, and names the escalation path. An agent has enough context to call and interpret the result 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?

With 0% schema coverage, the description carries the full burden and does so well: it explains the section alternatives (width+height, diameter, or area+i_min), the material sources (youngs_gpa/yield_mpa or material DB), the end_condition enum values, and load_n's role in computing the safety factor. Every parameter is accounted for in context.

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: an exact column-buckling screen using Euler + Johnson closed-form solutions, explicitly labeled 'NO solver.' It also distinguishes itself from fem_buckling with the beam_modal/fem_modal analogy, so an agent can tell it apart from the FEA 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?

It states the tool is a closed-form screen and explicitly escalates to fem_buckling for non-prismatic/eccentric/built-up cases, giving clear when-to-use vs when-not-to-use guidance. The section/end-condition/material options further define the applicable domain.

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

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

With annotations limited to readOnlyHint and openWorldHint, the description carries the full behavioral disclosure and does it well. It supplies the governing formula, confirms a closed-form no-solver computation, states which dimension the beam bends in, lists supported boundary cases, explains the theoretical limit, and enumerates the exact return keys.

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

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

The description is dense but every sentence earns its place: purpose, formula, geometry, boundary/material inputs, theory validity, and return shape. Significant information is front-loaded, and the formatting with backticks and the formula makes it scannable for an agent.

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

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

For a tool with no output schema and a bare input schema, the description supplies the necessary physics, valid parameter values, boundary condition set, material input paths, and exact output contract. An agent can select, invoke, and interpret beam_modal without further tool definitions.

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

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

The schema has 0% description coverage, so the description must add meaning, and it does: the formula ties length, width, height, Young's modulus, and density together; it explains material selection (youngs_gpa+density_kg_m3 or a Materials-DB material), enumerates boundary values, and describes the results including slenderness. n_modes is only implied via 'up to 5 modes each,' but this is a minor gap in an otherwise complete compensation.

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

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

The description opens with a precise claim: exact Euler-Bernoulli natural frequencies of a uniform rectangular beam, and frames it as a closed-form modal oracle with no solver. It also names fem_modal as the eigen-solve it gates, plus boundary conditions, material modes, and the bending axis, so 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?

It explicitly references the CalculiX fem_modal eigen-solve as the tool this oracle validates against, giving the agent a decision context. It also states the validity boundary (slender-beam theory requires length ≫ height; thick beams need Timoshenko correction), though it stops short of a direct 'use this instead of X when...' routing statement.

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 readOnlyHint=true, but the description goes beyond by detailing the calculation method (ISO 281 formula), the input modes (direct C or catalog lookup), and the output structure (including pass/fail against target_hours). It also discloses the exponent values for ball vs roller, which is behavioral detail not in annotations.

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

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

The description is dense but efficient, fit in two sentences. It front-loads the core formula, then expands on input options and output fields. Every clause adds value, no filler.

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

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

Given the tool's moderate complexity (6 params, no output schema), the description covers the formula, input modes, catalog lookup, and key outputs. It does not detail the full output dictionary (e.g., units of dynamic_load_c_n are implicit as N), but the essentials are covered. The absence of output schema makes it important to mention the return fields, which it does.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the meaning of dynamic_load_c_n, designation, and how they relate (e.g., '6205' -> C=14 kN). It also clarifies equivalent_load_p_n and speed_rpm are required, and kind affects the exponent. This adds substantial meaning beyond the bare parameter names.

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

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

The description clearly states the purpose: compute basic rating life L10 per ISO 281, with formula and parameters. It distinguishes its function from siblings by specifying the output fields and the catalog lookup feature for deep-groove ball bearings. The verb 'calculate' is implicit but the resource (bearing life) and the specific method are explicit.

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

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

The description explains how to supply the dynamic rating C or pull it from the catalog by designation, which is clear usage context. However, it does not explicitly state when to use this tool versus alternatives like 'belt_drive' or 'gear_rating', though the sibling list shows it is one of many mechanical calculation tools. The context is clear, but no exclusion criteria for other tools.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral detail by exposing the mathematical model (Eytelwein equation), the V-belt adjustment, and the pass/fail output. It does not contradict annotations and provides transparency about computational assumptions beyond the schema.

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

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

The description is a single dense block that front-loads the purpose, then provides equations and the return object—no fluff or repetition. Every sentence contributes to understanding the tool's operation.

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

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

Given no output schema, the description properly enumerates all return fields, which is essential. It also covers the core formulas and the V-belt variant, but it omits specifics about the 'pass' criterion and default friction/groove behavior, leaving minor gaps for an 8-parameter analysis 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?

With 0% schema description coverage, the description must compensate, and it does: the equations map parameters to variables (D, d, C, mu, beta, P) and clarify relationships such as tension ratio and belt speed. However, 'tight_side_limit_n' is not explained, leaving a small gap for an otherwise thorough semantic mapping.

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 'Rate a belt drive (Eytelwein/capstan)', clearly identifying the resource and the analysis type. The inclusion of governing equations and the output list further distinguishes it from mechanical siblings like 'chain_drive' or 'gear_rating'.

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 through the belt-drive formulas and return fields, but it does not explicitly state when to choose this tool over alternatives like chain_drive, nor does it mention any exclusions. The context is clear enough for an expert to infer, but it lacks direct 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?

The annotations only indicate read-only and open-world hints, so the description carries the burden of explaining the calculation behavior. It provides the governing formula T=K*F*d, the source of tensile stress area and proof strength, the output fields, and the meaning of preload_target_pct with examples. This is substantial 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 dense but appropriately detailed for an engineering calculation tool, and it fronts the core purpose before input alternatives and outputs. Each clause adds useful information, though it is presented as one long block rather than structured sections.

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

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

The description names the full return set, explains input alternatives, and provides default behavior for preload_target_pct, which is valuable given no output schema. It is weaker in explaining how external_load_n and joint_stiffness_ratio influence the separation and loaded-stress outputs, and it does not define the exact pass criterion.

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

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

With 0% schema description coverage, the description must compensate, and it does explain bolt_size, bolt_dia_mm, pitch_mm, property_class, torque_nm, preload_n, and preload_target_pct. However, several parameters such as external_load_n, joint_stiffness_ratio, material, proof_strength_mpa, and k_factor are not explicitly connected to their roles, leaving meaningful gaps for a 12-parameter tool.

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

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

The description clearly states the tool rates a bolted joint using VDI 2230-lite, with a specific verb and resource. It is unmistakably distinct from sibling engineering checks, though it does not explicitly name or contrast a sibling alternative.

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

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

The description gives clear context for when this tool would apply and explains the alternative input paths: bolt_dia_mm+pitch_mm or bolt_size, and torque_nm or preload_n. It does not explicitly state when not to use it or name alternatives, but the intended usage is well implied.

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

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

The description discloses substantial behavior beyond the readOnlyHint annotation: the exact return schema, the default bare-list format, the dict shape under orderable=True, and the deliberate choice to keep offending rows in the list rather than silently dropping them. It also notes that availability is a curated snapshot, which is a meaningful caveat.

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 long but every section earns its place: the core result, grouping rule, parameter semantics, and optional buyability view are each explained with concrete examples. The structure front-loads the primary behavior and then moves through optional modes in a logical order.

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

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

Given the tool's complexity, the description is complete: it covers all five parameters, the default and alternate return shapes, edge cases like undesignated/not-stocked rows, and the reason for the default bare-list behavior. Since an output schema exists, returning values need not be re-specified, and 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?

Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It covers assembly implicitly, density with explicit units, recursive with both True/False behavior, orderable with the resulting dict structure, and check_stock with a concrete example of what skipping availability means.

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 precise verb and resource: 'Walk an assembly and return [{part, count, total_volume_mm3, total_mass_kg?}, ...]'. It also clarifies a non-obvious grouping rule ('NOT the bare object name') that distinguishes this from a naive object-name aggregation and from sibling tools like list_assembly_parts.

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 contextual guidance for each flag: recursive controls flattening, orderable opts into the buyability dict, and check_stock=False skips availability checks. It does not explicitly name an alternative tool or state when not to use bom_extract, but the behavioral conditions for parameter selection are unambiguous.

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?

Goes well beyond the sparse annotations: explains the conditional `warnings` key, sign convention for removed_volume, None volume_ratio, and the two degenerate-cut cases. Also discloses strict-mode behavior and default warn-don't-fail, so side effects are fully predictable.

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?

Long but tightly organized: purpose, params, return semantics, then edge cases. Every sentence earns its place, and the warnings-key test is stated operationally.

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 supplies return fields and units, conditional keys, and failure semantics. An agent has everything needed to call boolean_op and interpret its result 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 0%, but the description fully compensates: it defines the three valid op values, clarifies base/tool provenance, and explains strict's default and effect. This is more parameter guidance than most schemas 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?

States a specific verb and resource: 'Boolean operation on two existing objects, referenced by their handles.' It enumerates cut/fuse/common, so an agent can distinguish it from other geometry transforms and feature 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?

Describes the operating modes and says base/tool are handles returned from add_primitive, giving clear usage context. It does not explicitly name alternatives or when-not-to-use conditions, so it stops short of 5.

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