kernelcad

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

Description states 'side-effect-free', matching the destructiveHint=false annotation. Also explains the return value (modified source + diagnostics), adding useful 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?

Two concise sentences plus a code snippet. Purpose is front-loaded, and every element is useful with no wasted words.

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

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

Given the output schema exists (not shown, but indicated), the description adequately covers the return value. The tool's complexity is moderate, and the description provides sufficient context for an agent.

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 high (86%), so baseline is 3. The description provides a code snippet showing parameter usage, but does not add detailed semantics beyond what the schema already describes.

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 adds a mate connector to a part, with a specific code insertion example. This distinguishes it from siblings like add_constraint or add_feature.

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

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

Provides clear context for when to use this tool (adding a mate connector to a part) and mentions side-effect-free. However, no explicit comparison or when-not-to-use guidance is given.

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

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

Description explicitly states 'Side-effect-free' which aligns with destructiveHint=false. It explains the tool returns the updated list, indicating no mutation of inputs. This adds valuable 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?

Two sentences, no redundant words. Front-loaded with purpose. Every sentence contributes necessary information.

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

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

Given the tool has 2 parameters, nested objects, and output schema, the description covers purpose, usage pattern, and side-effect-free behavior. It does not detail output format, but output schema exists. Minor gap: could mention the output is a new list.

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

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

Schema coverage is 100%. Description adds meaning by explaining the role of each parameter: 'constraints' as existing list (omit for empty), 'constraint' as the one to append. Also mentions 'validated' which hints at input validation.

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

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

The description clearly states the verb 'add' and resource 'sketch constraint to a list'. It distinguishes from siblings by specifying the domain (sketch constraint) and the action (appending to a list).

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

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

The description gives explicit context: 'Use this when you need to add a sketch constraint to a list.' It also provides usage pattern: 'pass { constraints, constraint } and receive the updated list.' It does not mention when not to use or alternatives, but 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?

The description discloses the insertion location, return format (modified code + diagnostics), validation behavior ('fails closed'), and claims 'side-effect-free'. Annotations provide readOnlyHint=false and destructiveHint=false, so the description adds valuable behavioral context beyond those.

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 bullet points and front-loads the primary use case. It is comprehensive but not verbose; all sentences add value. Minor length could be trimmed, but it remains effective.

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 (10 params, two kinds, nested objects) and minimal annotations, the description covers the two paths, required params, return type, and consumption. It lacks explicit error details but mentions 'fails closed'. The output schema exists, so return values need not be explained.

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

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

Schema coverage is 100%, and the description enriches parameter meanings by explaining kind-specific details (e.g., defaults, structure of Hermite endpoints, that controlPoints are in mm). This goes beyond the basic schema descriptions.

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

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

The description specifies a clear action (authoring a 3D Curve3D) and resource (user's .kcad.ts file) with precise placement. It distinguishes the two kinds (nurbs and hermite) and differentiates from siblings by naming consumption tools like add_variable_sweep and add_surface.

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

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

The description begins with 'Use this when you need to author a 3D Curve3D', providing explicit context for when to use the tool. It explains how to consume the result with other tools but does not state when not to use it or explicitly name alternatives, though the function is specific enough.

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

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

The description adds behavioral details beyond annotations: insertion location, return of modified code plus diagnostics, and side-effect-free claim. Annotations indicate not read-only and not destructive, which aligns with the description's side-effect-free assertion (no permanent state change).

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

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

The description is three sentences, with a clear front-loaded usage statement. The third sentence about faceLabels and lookup_api is relevant but somewhat tangential; it could be separated. Overall, it is concise and well-structured.

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

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

Given the presence of an output schema and annotations, the description covers key aspects: insertion logic, return value, side-effect-free nature, and an advanced tip. It could mention edge cases (e.g., no return statement) but is sufficient for typical usage.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds an example for feature_code, clarifying the expected format and syntax beyond the schema's 'Single-statement source line to insert'. This provides practical guidance.

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

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

The description clearly states the verb 'insert' and the resource 'new feature line into a script', with precise location 'before the last top-level return statement'. This distinguishes it from sibling tools like add_constraint or add_part, which add different script elements.

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 begins with 'Use this when you need to insert a new feature line into a script', providing a clear use case. It also mentions side-effect-free behavior and a tip about faceLabels, but does not explicitly exclude when not to use it or compare to alternatives like add_connector.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the tool is not read-only and not destructive. The description adds that it 'durably edit source' and requires code and assembly_binding, plus states that each relation 'fails closed on its own missing required params', providing useful behavioral insight beyond annotations.

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

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

The description is concise (about 10 lines) with a clear front-loaded purpose statement and bullet-pointed breakdown of the three relation types. Every sentence adds value without redundancy. It is well-structured for quick comprehension.

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 (three distinct operations with many parameters), the description sufficiently covers all key aspects: the three relation types, their parameter shapes, common required params, and error behavior. An output schema exists so return values need not be described. The description stands alone as a complete guide for an AI agent.

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

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

Schema coverage is 100%, so baseline is 3. The description groups parameters by relation type (e.g., 'mate' expects { name, a, b, type, pose?, ... }), which adds structural meaning not explicit in the schema's conditional required blocks. It also explains that non-relation parameters are 'forwarded verbatim', clarifying how to use them.

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

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

The description clearly states the tool's purpose: 'author a mate-graph relationship into the source'. It breaks down into three specific relation types (mate, coupling, transmission) with distinct parameter sets. This distinctively distinguishes it from sibling tools like add_constraint or add_connector.

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 opens with 'Use this when you need to author a mate-graph relationship', providing clear usage context. It mentions required parameters (code, assembly_binding) and the default relation. However, it does not explicitly compare to alternatives or state when not to use the 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?

Describes the side-effect-free nature ('caller persists the returned source') and explains that it returns modified source plus diagnostics. This goes beyond the annotations (destructiveHint=false, readOnlyHint=false) by clarifying the exact behavioral impact.

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

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

Three concise sentences: first states purpose, second explains the exact insertion, third clarifies side-effect-free. Every sentence earns its place with no redundant information.

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

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

Given the complexity (6 parameters, all documented in schema) and the existence of an output schema, the description fully covers what the tool does and its constraints. The return behavior (modified source + diagnostics) is clearly stated.

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

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

All 6 parameters have descriptions in the schema (100% coverage). The description does not add further meaning to individual parameters beyond what the schema provides, so baseline of 3 is appropriate.

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

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

Clearly states the verb 'add' and resource 'part to an assembly'. Describes the specific action of durably inserting a code line before the final return, distinguishing it from other add_* sibling tools.

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

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

Explicitly says 'Use this when you need to add a part to an assembly', providing clear context. Does not mention when not to use or alternatives, but the sibling tools are numerous and distinct.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false). The description adds significant value by stating it is 'Side-effect-free', 'fails closed on missing params', and returns modified code with diagnostics. It does not detail idempotency or concurrency, but the added context is strong.

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

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

The description is well-structured and front-loaded, but somewhat lengthy due to detailed kind breakdowns. It could be slightly more concise, but each sentence earns its place by providing necessary constraints and examples.

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

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

Given the complexity (3 kinds, 14 params, nested objects, output schema), the description is comprehensive: explains insertion point, pen position constraints, return value, and kind-specific details. The existence of an output schema reduces need to describe return format.

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

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

Schema coverage is 100%, but the description adds substantial meaning beyond schema: for spline, it explains interpolation, tangent normalization; for nurbs, the B-spline net; for hermite, tangent magnitude meaning. These enrich parameter understanding without redundancy.

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 appends a curved segment to an existing PathBuilder chain, specifies the three kinds (spline, nurbs, hermite) with code examples and constraints, and distinguishes itself from sibling tools like add_curve by focusing on path segment appending.

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

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

The description explicitly says 'Use this when you need to append a curved segment to an existing PathBuilder chain' and provides guidance on when to use each kind (e.g., 'Use for organic 2D outlines'). However, it lacks explicit when-not-to-use or comparison with sibling tools like add_curve, limiting differentiation.

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?

Discloses side-effect-free nature, return value (modified code + diagnostics), pattern implementation as cumulative boolean union, and face ref naming convention. Annotations are consistent (readOnlyHint false, destructiveHint false).

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

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

The description is a single well-structured paragraph, front-loading the core purpose, then covering insertion behavior, returns, side-effects, and geometric notes. Slightly verbose but each sentence adds value.

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

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

Given the tool's complexity (7 params, nested objects, output schema exists), the description covers return value, side-effect-free nature, pattern unit concept, geometric implications, and face ref naming. It is complete for correct agent usage.

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

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

Schema coverage is 86%, so the schema already documents most parameters. The description adds value by explaining the role of 'target', 'assign_to', and the return value, but does not re-iterate all schema details.

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

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

The description clearly states it repeats a feature in a pattern by inserting a pattern call into a script. It distinguishes from siblings like add_feature (general feature addition) and flatten_pattern (different 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?

Explicitly says 'Use this when you need to repeat a feature in a pattern' and provides context on when each pattern kind is appropriate via the schema. Also gives guidance on additive vs subtractive features.

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 (readOnlyHint=false, destructiveHint=false) indicate mutation without destruction. Description adds crucial details: slice-1 limitation (weights ignored), surfaces are non-rational, no Shape until chaining .thicken() or .toShape(), returns code + diagnostics, and each kind fails closed on missing params. This far exceeds annotation coverage.

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

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

The description is well-organized with a clear lead sentence and separate paragraphs for each kind. It is fairly long but each sentence adds information. Slightly verbose but not redundant; earns its length.

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

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

Given 12 parameters, two modes, nested objects, and an output schema, the description covers prerequisites, limitations, behavioral nuances, and post-creation steps. It mentions the need for declared curve_bindings and the chaining with add_feature, leaving no major 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 coverage is 100% with each parameter described. Description adds significant value by grouping parameters by kind, explaining defaults (knots, sampling, continuity), constraints (adjacent endpoints must coincide within 1e-6 mm), and side effects (ignored weights). It also clarifies the control-point grid shape and curve_bindings order.

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

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

Description clearly states the tool authors NURBS surfaces with two distinct paths selected by 'kind'. It specifies the exact function calls generated (nurbsSurface, surfaceFromCurves, surfaceFromBoundary) and differentiates from sibling tools like add_curve or add_feature by focusing on surface 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?

Description opens with 'Use this when you need to author a NURBS Surface' providing clear context. It explains each kind's sub-usage but does not explicitly list when not to use or alternative tools, though the specificity implies limited applicability.

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, meaning the tool modifies code but is not destructive. The description adds context about the default font, side-effect-free behavior, and return of modified code plus diagnostics, which enhances transparency beyond annotations.

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

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

The description is concise and well-structured, starting with a clear purpose then detailing modes. It avoids fluff but could be slightly more compact.

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 (17 parameters, 2 modes, output schema exists), the description covers the main behaviors and parameter groups. However, it lacks explicit guidance on parameter dependencies or mutual exclusivity, which would improve completeness.

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

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

Schema description coverage is 100% with clear descriptions for each parameter. The tool description adds narrative grouping by mode and clarifies defaults, but this adds limited value beyond the schema's already-detailed parameter descriptions.

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

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

The description clearly states the tool is for authoring text into a kernelCAD script, and distinguishes between two modes (sketch and emboss) with specific actions for each. This provides a clear verb+resource purpose and differentiates from sibling tools.

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

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

The description explicitly explains when to use each mode (e.g., 'sketch' for chainable text, 'emboss' for engraved/raised features) and mentions failure modes. However, it does not provide explicit guidance on when not to use the tool or compare 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?

The description discloses behavioral traits beyond annotations: it states 'Side-effect-free', explains validation via regex ('fast structured error vs capture-time stack'), and notes that orientation is not exposed. This adds value beyond the annotations (`readOnlyHint: false`, `destructiveHint: false`), and there is no contradiction.

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

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

The description is fairly concise and front-loaded with the use case. It includes relevant technical details without excessive verbiage. Minor jargon could be reduced, but overall it is well-structured.

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

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

Given the complexity (6 parameters, output schema exists), the description is complete. It covers the return type (modified code + diagnostics), validation, binding references, constraints on sections, and the limitation about orientation. The output schema is mentioned implicitly by describing the result as a `Shape`.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining that `spine_binding` references an existing variable, `sections` must be strictly increasing in `t` and span [0,1], and that the result is a `Shape` for chaining. These details enhance understanding beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: authoring a variable-section sweep along a spine. It specifies the action (insert a `variableSweep` declaration), the resource (`.kcad.ts` file), and the result (a `Shape`). The mention of chaining with `add_feature` differentiates it from sibling tools that handle other operations.

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

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

The description explicitly says 'Use this when you need to author a variable-section sweep along a spine' and provides context like inserting before the last top-level return. While it doesn't explicitly state when not to use, the context is clear. No direct alternatives are named, but the specificity implies this is for sweeps only.

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

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

The description discloses that the tool 'Durably insert[s]' code, indicating a permanent modification, and returns 'modified source plus diagnostics.' This adds context beyond the annotations (which only indicate not read-only and not destructive). The description does not contradict annotations.

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

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

The description is two sentences, front-loaded with the usage directive, and every sentence adds value. It is concise and well-structured with no wasted words.

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

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

Given the tool has an output schema and is moderately complex (5 params), the description fully covers the purpose, usage, return value (modified source plus diagnostics), and behavioral context (checked by validation gates). It is complete for an AI agent to understand how to use the tool.

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

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

The input schema has 100% coverage with descriptions for all 5 parameters. The tool description does not add any additional explanation beyond what the schema already provides. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description explicitly states the tool's purpose: 'declare a reachability target for a connector.' It specifies the action (insert a workspace target) and the resource (connector). This clearly distinguishes it from sibling tools like 'add_constraint' or 'add_connector'.

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 starts with 'Use this when you need to...', providing clear context for when to use the tool. It explains that workspace targets are checked by validation gates. However, it does not explicitly state when not to use it or mention alternatives, slightly reducing the guidance.

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

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

Annotations provide limited info (readOnly=false, destructive=false). Description adds extensive behavior: collision verification, non-blocking collision handling (artifact still written), environment prereq, and return structure. Contradicts none.

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?

Description is long but each sentence adds value. Front-loaded with purpose. Some redundancy (environment requirement repeated) but overall efficient for the complexity.

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

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

Covers all aspects: purpose, parameters, environment, return format, behavioral nuances. With output schema present, description still adds return structure details. Complete for an 8-parameter tool.

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

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

Schema coverage is 100%, but description adds significant context: file parameter emphasizes no code mode, focus/hide explains mutual exclusivity and render-only semantics, frames_dir/output_path mutual exclusivity, verify_every union with keyframe sample set. Greatly enhances understanding.

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

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

The description clearly states 'Use this when you need to render a script's animation timeline to a video.' It specifies capture of animationView({...}) to MP4 or PNG frames, with a clear verb-resource relationship. It distinguishes from sibling tools like render_preview by focusing on animation 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?

Provides explicit usage context: 'FILE ONLY: pass { file }' and 'no { code } mode.' Explains mutually exclusive options and environment requirements. Does not explicitly mention when not to use or alternatives, but the context is sufficiently clear.

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

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

Annotations already indicate readOnlyHint=false, openWorldHint=false, destructiveHint=false. The description adds behavioral context: it iterates over attempts, uses review_cad, can write build records, and returns structured repair prompts. This complements the annotations effectively.

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 four concise sentences front-loaded with when to use. Every sentence adds value, and there is no redundancy or filler.

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

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

Given the high number of parameters (16) and nested objects, the description provides a good high-level process. The schema covers most parameters and the output schema exists, so the description does not need to detail return values. Slightly more detail on the loop termination condition would enhance completeness.

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

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

The schema covers 94% of parameters with descriptions, so the baseline is 3. The tool description does not add further meaning beyond what the schema provides, so no extra credit.

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

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

The description clearly states the tool's action: 'run a CAD design loop over multiple attempts.' It specifies the process (review, continue, return repair prompts, optionally write build record) and distinguishes it from sibling tools like review_cad and individual add_* tools by its loop/orchestration nature.

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 opens with 'Use this when you need to run a CAD design loop over multiple attempts,' providing clear context. However, it does not explicitly state when not to use it or suggest alternatives, which would improve guidance.

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

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

The description details the output format comprehensively (per-part changes, interference delta, mate-graph changes, param changes) and explicitly confirms it is read-only, aligning with annotations readOnlyHint=true and destructiveHint=false. It also addresses an edge case (single-shape scripts). This adds significant value 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 concise and well-structured. It starts with the usage context, then explains the output in detail, and ends with usage guidance and safety confirmation. Every sentence provides useful information without 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?

Given the tool's complexity (multiple output components, 4 parameters), the description covers all essential aspects: usage timing, input pairing, output details, read-only nature, and edge cases. The presence of an output schema reduces the burden, but the description still provides a clear summary.

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 100% coverage with parameter descriptions. The description adds value by explaining the relationship between parameters: 'a baseline ({ baseFile } or { baseCode }) and a revision ({ file } or { code }).' This clarifies how to pair the parameters, which is not evident from the schema alone.

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

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

The description clearly states the tool's purpose: 'see exactly what changed between two script versions.' It uses a specific verb ('diff') and resource ('script versions'), distinguishing it from sibling tools which are for building or querying CAD models, not comparing versions.

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 usage guidance: 'Use after editing a script to verify exactly what changed physically before re-rendering.' It also states the tool is read-only and never touches the active session. However, it does not explicitly mention when not to use it or suggest alternative tools, but the context is sufficient given the tool's specificity.

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?

Description indicates full run modifies the active session ('finish with a full evaluate_script before using session-dependent tools'), but annotations declare readOnlyHint=true, implying no side effects. This is a contradiction, so score 1 per instructions.

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?

Well-structured: purpose first, then outputs, then parameter usage, then dryRun details. Slightly verbose but front-loaded with essential information. Every sentence adds value.

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

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

Covers purpose, inputs, outputs, and special behavior (dryRun). Output schema exists, so return values need not be described. Despite the annotation contradiction, the description itself is complete for agent usage.

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

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

Schema coverage is 100%, baseline 3. Description adds value by explaining the mutual exclusivity of 'file' and 'code', and the purpose of 'dryRun' beyond the schema description. It clarifies usage context for each 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 starts with 'run a script and check it compiles' and details specific outcomes: pass/fail, feature count, diagnostics, and optional parts summary. This clearly distinguishes it from sibling tools like verify or why_did_this_fail.

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?

States when to use: 'Use this when you need to run a script and check it compiles.' Also explains dryRun for fast validation and when to use full run ('finish with a full evaluate_script before using session-dependent tools'). Does not explicitly mention alternatives, but 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 declare readOnlyHint=true, meaning no destructive behavior. The description adds details about the return format and the meaning of distance values, which goes beyond annotations. No contradiction detected.

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 well-structured sentences, each earning its place. The first sentence is a clear purpose statement, the second explains output, the third gives usage hints. Slightly verbose but remains 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?

Given the presence of an output schema and 100% parameter coverage, the description provides sufficient context: input relationships, output structure, usage hints, and a comparison to a sibling. Minor missing details about error conditions are acceptable.

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

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

Schema coverage is 100%, so parameters are documented. The description adds value by hinting that file and code are mutually exclusive ('either...or') and explaining that fieldName refers to an sdf.bind binding. This clarifies usage beyond the schema.

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

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

The description clearly states the tool samples a signed-distance field at a point, specifies the return object, and distinguishes it from the expensive sdf.materialize sibling. The verb 'sample' and resource 'signed-distance field' are specific.

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

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

The description explicitly says when to use it (to verify SDF composition before materialization) and mentions the prerequisite of binding the SDF field. It does not list alternative tools among siblings but provides enough context to avoid misuse.

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 annotations. It discloses default watertight verification, error return patterns (export.mesh.not-watertight, export.part.not-found), and file writing behavior (still written on verification failure). It also explains side effects like writing mesh files for URDF/SDF targets. 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 detailed but well-structured with clear bullet points for each target and sub-points for formats. It is front-loaded with the main purpose. While long, the complexity of the tool (10 parameters, nested options) justifies the length. Minor denseness prevents 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?

Given the tool's complexity (10 params, nested options, output schema), the description covers all necessary aspects: purpose, usage, parameter semantics, behavioral traits, error conditions, and side effects. It is complete for an AI agent to select and 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?

With 100% schema coverage, the description still adds significant meaning: it explains conditional parameter requirements based on 'target', describes the per-format options bag in detail, and clarifies the role of 'no_verify'. This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: export geometry to a file. It distinguishes two targets ('model' and 'part') with distinct behaviors, providing a specific verb+resource combination. No sibling tool overlaps with this export functionality, making it easy to select.

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

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

The description explicitly says 'Use this when you need to export geometry to a file' and provides detailed guidance on when to use each target ('model' vs 'part'). It also explains optional parameters, per-format options, and error conditions, giving clear context for invocation.

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, openWorldHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: bundled ids resolve offline, non-bundled ids require partsBaseUrl, and the return value includes cache path and sha256 fingerprint. This explains the caching mechanism and external dependency, which annotations alone do not capture.

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 (four sentences) and front-loaded with the primary use case. Every sentence adds value: when to use, resolution logic, offline vs online behavior, and return format. No redundant or wasteful text.

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

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

The description provides enough information to use the tool for its main purpose, covering id/query resolution, bundled vs non-bundled, and return values. However, it leaves gaps: the roles of 'family', 'category', and 'standard' are unexplained, and it does not clarify whether id and query can both be provided or their interaction. Given the low schema coverage and 6 parameters, the description is adequate but not fully complete.

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

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

Schema description coverage is only 17% (only partsBaseUrl has a description). The description explains the roles of 'id' and 'query' (resolve an id or single-match query), but does not address 'family', 'category', or 'standard' parameters. These remain ambiguous—whether they are part of the query or separate filters is unclear. With low coverage, the description should have compensated by detailing all parameters, but it only covers two out of six.

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

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

The description clearly states the tool's purpose: to download a catalog part as a STEP file. It specifies the action (download/fetch) and the resource (catalog part STEP file), and distinguishes from siblings like find_part (search) and add_part (adding parts) by focusing on file download. The verb 'fetch' combined with 'download a catalog part as a STEP file' 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 provides clear context on when to use the tool: 'Use this when you need to download a catalog part as a STEP file.' It also explains the resolution mechanism (id vs single-match query) and the difference between bundled and non-bundled ids with partsBaseUrl. However, it does not explicitly exclude alternative tools (e.g., find_part for searching or add_part for placement) or provide when-not-to-use guidance, which would improve clarity.

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=true and destructiveHint=false, and the description does not contradict these. It adds behavioral details like token AND-combination and cross-facet filtering, exceeding annotation coverage.

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

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

The description is concise, with three sentences that front-load purpose, then explain filtering logic, then remote tier setup. No wasted words.

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

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

Given the presence of an output schema, the description covers the main functionality: search, filtering, and remote option. It is fairly complete for a search tool, though more detail on each filter parameter would improve completeness.

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

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

With only 13% schema description coverage, the description partially compensates by mentioning 'fuzzy query' (query), 'faceted filters' (category, family, etc.), and 'source' enum. However, parameters like 'tag' and 'standard' are not explained, leaving 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 clearly states the tool finds a part in the catalog using fuzzy query and faceted filters. It specifies the verb 'find' and resource 'part in catalog', and distinguishes from siblings like 'fetch_part' by describing the search functionality.

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

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

The description explicitly says 'Use this when you need to find a part in the catalog' and explains search behavior (AND-combine) and remote tier option. However, it does not specify when not to use it or mention alternatives like 'fetch_part'.

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 reinforces the read-only nature (consistent with readOnlyHint annotation) by describing the output as an unfolded pattern. It adds behavioral details such as the output format and bend limit. 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 concise at two sentences, front-loading the use case. The phrase 'Slice 1: at most 2 bends' is slightly unclear and could be reworded for better clarity. Overall, it is efficient but has a minor clarity issue.

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

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

The description covers the core functionality and output, but it does not explain the term 'Slice 1', nor does it address edge cases like more than 2 bends or error scenarios. No information on prerequisites or permissions is provided. The presence of an output schema reduces the need for output details, but the description could be more 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 that 'file' and 'code' are alternative input methods, and 'featureId' is optional to select a specific shape. However, it does not describe the expected formats of 'file' or 'code', nor does it clarify that all parameters are optional. This leaves some ambiguity.

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

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

The description clearly states the tool's purpose: to obtain the unfolded flat pattern of a bent sheet-metal part. It specifies the output format (Region with polylines, holes, bend lines, sketch plane) and a constraint (at most 2 bends). This distinguishes it from sibling tools that focus on adding features or constraints.

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 tells when to use the tool ('when you need the unfolded flat pattern') and how to specify input (using 'file' or 'code', with optional 'featureId'). It implies a limitation to sheet-metal parts with up to 2 bends. However, it does not explicitly mention when not to use it or recommend alternatives from the sibling tool 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 far beyond the readOnlyHint annotation by detailing key behaviors: server-side rendering independent of user's Studio camera, deterministic output (same model + view = same bytes), always current and not stale, error handling (returns error object, never blank image), and color/shading consistency. It explicitly addresses potential misconceptions about staleness and blank captures.

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 well-structured with clear sections (CRITICAL, DEFAULT, DETERMINISTIC). Each sentence conveys important information without redundancy. However, some details (e.g., 'slug is the capability') could be more concise without losing clarity. Overall, effective use of space.

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

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

Given the tool's complexity (3 parameters, output schema, annotations), the description is exceptionally complete. It covers purpose, usage pattern, behavioral details, error handling, and parameter semantics. The presence of an output schema means return values don't need explanation, and the description touches on error states. No gaps evident.

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?

Although the schema covers all parameters with descriptions, the tool description adds critical context: the default 'all' view returns a labeled contact sheet with specified layout (3x2 grid), the deterministic behavior ties slug and view, and paths_only is explained in terms of use cases (sandboxed agents). This adds value beyond the schema definitions.

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

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

The description clearly states the tool's purpose: 'Render a project's current model server-side and return it as an inline image'. It explicitly distinguishes from asking users to change their camera view, which is a common confusion. The verb 'render' and resource 'project's model' are specific, and the mention of inline image differentiates from potential sibling tools like 'render_preview'.

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

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

The description provides explicit usage guidance: 'Use this after open_in_studio (or any /p/<slug> link)'. It tells what NOT to do: 'NEVER ask the user to rotate, zoom, pan... you cannot affect their screen'. It also instructs to re-render after pushing changes and to call with different view for different angles. Alternatives like paths_only are explained.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds beyond by specifying exact return content (positions, indices, normals) and delivery mechanism (MCP Apps bridge). No contradictions.

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

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

Two sentences cover purpose, usage context, and auth. Front-loaded with the core action, zero wasted words.

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

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

Given the tool has a single parameter, annotations, and an output schema (not shown), the description fully covers purpose, usage context, auth requirements, and data type. No gaps identified.

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

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

Schema coverage is 100% with a clear description for 'slug'. Description adds context about slug's role in capability/authorization, which is valuable beyond the schema field description.

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

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

The description uses a specific verb ('Return') and resource ('per-feature triangle mesh') and clearly differentiates from siblings like 'mesh_summary' or 'get_latest_render' by specifying raw mesh data (positions/indices/normals).

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

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

Explicitly states the tool is 'for the in-chat 3D viewer widget' and explains auth requirements based on slug visibility. Could be improved by stating when not to use (e.g., if only summary needed, use mesh_summary).

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 value beyond annotations by detailing that it fetches the full .kcad source and metadata, that updating the same slug live updates the user's open tab, and that private projects require OAuth. Annotations already declare readOnlyHint and destructiveHint, so the description complements them without contradiction.

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

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

The description is four sentences long, each providing unique information. It could be slightly more concise, but it is well-structured and front-loaded with the main purpose.

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

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

Given the tool's dual mode (fetch vs list) and dependencies (OAuth, output structure), the description covers essential context. The presence of an output schema reduces the need to describe return values, so the description is adequately complete.

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

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

With 100% schema description coverage, the baseline is 3. The description adds context about the slug's origin (from a listing or /p/<slug> link) and the behavior when omitted, which is helpful but not extensive.

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 fetches a specific project or lists saved projects, distinguishing between the two modes based on the slug parameter. It directly addresses the verb 'get' and the resource 'project', and provides specific use cases like reopening a saved project or browsing.

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 the tool (to reopen a saved project or browse saved projects) and provides context about OAuth requirements for private projects and listing mode. While it doesn't explicitly mention when not to use it or list alternatives, it gives clear guidance on usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by explaining that the source is immutable and that for private projects the owner's OAuth is required. It does not contradict annotations and adds practical context about capability-based access.

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 consists of three concise sentences, each adding essential information: definition, use case, and access details. No extraneous words; well-structured and front-loaded with the core purpose.

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

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

Given the 47 sibling tools (many mutations), the description fully covers when and how to use this read-only fetch tool. With an output schema present, return values need no further explanation. The description covers usage, access, and verification purpose completely.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by specifying that slug and version come from open_in_studio and that slug acts as a capability for public projects, exceeding what the schema alone provides.

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

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

The description clearly states the verb ('Fetch'), resource ('exact immutable .kcad source and parameters'), and context ('captured at a prior `open_in_studio` version'). It distinguishes this tool from siblings by focusing on read-after-write verification of a specific revision.

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

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

The description provides explicit usage guidance: 'Use this to read-after-write verify a release' and details how to pass slug and version. It also explains access requirements for public vs private projects, covering when and for whom the tool is appropriate.

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, destructiveHint=false. Description adds that parameters are subject-specific and forwarded verbatim, providing useful 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?

Bulleted list of subjects after a concise purpose statement. Each sentence earns its place; no wasted words despite length.

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

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

Given the tool's complexity (8 params, many subjects, output schema exists), the description covers all necessary information: subjects, parameter semantics, and usage context. No 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 coverage is 100%, baseline 3. Description explains `of` enum values in detail and adds that other params are subject-specific, but does not add significant new meaning beyond the schema.

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

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

Starts with 'Use this when you need to read facts about a model,' clearly stating verb+resource. The broad list of subjects distinguishes it from sibling tools that add/modify/query.

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

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

Explicitly states when to use (reading facts) and briefly explains parameter behavior ('All params except `of` are subject-specific'). Does not name alternatives but 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 already declare readOnlyHint=true and destructiveHint=false, so the description's contribution is limited to clarifying the scope of listing. No additional behavioral traits beyond expected read-only operation. No contradiction.

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

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

Two sentences, front-loaded with purpose. Every sentence adds value without unnecessary detail. Highly efficient.

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

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

For a zero-parameter listing tool with an output schema, the description fully covers purpose, scope, and usage. No 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?

No parameters (schema coverage 100% trivially). Description adds value by explaining what the tool returns, which is essential for an agent to understand the output. Baseline 4 is appropriate.

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

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

Description specifies verb 'list' and resource 'kernelCAD script-runtime surface' with detailed examples of included items (global functions, Shape methods, etc.). Clearly distinguishes from siblings like lookup_cookbook.

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?

Starts with 'Use this when you need to list...' providing explicit usage context. Mentions discovering what is callable from a .kcad.ts script. Does not explicitly state when not to use but given specificity it's clear. Lacks direct alternative references but siblings provide implicit differentiation.

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 and destructiveHint. Description adds the output format (uri, mimeType, text) and confirms no input needed, providing useful context 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?

Two sentences: first states purpose concisely, second gives usage guidance. No redundancy, front-loaded with core functionality.

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

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

For a zero-parameter tool with safety annotations and output schema partially described, the description covers purpose, usage, and output format. Complete without 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?

No parameters exist, so baseline is 4. Description explicitly states 'INPUT: none', which reaffirms the schema. No further param explanation needed.

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

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

The description clearly states the tool returns the SKILL.md body for kernelcad-authoring conventions, specifying verb, resource, and content. It distinguishes from siblings like lookup_api and lookup_cookbook which are about different domains.

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

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

Provides explicit guidance: use this tool if the MCP client does not list resources, otherwise read the resource directly. Clearly states an alternative approach.

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 ranking method (BM25 over title/tags/keywords/trigger) and the empty result behavior, which go beyond the annotations (readOnlyHint, openWorldHint, destructiveHint). There is 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 concise, with a front-loaded purpose statement, and every sentence adds value. It includes examples and edge-case behavior without unnecessary detail.

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

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

The description is complete for a simple lookup tool: it explains the search mechanism, result handling, and use cases. With an output schema present, return value details are unnecessary.

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 covers 100% of parameters with descriptions. The tool description does not add significant new semantic meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool looks up canonical pattern snippets for CAD tasks, using a specific resource (kernelCAD cookbook). It distinguishes effectively from siblings like lookup_api and lookup_authoring_skill, which serve different purposes.

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

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

The description explicitly states when to use this tool ('when you need a canonical pattern snippet') and provides examples and behavior if no results are found ('proceed without cookbook help'). However, it does not explicitly mention when not to use it or suggest alternative 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 destructiveHint=false. The description adds that it is a 'tiny one-shot call' and that hints are also inline on every emitted diagnostic, providing additional behavioral context beyond annotations. No contradictions.

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

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

The description is three sentences, front-loaded with the primary use case, and every sentence adds value without redundancy. It is concise and well-structured.

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

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

Given the tool has no parameters, clear annotations, and an output schema, the description sufficiently explains the tool's purpose and usage context. It does not need to describe return values due to the output schema.

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

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

The tool has zero parameters, so schema coverage is 100%. According to the guidelines, 0 parameters yields a baseline of 4. The description does not add parameter info because none exist, which is appropriate.

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

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

The description clearly states the tool provides the 'kernelCAD 26-code diagnostic catalogue with hint templates', using a specific verb 'look up' (implied) and resource 'diagnostic catalogue'. It distinguishes itself from siblings by focusing on the canonical list upfront, which is not offered by other tools.

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

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

The description explicitly says 'Use this when you need the kernelCAD 26-code diagnostic catalogue' and mentions its utility for pre-populating retry strategies. While it does not list alternative tools or when not to use it, the context is clear enough for an agent.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds value by disclosing that it runs the full OCCT pipeline (same as Studio renderer), evaluates modern sources, and never returns raw arrays. It also explains the output structure including failedFeatureIds. No contradictions.

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 clear sections for action, use cases, input, and output. It is front-loaded with the core purpose. While slightly long, every sentence adds value and there is no redundancy.

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

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

Given the presence of an output schema (referenced but not shown), the description adequately explains the output fields (ok, bounds, features, failedFeatureIds) and what is not returned. It also distinguishes the tool from siblings. It provides sufficient context for an agent to decide when to use this tool.

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

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

Schema coverage is 100% with detailed descriptions for all three parameters. The description adds context beyond the schema, such as 'stateless slider recompute' for params and clarifying that fileName is for diagnostics only. This enhances understanding of parameter semantics.

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

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

The description clearly states the tool meshes a .kcad.ts source and returns a compact geometry summary, listing specific use cases. It distinguishes from sibling tools by explicitly noting that raw vertex data is never returned and directing users to open_in_studio + get_latest_render for rendered views.

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

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

The description provides explicit guidance on when to use the tool (inspect geometry without viewer, verify shape/size, triangle counts) and when not to (to see rendered model). It also mentions that it handles modern sources that the legacy worker cannot, giving context on its suitability.

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?

Discloses key behaviors: persists the model, returns a slug for live updates, optional code reuse from evaluate_script. Annotations indicate a write operation (readOnlyHint false) and non-destructive (destructiveHint false); description adds the reuse and live-update details without contradiction. Complete transparency.

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

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

Thorough but well-structured. The most important usage guidance is front-loaded, followed by parameter details. Slightly longer than necessary but every sentence contributes to correct usage. Could be trimmed by merging redundant phrases.

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

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

Given the complexity of conditional slug usage and code reuse, the description covers all operational scenarios. The existence of an output schema likely provides return value details. The live-update behavior with slug is fully explained, making the tool self-contained for an agent.

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

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

Schema coverage is 100% with descriptions for each parameter. Description adds crucial context: code is optional and reuses last evaluated source, slug determines update vs. new project. This exceeds schema-only information, though for trivial parameters like title the description adds little.

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 persists a kernelCAD model and returns a link for viewing/sharing. It specifies the context ('when the user wants to SEE or share the model') and distinguishes it implicitly from siblings by focusing on a unique outcome. Could be improved by explicitly contrasting with similar tools like evaluate_script that don't persist.

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

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

Provides explicit trigger phrases and specific situations to use (after finishing a build, after each meaningful revision). Offers conditional guidance on passing slug for updates vs. omitting for new projects. Does not explicitly state when not to use or list alternatives, but the guidance is substantial 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 discloses key behaviors beyond annotations: 'Side-effect-free; returns modified code plus diagnostics', and explains the deferred asEdge feature due to 'BRepProj_Projection not bundled'. This adds context that 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 reasonably concise with three sentences covering purpose, usage pattern, and side-effects. It could be more structured but is efficient and front-loaded with 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?

Given the tool's complexity (7 parameters, 4 required) and existence of output schema, the description covers the main usage, behavioral traits, and a key limitation. It is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

While schema coverage is 100%, the description adds context for curveExpression ('Inserted verbatim as the curve: field'), asEdge ('captured but currently deferred'), and scaleMode ('scaling mode'). It does not detail every parameter but augments meaning beyond raw schema.

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

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

The description clearly states the tool's purpose: 'wrap a 2D curve onto a 3D face'. It provides a specific verb ('projectCurve') and resource ('Shape'), and distinguishes from siblings like add_curve by specifying the projection onto a face.

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

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

The description explicitly says 'Use this when you need to wrap a 2D curve onto a 3D face' and suggests pairing with .extrude(d)/.cut(...) for engraved logos. It does not explicitly state when not to use it or mention alternative tools, but the directive 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 already mark the tool as read-only and non-destructive. The description adds behavioral context: explains what each mode returns, parameter forwarding, and the 'expect' constraint. It does not cover potential side effects or limitations, but the annotations cover the safety profile.

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

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

The description is concise, using a bullet list for modes and clear language. Every sentence adds value, 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 the complexity of three modes and seven parameters, the description is largely complete. It explains purpose, mode selection, and parameter roles. Since an output schema exists, not detailing return values is acceptable. Minor gaps: no mention of error conditions or response structure.

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

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

Schema coverage is 100%, and the description adds mode-specific parameter guidance (e.g., which params apply to each mode). This clarifies usage beyond the schema's parameter descriptions without redundancy.

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 resolves or inspects topology against a lowered geometry, with three distinct modes (evaluate, resolve, lineage) each having a specific purpose. This differentiates it from sibling tools like 'inspect' or 'evaluate_script' by focusing on querying via ref, DSL, or AST.

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 opens with 'Use this when you need to resolve or inspect topology against a script's lowered geometry' and breaks down when each mode is appropriate. However, it does not explicitly state when not to use this tool or name alternative tools from the 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 claims 'Side-effect-free,' but annotations set destructiveHint=true, indicating the tool has side effects (modifying code). This contradiction misleads about safety; the description does not clarify what side effects occur.

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

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

Four sentences, front-loaded with 'Use this when...', no wasted words. All information is essential and well-ordered.

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 output schema and annotations, the description covers key behavior: returns modified code and diagnostics, refuses to remove return line. Missing details on match uniqueness failure, but overall sufficient.

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

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

Schema coverage is 100% and already includes descriptions for both parameters. The description adds only a usage context but no new semantic meaning beyond the schema examples.

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 removes a feature line from a script, specifying the verb (remove) and resource (feature line). It distinguishes from sibling tools like add_feature by its purpose.

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

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

The description explicitly says 'Use this when you need to remove a feature line from a script,' providing clear usage context. However, it does not explicitly mention when not to use or alternatives, though siblings imply absence of add-like 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 mark readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds extensive behavioral details: it writes PNGs to disk (local paths, temp dirs), requires playwright chromium, runs mechanism truth (with watermark on failure), and explains that paths are local-machine only. It also clarifies behavior under KERNELCAD_RENDER_STRICT=1 and no_mechanism_check. 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 comprehensive but verbose, repeating 'NO STUDIO / DEV-SERVER REQUIRED' and including some details that could be streamlined. It uses bold for emphasis and front-loads the main purpose, but could be tightened without losing meaning. Adequate but not excellent in conciseness.

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

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

Despite 13 parameters and a rich output schema, the description covers all essential aspects: environment dependency (playwright), mechanism check behavior, local path handling, fallback logic for base_url, and return format (images with per-view descriptions). It leaves no major gaps for an AI agent to understand what the tool does and what to expect.

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

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

With 100% schema description coverage, baseline is 3. The description adds extra meaning for key parameters: explains pose format ('az,el' with rotation semantics), focus/hide semantics (mutually exclusive, same as CLI flags), and no_mechanism_check effect (ignored under strict mode). Some parameters (e.g., environment) only get minimal extra context, but overall the description significantly enriches understanding beyond the schema.

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

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

The description starts with a clear verb-resource pair ('render a kernelCAD model to deterministic PNG views') and immediately differentiates from siblings by noting 'NO STUDIO / DEV-SERVER REQUIRED' and mentioning alternative tools for remote clients (open_in_studio). It explicitly states the tool's role in the evaluate→render→inspect→fix loop, making intent 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 explains when to use this tool (visual self-check, fast iteration) and provides context for alternatives (open_in_studio for remote clients). It covers trade-offs like skipping mechanism check for speed, but does not explicitly list scenarios where the tool should not be used. Overall, guidance is strong but slightly incomplete.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds context about the deterministic review loop, including script evaluation, assembly validation, mate checking, interference checks, and repair verdict. 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 front-loaded with usage context and is well-structured with a clear list of steps. It is reasonably concise given the complexity, though some redundancy could be trimmed.

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 12 parameters (none required), full schema descriptions, output schema, and annotations, the description provides a comprehensive overview of the tool's behavior and return value (repair verdict). It covers the main steps and is complete for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific details beyond the schema, which is acceptable since the schema already provides full descriptions for all 12 parameters.

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

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

The description clearly states the tool's purpose: reviewing a mechanism for fitness and repair mode. It specifies the verb 'review', the resource 'CAD model', and provides a detailed list of steps in the deterministic CAD review loop. This makes it distinct from sibling tools.

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

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

The description explicitly says 'Use this when you need to review a mechanism for fitness and repair mode,' providing clear context for use. However, it does not mention when not to use this tool or alternatives, so it lacks explicit exclusions.

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

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

Adds critical context beyond annotations: slug-based capability (no OAuth), private projects require owner signed-in, return format with signed URLs and optional base64 inlining, and default behavior. 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 well-structured, front-loaded with the main purpose, and each sentence adds value without redundancy. Approximately 150 words and efficiently conveys all necessary information.

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

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

Despite having an output schema, the description still outlines the return format (signed URLs, struck part names, optional base64). All 3 parameters are fully covered, and authentication context is provided. The description is complete for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable context: explains slug as project link, paths_only default and effect, freshness_sec default and usage hints. This goes beyond the schema documentation.

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

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

The description clearly states 'Return the newest brush-painted review packet from a Studio session,' specifying the exact resource and action. It distinguishes itself from siblings like 'review_cad' by focusing on painted feedback from a shared link.

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 call with 'slug' (after sharing a /p/<slug> link) and when to omit (for own signed-in packet). No explicit when-not-to-use, but the context is clear enough.

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

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

Discloses return values (modified code + diagnostics) and explicitly states no side effects, going beyond annotations which only provide hints.

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 focused sentences: first states purpose, second describes return and external persistence. No fluff, essential information 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?

Given the tool's moderate complexity and full schema coverage, description covers all necessary aspects: purpose, parameters, return, and side-effect behavior.

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

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

Adds context to param_name ('first arg to param()') and provides examples for new_value, adding value beyond the 100% schema description coverage.

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

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

States specific action: 'edit a param() default value in a kernelCAD script'. Distinguishes from sibling tools like add_part or remove_feature which handle other script modifications.

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 tells when to use (edit param default) and clarifies that persistence is handled externally via file-write tools, setting correct expectations.

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