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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Analyze naming issues' without stating whether the operation is read-only, whether it modifies the document, or what side effects (if any) it has. The description adds minimal detail beyond the tool name, leaving an agent unable to anticipate safety or mutation behavior.

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

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

The description is a single sentence with no wasted words, which is concise. However, it is so brief that it omits essential details about parameters and behavior. While the purpose is front-loaded, the overall content is insufficient for a tool with two optional parameters and no output schema, so it does not earn a higher score.

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 two optional parameters with no schema descriptions, no output schema, and no annotations, the description is severely incomplete. It does not explain what 'naming issues' include, what the analysis returns, whether it requires a selected or active document, or how the parameters affect the analysis. An agent has no reliable way to know what to pass or what to expect, making this definition inadequate.

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

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

The input schema has zero description coverage for its two optional parameters ('rules_path' and 'document_id'), and the description provides no explanation of either. It only mentions 'selected or active document,' which loosely hints at document selection but does not clarify the parameters' roles. With no additional semantics, an agent cannot infer how to use the parameters correctly.

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

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

The description clearly states a specific verb ('Analyze') and resource ('naming issues'), and scopes it to the 'selected or active document.' It distinguishes itself from sibling tools like analyze_spec_issues by the object of analysis (naming vs. spec), though it does not explicitly reference any sibling or contrast with them.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or preconditions. It neither mentions similar tools (e.g., analyze_spec_issues) nor clarifies context such as whether it requires an open document. The usage is only implied by the name and vague verb.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the analysis is read-only, whether it modifies the document, what kinds of issues are detected, or what the tool returns. 'Analyze' implies a non-mutating operation, but that is not made explicit.

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

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

The description is a single short sentence with the action and resource front-loaded. It contains no redundant explanations, though the word 'basic' is somewhat vague and could be replaced with more concrete scoping 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 no annotations, no output schema, and low schema coverage, the description is under-specified. An agent cannot determine expected output, parameter behavior, or how this tool relates to the many sibling specification and analysis tools.

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

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

Schema description coverage is 0%, and the description does not explain what 'rules_path' does or how it affects the analysis. 'document_id' is only weakly implied by 'selected or active document', so both parameters remain largely underspecified.

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

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

The description states a clear action ('analyze') and a resource ('specification issues in the selected or active document'). It is not a tautology, but the qualifier 'basic' is vague and it does not explicitly differentiate itself from sibling tools like analyze_naming_issues or other specification-related tools.

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

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

There is no guidance on when to use this tool versus alternatives such as analyze_naming_issues or preview_specification_generation. The only context given is that it operates on the selected or active document, with no conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'writable fields only,' which implies a safety filter, but it does not disclose what happens to non-writable fields (silently ignored? error?), whether the operation is reversible, whether it mutates the document immediately, or what the save/close_after_save parameters do. The description adds minimal behavioral context beyond the name.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the verb and resource. However, it is so brief that it sacrifices useful detail; still, for conciseness alone it earns a 4.

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

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

Given the tool has 4 parameters, no output schema, no annotations, and 0% schema description coverage, the description is incomplete. It does not explain the changeset format, the save behavior, the document context, or the relationship to preview_changeset. An agent would struggle to invoke this tool correctly without additional documentation.

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

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

Schema description coverage is 0%, so the description must compensate for the four parameters. It does not explain what 'changes' should look like, what 'save' controls, what 'document_id' refers to, or what 'close_after_save' does. The parameter names are somewhat self-explanatory, but the description adds no meaning beyond the schema's field names and types.

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

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

The description states a specific verb ('apply') and resource ('prepared changeset'), and adds a scope qualifier ('to writable fields only'). It is clear enough about what the tool does, but it does not distinguish it from sibling tools like apply_relink_paths, apply_specification_changes, or apply_v_belt_grooves, which also apply prepared changes. The phrase 'prepared changeset' is somewhat vague without context on how a changeset is prepared.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention that a changeset should first be prepared via preview_changeset or preview_property_changes, nor does it explain the relationship to apply_specification_changes or apply_relink_paths. An agent would have to infer usage from the name and schema alone.

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

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

With no annotations, the description carries the full burden of disclosing side effects, but it only says it applies relinks and saves a result. It does not state whether the original assembly file is modified in place, whether a KOMPAS session must be open, what happens when output_path is null, or whether the operation is reversible.

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

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

The description is a single, front-loaded sentence with no filler. It earns its place, though 'through KOMPAS itself' is slightly vague. It could be expanded without becoming wasteful.

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

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

For a tool with no output schema and undocumented parameters, this is incomplete. The agent cannot determine how to construct the changes array, what output_path null means, or how this compares to the closely related relink tools in the sibling 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 description coverage is 0%, and the description only maps assembly file to assembly_path and target path to output_path. The critical 'changes' parameter (array of arbitrary objects) is not described at all, so the agent receives no information about what each relink change should look like.

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

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

The description states a clear action (apply relinks), target resource (assembly file), execution mechanism (through KOMPAS itself), and output behavior (save result to target path). This is enough to distinguish it from generic tools, though it does not explain what a relink is or how it differs from apply_relink_paths.

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

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

No guidance is provided about when to call this tool versus the many sibling tools (preview_file_relink_paths, build_file_relink_plan, apply_relink_paths, relink_to_export, etc.). The phrase 'through KOMPAS itself' hints at mechanism, but there is no explicit when-to-use or alternative-routing information.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Preflight or cut' implies a two-phase write operation, but the description never explains that preflight is non-destructive while cutting writes to the model, that confirm_write gates the actual write, or that the operation targets exactly one body (body_count const 1). The write/destructive implications and the return behavior are left unstated.

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 single sentence is tight, front-loaded with the verb, and contains no filler. However, it leans toward under-specification rather than genuine conciseness, omitting essential information about the two-phase behavior and inputs. The structure is clean but at the expense of completeness.

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

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

For a complex tool with a nested profile/target schema, no annotations, and no output schema, the description is incomplete. It does not explain the execute/confirm_write write flow, what data the rotational blank contract requires, or what preflight vs. cut returns. An agent cannot reliably determine inputs or interpret results from this definition.

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

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

Schema description coverage is 0% and the description adds nothing about parameters. With a complex nested schema (profile with designation enum PH/PJ/PK/PL/PM, effective_diameter, groove_count; target rotational-blank contract; execute/confirm_write booleans; axial_center), the description should compensate but explains zero parameter semantics. An agent has no guidance on what profile or target values to supply.

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

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

The description states a clear verb-and-resource ('Preflight or cut exact rounded Poly-V grooves into one global-X rotational body'), specifying the target body type and axis. It distinguishes from sibling apply_v_belt_grooves (V-belt vs Poly-V) and, via the 'Preflight or cut' wording, hints at its difference from preview_poly_v_groove. However, the preview-vs-apply distinction is implied rather than explicitly named.

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

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

The description gives no explicit when-to-use guidance or alternative routing. 'Preflight or cut' hints at a preview/execute duality but never tells an agent when to set execute=true versus execute=false, when confirm_write is required, or that list_poly_v_profiles/resolve_poly_v_profile should be used first to select a designation. No prerequisites (e.g., document open, rotational blank present) are stated.

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

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

With no annotations, the description must carry the burden of behavioral disclosure, but it only says 'Apply'. It does not state whether source paths are permanently overwritten, whether save and close_after_save control persistence, or whether the operation is reversible or fails without an active assembly.

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

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

The description is a single focused sentence with no filler and front-loads the action. It is concise, though the terseness comes at the expense of behavioral and parameter detail captured by other dimensions.

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

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

This is a mutating, multi-parameter tool with no annotations, no output schema, and 0% parameter description coverage. The one-sentence description omits return values, the required changes structure, document targeting semantics, and save/close behavior, making it inadequate for safe invocation.

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

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

Schema description coverage is 0%, and the description names none of the four parameters. The critical 'changes' array remains an opaque list of arbitrary objects, so the agent receives no guidance on constructing valid input beyond the schema's empty shape.

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 ('Apply') and names both the object ('component source-path relinks') and the target ('selected or active assembly'). This clearly distinguishes it from sibling tools like apply_file_relink_paths, which target file paths.

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

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

No when-to-use or alternative-selection guidance is given. The phrase 'selected or active assembly' hints at a prerequisite, but the description never says to use this after preview_relink_paths or build_relink_plan, nor when to prefer it over the many relink siblings.

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

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

Annotations are absent, so the description bears the full burden of disclosing side effects. It says 'Apply' which implies mutation, but it does not state whether the operation modifies the document, whether it saves, whether it is reversible, or what changes are made to the specification rows. The description adds almost nothing beyond what the name itself suggests.

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 single sentence is short and free of fluff, but it is under-specified rather than concisely complete. For a tool with 9 parameters and no other documentation, one vague sentence is not appropriately sized; the brevity sacrifices essential meaning.

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

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

This is a complex operation with 9 parameters, no annotations, no output schema, and rich sibling context. The description provides almost none of the contextual framing an agent needs: no mention of preview flow, no scope, no save behavior, no relationship to related specification tools. It is far from sufficient for correct invocation.

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

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

Schema description coverage is 0%, and the description mentions none of the 9 parameters. An agent has no help understanding what 'fields', 'fill_only', 'max_objects', 'include_root', 'close_after_save', or 'description_index' control. The description completely fails to compensate for the schema's total lack of parameter 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 identifies a clear verb ('Apply') and resource ('filling or syncing of specification rows from the model tree'), so an agent can reasonably infer this executes an autofill operation. However, 'filling or syncing' is ambiguous about what exactly happens, and it does not clearly distinguish this tool from closely related siblings like apply_specification_changes or refresh_specification_from_model.

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

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

There is no guidance about when to use this tool versus alternatives such as preview_specification_autofill, apply_specification_changes, or refresh_specification_from_model. The relationship to preview_specification_autofill is implied by the name but never stated in the description, so an agent cannot confidently decide when this is the right 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Apply edits,' which implies mutation, but it does not disclose whether changes are persisted only when save=true, what side effects occur, whether edits are reversible, or how close_after_save and max_objects affect execution.

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

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

The description is a single sentence with no filler, and the core purpose is front-loaded. It is concise and easy to scan, though it achieves this by omitting important operational detail.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, this description is incomplete. It omits critical context around save semantics, the shape of the updates array, document/layout scoping, row limits, and what happens after save.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints that updates contain 'object_id and standard fields.' It does not explain save, document_id, layout_name, max_objects, close_after_save, or description_index, leaving most of the 7 parameters semantically undocumented.

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

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

The description states a specific action ('Apply edits'), a specific resource ('existing specification rows'), and the key identifier ('by object_id and standard fields'). It is clear enough to distinguish from preview_specification_changes and create_specification, though it does not explicitly name sibling alternatives.

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

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

No guidance is given on when to use this tool versus alternatives like preview_specification_changes or apply_changeset. There is no mention of prerequisites, expected workflow ordering, or when the save parameter should be set.

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

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

With no annotations, the description carries the behavioral burden; 'Preflight or cut' usefully exposes two modes (non-committing preflight vs committing cut) and the single-body/global-X restriction. However, it does not disclose that execution writes to the document, the role of confirm_write/execute, or what features (rotational cut, fillets) are produced.

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

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

A single front-loaded sentence with no filler; every word adds scoping information (preflight vs cut, previewed, one body, global-X).

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

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

For a complex nested request with no output schema and no annotations, the one-line description is insufficient. It omits how to trigger the preflight vs cut mode, the required document target/profile inputs, and the relationship to preview_v_belt_groove; an agent would need to reverse-engineer the large schema to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it mentions no concrete parameters. The only added semantic is 'one global-X rotational body', which clarifies the target contract (axis/body_count) in plain language; execute, confirm_write, profile, and document_id behavior are left entirely to the large nested 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 names a specific action ('Preflight or cut') and resource ('previewed V-grooves') plus a clear target scope ('one global-X rotational body'), which matches the schema's axis='global_x' and body_count=1 constraints. This distinguishes it from the preview_v_belt_groove sibling (preview only) and apply_poly_v_grooves (poly-V, not V-belt).

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

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

The phrase 'previewed V-grooves' implies the tool should be used after a preview operation, and 'one global-X rotational body' scopes valid targets, but no alternative tools or explicit when-not-to-use conditions are named. The intended workflow is inferable rather than stated.

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

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

With no annotations provided, the description carries the full burden. It discloses read-only opening (a safety signal) and continuation after errors, which are useful. However, it omits critical behaviors such as whether documents are saved, whether reports are generated (despite report_dir and report_name parameters), and what the return value or output format is. The mention of read-only adds value but is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core actions (open read-only, run checks, close, continue on errors). It contains no filler and is appropriately concise for the information it conveys.

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

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

For a tool with 13 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool returns, how to configure the analysis scope, what report formats are supported, or how errors are surfaced. An agent cannot invoke this tool correctly based on the description alone.

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

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

Schema description coverage is 0%, and the description does not explain any of the 13 parameters. It mentions 'naming/spec quality checks' which likely maps to the 'analyses' parameter, but provides no details on root, limit, paths, recursive, extensions, report_dir, rules_path, report_formats, or continue_on_error. The description fails to compensate for the lack of schema documentation, leaving agents without essential parameter 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 the action (open models read-only), the resource (models), and the purpose (naming/spec quality checks). It also mentions the batch nature and error continuation. However, it does not explicitly contrast with sibling tools like analyze_naming_issues or analyze_spec_issues, which could be confused for single-document 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 no guidance on when to use this batch tool versus the single-document analyzers or other related tools. It implies a batch scenario but does not state selection criteria, exclusions, or alternatives. An agent cannot determine when this is the preferred 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?

With no annotations, the description carries the full burden of behavioral disclosureasi. It only reveals that per-file errors are tolerated ('continuing after per-file errors'), but it does not explain side effects, whether reports or output files are generated, whether the operation is read-only, or how failures are reported.

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

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

The description is a single, front-loaded sentence with no filler. It delivers the core action, scope, and resilience behavior efficiently without repeating the tool name or schema fields.

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

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

For a 13-parameter tool with no annotationsane and no output schema, this description is severely incomplete. It does not explain return values, report generation, scope behavior, filtering options, or any expected outcomes, leaving an agent under-equipped to invoke the tool correctly.

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

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

Schema description coverage is 0% and there are 13 parameters, yet the description only hints at two: 'folder or explicit file list' corresponding to root/paths and 'continuing after per-file errors' corresponding to continue_on_error. Critical parameters such as recursive, extensions, dry_run, report_dir, report_name, and report_formats receive no semantic clarification.

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

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

The description clearly states the action ('Run lifecycle smoke-checks'), the target scope ('over a folder or explicit file list'), and a distinguishing feature ('continuing after per-file errors'). This differentiates it from sibling tools like smoke_check_session, which appears to be the single-session counterpart.

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

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

The description implies a use case (batch smoke-checking over folders or file lists) but does not explicitly state when to use this tool versus alternatives such as smoke_check_session or scan_model_files. There are no exclusion criteria, prerequisites, or explicit alternative routing.

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

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

With no annotations, the description must convey behavioral traits, but it only says 'build a grouped actionable relink plan' without disclosing whether it is read-only, what side effects it might have, or what the output looks like. It does not contradict annotations since none exist.

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

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

The description is a single concise sentence with no wasted words, but it is so sparse that it sacrifices usefulness. It is appropriately sized for clarity but lacks the substance needed to be actionable.

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

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

Given the tool's complexity (two required paths, no output schema, no annotations), the description is grossly incomplete. It does not explain what an 'explicit mapping file' is, what the relink plan contains, or how the assembly path factors in.

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

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

Schema description coverage is 0% and the description does not explain the two required parameters (assembly_path, mapping_path). An agent has no idea what these paths should point to or their expected formats.

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

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

The description states a specific action (build a relink plan) and its input (explicit mapping file), making the core purpose clear. However, it does not explicitly differentiate from sibling tools like build_relink_map_plan or build_file_relink_plan, relying on subtle wording like 'grouped actionable' to imply uniqueness.

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

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

No guidance is provided on when to use this tool versus the many similar relink planning tools (e.g., build_relink_plan, preview_relink_map_paths). The description does not mention conditions, alternatives, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Build...plan' implies a non-mutating planning operation, but the description does not explicitly state that no files are modified, what the plan contains, or how downstream tools consume it.

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

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

The single sentence is concise and free of filler, and the core action is front-loaded. However, it is under-specified for a three-parameter tool, so the brevity borders on incompleteness rather than ideal 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?

With no annotations and no output schema, the description needs to explain return shape, parameters, and side effects, but it only provides a terse summary. An agent has insufficient context to know what a 'grouped actionable relink plan' looks like or how to use the two required arguments.

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

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

Schema description coverage is 0%, and the description adds no information about assembly_path, search_root, or relink_all. The optional boolean relink_all is completely unexplained, leaving the agent unable to determine its effect on the generated plan.

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

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

The description states a clear action and object: 'Build a grouped actionable relink plan for an assembly file.' This is specific enough to convey high-level intent. However, it does not explicitly distinguish this from sibling tools like build_relink_plan or build_file_relink_map_plan.

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

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

There is no guidance on when to use this tool versus alternatives such as build_relink_plan, build_file_relink_map_plan, or preview_relink_paths. It does not state prerequisites, exclusions, or the role of the plan in a larger relink workflow.

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

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

No annotations are provided, so the description carries the full burden. It says the tool 'builds' a plan, implying a non-destructive analysis, but it does not disclose whether the plan is persisted, whether it modifies the document, whether it requires file access, or what the output format is. The word 'actionable' hints at later application but the behavior remains underspecified.

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

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

The description is a single sentence with no filler. It front-loads the main action and includes the key inputs. It could be slightly more informative without becoming verbose, but it is appropriately concise.

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

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

Given no annotations, no output schema, and 0% parameter coverage, the description is too thin. An agent cannot tell whether this tool is safe to call, what the plan looks like, or how it differs from the many relink siblings. The presence of build_relink_plan, build_file_relink_map_plan, and preview_relink_map_paths makes the missing differentiation more costly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that a mapping file is used, which maps to mapping_path, and that the document is selected or active, which maps to document_id. However, it does not clarify the format of mapping_path, whether document_id is required when no document is active, or what happens when both are absent.

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

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

The description states a specific verb ('Build') and resource ('grouped actionable relink plan') and mentions the input source ('mapping file') and target ('selected or active document'). It is clear enough to distinguish from generic relink tools, though it does not explicitly name a sibling alternative.

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

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

The description implies the tool is used when a mapping file is available and a relink plan is needed, but it does not state when to prefer this over siblings like build_relink_plan, build_file_relink_map_plan, or preview_relink_map_paths. No exclusions or alternative conditions are 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?

No annotations are provided, so the description must carry the full behavioral disclosure burden. It only says the tool 'builds' a plan and gives no information about side effects, whether changes are applied, required document state, permissions, or output behavior.

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

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

The description is a single sentence and starts with the action verb, so it is brief and front-loaded. However, it is so terse that it substitutes vague phrases like 'grouped actionable' for structure that would help an agent understand the tool's purpose.

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

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

With three undocumented parameters, no annotations, and no output schema, the description should explain return values, how the plan is grouped, and how the document/selection is determined. It provides almost none of this, leaving a substantial gap for an agent trying to invoke the tool correctly.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters: relink_all, document_id, and search_root. Since the schema itself provides no descriptions, the description completely fails to clarify what these parameters mean or how they affect the plan.

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 concrete verb and object ('Build ... relink plan') and identifies a target document, but 'grouped actionable' is undefined jargon. It does not distinguish this from siblings like build_relink_map_plan, build_file_relink_plan, or build_file_relink_map_plan.

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

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

There is no guidance on when to use this tool rather than the other relink-plan or preview-relink siblings. It does not explain what scenario requires building a plan, when relink_all is appropriate, or what 'selected or active document' means in practice.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It indicates a read-like 'readback' operation and an optional manifest write, but it does not mention important side effects or defaults such as close_after_probe=true, require_active_document=true, or whether the document state is affected.

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

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

The description is a single front-loaded sentence with no filler, and the primary action and scope are stated first. However, the jargon 'bounded readback' and the compressed list of behaviors could be structured more helpfully.

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

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

For a tool with 8 parameters, no annotations, no output schema, and no per-parameter descriptions, the one-line description is insufficiently complete. It lacks information about return values, side effects, default behaviors, and how this tool relates to the many readback/probe/verification siblings.

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

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

The schema has 0% description coverage and all 8 parameters are undocumented, so the description must compensate. It only loosely maps to document selection ('active/opened document') and manifest output ('writing the full manifest JSON'), leaving parameters like visible, read_only, model_path, and close_after_probe without meaningful 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 identifies the action ('Capture') and the resource ('bounded readback snapshot') for an active/opened document, and mentions the optional manifest JSON writing. However, it does not explicitly distinguish this from closely related sibling tools such as probe_document_readback or verify_document_readback_stability.

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

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

The description implies usage context by referring to an 'active/opened document' and optional manifest output, but it never states when to prefer this tool over alternatives or when not to use it. There is no explicit routing to any sibling 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It discloses the two checks (openable, locked) but does not say what the tool returns, whether the 'can be opened' check actually attempts to open the file (and whether that has side effects), or how 'locked by another process' is determined. For a probe tool whose entire value is its verdict, the outcome semantics are undisclosed.

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 18-word sentence that leads with the verb 'Check' and states the two checks without filler. Every word earns its place, and there is no redundant restatement of the tool name or schema content.

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

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

With no output schema, no annotations, and a 0%-coverage parameter schema, the description is the only source of context, and it does not explain how an agent interprets the result (boolean? structured status?) or what distinguishes the two checks (e.g., does a locked file also count as 'cannot be opened'?). An agent cannot reliably act on this tool's outcome with the information given.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'path' parameter. It adds only the implicit notion that the path identifies 'a file,' and says nothing about accepted path formats (absolute, relative, workspace-resolved), whether the file must exist, or constraints like local vs. network paths. Even with a single parameter, the agent is left guessing about path conventions.

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

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

The description names a specific verb ('check') and resource ('file') with two concrete aspects: openability and lock status. This distinguishes it from siblings like open_document, scan_model_files, and get_file_composition, none of which perform an access probe. However, the phrase 'appears locked by another process' is slightly hedged and leaves the precise meaning of the check ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. It does not state typical preconditions (e.g., use before open_document, or to diagnose a failed open), nor does it name any alternative tools or exclusion cases. With roughly 130 siblings, an agent must infer the intended usage context entirely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It explains what the tool produces, but does not mention whether it is side-effect-free, whether it can fail, or what happens with incomplete or unusual inputs. It is adequate for a simple classifier, but not detailed.

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

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

The description is one efficient sentence that gets to the point and is appropriately sized for a simple classifier. It could add more detail, but it is not verbose and places the core action first.

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

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

For a tool with three parameters and no output schema, the description gives a high-level account of the result but omits details about how the inputs are used and what categories or recovery hints look like. It is minimally viable but has gaps around optional inputs and expected output variety.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining the roles of 'message', 'stage', or 'exception_type'. The parameter names are somewhat self-explanatory, but the optional parameters' influence on classification output is left entirely to inference.

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

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

The description uses a specific verb 'Classify' with a clear resource ('KOMPAS/COM runtime error' and a clear result ('stable code, category, and recovery hint'). This distinguishes it from CAD/geometry sibling tools and states the tool's unique transformation.

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

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

The description implies when the tool should be used: when a KOMPAS/COM runtime error needs to be classified into a stable code and recovery hint. However, it does not explicitly discuss when not to use it or compare it with related tools such as normalize_operation_result.

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

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

No annotations are provided, so the description carries full burden. 'Apply the current cleanup rules' implies a mutation (it likely modifies the document), but the description doesn't disclose whether this is destructive, whether it requires a certain document state, how the report is generated, or what side effects occur. For a potentially destructive operation, this is a significant gap.

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

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

The description is a single sentence with no unnecessary words, front-loading the core action. It is appropriately concise for the information it provides, though that information is limited.

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

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

With no output schema and no annotations, the description is insufficient for a tool that performs a multi-step process (cleanup, export, report writing). It does not state what the report contains, what kind of working copy is created, or what the expected outcome is. Given the tool's moderate complexity (3 parameters, likely side effects), the description is incomplete.

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

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

Schema description coverage is 0% and the description provides no explanation of the parameters. The schema only lists names and defaults, giving no meaning to 'suffix', 'rules_path', or 'document_id'. The description fails to explain what these parameters control, such as how the suffix affects the output filename or how rules_path selects cleanup rules, leaving the agent unable to set them correctly.

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

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

The description states a specific verb ('Apply', 'export', 'write') and resource ('cleanup rules', 'working copy', 'report'), making the purpose clear at a high level. However, it does not distinguish itself from the many sibling tools that also involve cleanup, export, or relinking, such as 'relink_to_export' or 'save_export_copy', so the agent may not know which to choose without further investigation.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention contexts where cleanup is needed, how it relates to other export or relink tools, or any exclusions. The agent is left to infer usage from the tool name and generic description, which is insufficient given the large and overlapping sibling set.

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

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

With no annotations, the description carries the full burden, and it does disclose the destructive scope ('all constraints') and a precondition ('existing sketch entity'). It does not mention reversibility, error behavior, or whether the entity itself remains untouched, leaving important consequences left to inference.

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

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

The description is a single front-loaded sentence with no filler and communicates the core operation immediately. It is appropriately concise, though it provides no additional structure or elaboration beyond that one sentence.

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

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

For a destructive tool with no annotations, no output schema, and three undocumented parameters, the description is too thin to support reliable invocation. It is sufficient for high-level selection but not enough to construct a correct call confidently.

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

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

Schema description coverage is 0% and the description never explains entity, sketch_ref, or document_id, so it adds no meaning beyond the parameter titles. An agent cannot determine how to identify the target entity from this description 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 states a clear action ('Delete all constraints') and target scope ('attached to one existing sketch entity'), making it a specific destructive constraint-removal operation. It does not explicitly name or contrast sibling tools such as list_sketch_constraints or inspect_sketch_constraint, so it stops short of full differentiation.

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

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

There is no guidance about when to use this tool versus alternatives like list_sketch_constraints, inspect_sketch_constraint, parameterize_sketch, or repair_sketch. No prerequisites, exclusions, or selection criteria are provided.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention whether the close operation is destructive, whether unsaved changes are handled, what close_mode does, or any side effects. The only nuance is 'selected or active', which is insufficient.

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

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

The description is extremely concise (single sentence), which is structurally fine, but it is under-specified to the point of being minimally informative. It front-loads the core action but omits essential details, so it earns a mid-score for brevity without depth.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is far from complete. It does not explain parameter semantics, behavioral outcomes, or error conditions. The agent cannot reliably invoke this tool correctly based on the provided information.

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

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

Schema description coverage is 0%, and the description provides no explanation of the save, close_mode, or document_id parameters. The agent has no semantic understanding of these fields from the description, relying entirely on the schema names which are ambiguous.

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

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

The description clearly states the action (close) and the resource (document), specifying 'selected or active' which distinguishes from other document operations. It is not a tautology and gives a specific scope, though it does not explicitly contrast with sibling tools like open_document.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites, contexts, or when not to use it, leaving the agent to infer usage from the generic phrase.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. For a mutating creation tool, it says nothing about side effects on the document, whether the part gets saved, required session state, or error behavior. The presence of save_partial_on_error and return_partial_result_on_error parameters hints at error semantics, but the description never explains them. No contradiction with annotations since none exist.

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

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

The single sentence is short and front-loaded with the core action. But this is under-specification rather than genuine conciseness - the sentence earns its place but is followed by nothing. It's efficient in length but the brevity comes at the cost of substance.

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

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

The tool has 6 parameters with 0% schema coverage, a nested free-form object, and no output schema, yet the description provides no information about the params structure, return value, or operational behavior. For a creation tool that must receive a detailed spring scenario, this is substantially incomplete - an agent cannot reliably construct a valid call from this definition alone.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning. It mentions the 'compression_spring scenario' as the source but never clarifies what fields the free-form params object should contain (dimensions, material, etc.) or what the five other parameters (visible, output_path, close_after_save, etc.) mean. The description adds almost nothing beyond the parameter names themselves.

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

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

The description states a specific verb (Create), a resource (KOMPAS compression spring part), and a source ('supported compression_spring scenario'). This is clear enough to know the tool's basic function. However, it doesn't differentiate from close siblings like create_spring_from_size or create_part_from_scenario, so an agent cannot tell which creation path to choose without opening other definitions.

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

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

No guidance on when to use this tool versus the many related creation/preview siblings (preview_compression_spring, create_spring_from_size, create_part_from_scenario). No prerequisites, workflow context, or exclusion conditions are mentioned. The agent is left to infer the appropriate scenario from the tool name alone.

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

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

The description has very low behavioral transparency. It doesn't disclose whether the operation is destructive (e.g., overrides existing parts), what happens on failure (despite parameters like 'save_partial_on_error' and 'return_partial_result_on_error' hinting at partial results), or any side effects like file creation or visibility. With no annotations, the description carries the full burden, but it omits these critical behaviors.

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

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

The description is very short (one sentence), which is concise, but it fails to earn its place by missing critical information. It front-loads the core purpose but lacks any detail on parameters or behavior, so the conciseness is more about under-specification than efficient information packing.

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

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

The tool is complex (7 parameters, nested objects, no output schema, no annotations), yet the description provides almost no context. It doesn't explain the return value (the created part object?), error handling (save_partial_on_error), or how to specify parameters. This is grossly inadequate for an agent to call the tool correctly.

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

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

With 0% schema description coverage, the description must explain parameters, but it mentions only 'scenario' and provides an example. It doesn't explain 'params' (the core object), 'output_path', 'visible', 'close_after_save', 'save_partial_on_error', or 'return_partial_result_on_error'. The agent is left guessing what each parameter means, especially 'params' which is a dynamic object.

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

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

The description states a specific verb ('Create') and resource ('KOMPAS part') with an example scenario ('stepped_shaft'), which is clear enough. However, it doesn't explicitly distinguish this tool from siblings like 'preview_part_scenario' or 'create_compression_spring'—the agent might confuse which creation tool to use for scenarios vs. springs. The name itself implies the purpose, but the description barely goes beyond a restatement, missing explicit differentiation from other creation tools.

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

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

The description says 'from a supported parametric scenario' but doesn't explain when to use this tool over alternatives like 'preview_part_scenario' (for previewing) or other creation tools. It doesn't mention required input formats, how to list supported scenarios (maybe via a catalog tool), or any conditions that would make this tool inappropriate. This leaves the agent without clear guidance on tool selection.

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

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

Since no annotations are provided, the description carries the behavioral burden. It adds useful context: the tool creates a 3D point and verifies the before/after snapshot delta. However, it does not disclose side effects, persistence behavior, validation semantics, or what the verification result looks like.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and readable, though it omits enough operational detail that conciseness comes at the cost of completeness.

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

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

For a 7-parameter tool with no output schema, no annotations, and 0% schema description coverage, this one-line description is far from sufficient. An agent cannot determine argument semantics, expected results, failure modes, or preconditions.

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 contains 7 parameters with 0% description coverage, and the description explains none of them. There is no indication of what name, origin, max_items, min_added, document_id, require_no_changed, or require_no_removed mean or how they should be set.

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

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

The description uses a specific verb and resource: 'Create a 3D point in the active part.' It clearly identifies the action and the target context, distinguishing it from sketch-point creation tools even though no sibling is named.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternatives are mentioned. The description implies usage from 'active part' but does not state prerequisites or how this compares to create_sketch_point or other creation tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the tool creates an arc and verifies a snapshot delta, but does not explain side effects, prerequisites (e.g., open document), or failure modes. The 'verify the snapshot delta' phrase is ambiguous and could mislead an agent about the tool's exact behavior.

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

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

The description is a single sentence that front-loads the main action and is free of filler. However, it may be too terse given the complexity, as it omits crucial details while remaining concise.

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

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

Given 15 parameters, no annotations, and no output schema, the description is drastically incomplete. It does not explain the geometry inputs, the verification mechanism, or the expected outcome, making it inadequate for correct invocation.

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

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

Schema description coverage is 0% and the description does not mention any of the 15 parameters, including critical ones like start, center, end, or radius. An agent cannot infer parameter meaning, defaults, or relationships from the description. This is a major gap for a complex tool.

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

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

The description uses a specific verb ('Create'), a resource ('2D sketch arc'), and scope ('new or existing sketch'), distinguishing it from sibling creation tools like create_sketch_line_segment or create_sketch_circle. The added 'verify the snapshot delta' is somewhat vague but does not obscure the core 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 provides no explicit guidance on when to choose this tool over alternatives, such as line, circle, or polyline creation. It only mentions the context of a new or existing sketch, which is a condition, not a selection rule. This leaves the agent to infer the appropriate usage.

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

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

No annotations are present, so the description carries the full burden. It discloses that the tool verifies a before/after snapshot delta, which is a meaningful behavioral trait beyond simple creation. However, it does not explain side effects, failure modes, or what the verification entails.

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

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

One sentence, front-loaded with the primary action. No wasted words, though the verification phrase is somewhat jargon-heavy but still concise.

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

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

With 12 optional parameters, no annotations, and no output schema, the description is far too thin. It does not clarify how the verification parameters interact, what the return value is, or what 'verify' means in practice. This is inadequate for correct invocation.

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

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

Schema description coverage is 0% and the description does not explain any of the 12 parameters. It adds no meaning beyond the parameter names; e.g., max_items, min_added, require_no_changed, require_no_removed are entirely unexplained.

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

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

States a specific action (create) on a specific resource (sketch with one 2D circle) and adds a verification behavior. The circle specification clearly distinguishes it from sibling sketch creation tools like create_sketch_line_segment or create_sketch_rectangle.

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

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

No explicit guidance on when to use this tool versus other create_sketch_* tools. The description implies usage when a circle is needed, but does not name alternatives or exclusions.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It adds a meaningful behavioral trait ('verify the snapshot delta') and mentions new-or-existing sketch support. However, it does not explain what happens on verification failure, side effects beyond creation, or any preconditions.

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

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

The description is a single efficient sentence with no filler and front-loaded core action. It is appropriately concise, though it could have used the spare sentence to add one or two parameter or usage clarifications.

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 14 parameters, no output schema, no annotations, and no schema description coverage, this description is too sparse. The agent can infer the primary operation but lacks enough context to know how defaults interact, required inputs for a new sketch, or what the verification behavior actually validates.

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

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

The schema has 0% description coverage and 14 parameters; the description adds no parameter-level meaning. Parameter names like radius_x and plane hint at their roles, but the description does not compensate for the missing schema descriptions, leaving center format, line_style, require_no_changed, and others unexplained.

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

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

The description uses a specific verb and resource ('Create one 2D sketch ellipse') and adds useful scope ('in a new or existing sketch'). It clearly identifies what the tool does, though it does not explicitly distinguish itself from sibling entity-creation tools like create_sketch_circle or create_sketch_entities.

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

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

The context is implied: use this tool when you need a single 2D ellipse in a sketch. It does not compare against alternatives or state when to prefer create_sketch_entities for multiple entities, so usage guidance is present but not explicit.

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

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

With no annotations, the description carries the full burden and it does disclose that the tool mutates by creating entities and that it verifies the snapshot delta. However, it does not mention document-open requirements, persistence behavior, error handling, or what happens when verification fails, leaving notable behavioral gaps.

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

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

The description is a single front-loaded sentence with no filler. Every phrase contributes meaning, and it clearly leads with the primary action and resource.

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

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

For a complex 13-parameter tool with no output schema and no annotations, this description is far too thin. It omits how entities are structured, how constraints and dimensions are supplied, whether a new sketch is created, what the return value is, and what 'verify snapshot delta' implies for the caller.

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

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

Schema description coverage is 0%, so the description must compensate for the 13 parameters, but it adds almost nothing specific. 'Several' hints at the array nature of entities and 'target sketch' hints at a sketch context, but there is no explanation of entities, constraints, dimensions, flags, or the create_new_sketch/sketch_ref relationship.

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 ('create') and identifies a concrete resource ('several 2D sketch entities in one target sketch'), clearly distinguishing it from the singular create_sketch_* tools among the siblings. The additional mention of 'verify the snapshot delta' establishes a distinct secondary 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 phrase 'several 2D sketch entities in one target sketch' clearly communicates the intended batching use case versus single-entity creation alternatives. It does not explicitly state exclusions or mention when to prefer sibling tools, but the context is unambiguous enough for selection.

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

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

With no annotations available, the description must carry behavioral disclosure. It does state that the tool both creates geometry and verifies a before/after snapshot delta, which is useful because similar creation tools might only create. However, it does not disclose side effects, permissions, or failure semantics.

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

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

The description is one sentence with no filler, front-loading the core action before the verification behavior. Every clause earns its place.

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

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

For a tool with 12 parameters and no output schema, this is too sparse. The critical defaults and relationships among parameters, such as the snapshot verification flags, are left to the agent to infer, so a correct call beyond the defaults is underspecified.

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 12 parameters and 0% description coverage. The description explains none of them, so an agent cannot know how start/end coordinates, plane, create_new_sketch, or the require_* flags are meant to be used.

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

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

The description names a specific operation (create) and resource (a sketch with one 2D line segment), which immediately distinguishes it from sibling tools such as create_sketch_circle or create_sketch_polyline. The added verification behavior is also stated.

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

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

The intended use is implied by the resource named, but no explicit when-to-use, when-not-to-use, or alternative guidance is provided. An agent can infer it is the line-segment creator from the purpose, but nothing excludes or routes to related sketch 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?

With no annotations, the description carries the behavioral burden. It does disclose one notable behavior: the tool 'verif[ies] the snapshot delta' after creation. However, it does not explain side effects on the document, permissions, or error/failure behavior, so transparency is only partial.

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

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

A single front-loaded sentence with no filler. It states the action and the key behavioral addition in order of importance.

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

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

For an 11-parameter tool with no annotations and no output schema, this description is far from complete. It covers the core object but says nothing about most parameters, side effects, return values, or realistic invocation scenarios.

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

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

Schema description coverage is 0%, so the description must compensate. 'New or existing sketch' adds some meaning to create_new_sketch/sketch_ref, but the other nine parameters (e.g., max_items, min_added, require_no_changed, require_no_removed, line_style) are left completely unexplained.

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

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

The description names a specific verb and resource: 'Create one 2D sketch point' in 'a new or existing sketch.' This clearly differentiates it from sibling tools like create_sketch_line_segment or create_sketch_circle.

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

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

No guidance is given about when to choose this tool over alternatives, such as create_sketch_entities for bulk creation or the other primitive creators. The 'new or existing sketch' clause implies a selection condition but provides no exclusions or prerequisites.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'verify the snapshot delta,' hinting at a verification step, but omits side effects (e.g., mutation of the sketch), prerequisites (e.g., open document), or failure behavior. This is insufficient for a create operation.

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

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

The description is a single sentence that is concise and front-loaded with the core purpose. It avoids unnecessary verbosity, though the extreme brevity contributes to other dimensions being under-specified.

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

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

For a tool with 12 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain how to construct points, what the snapshot delta verification entails, or what the tool returns. An agent cannot confidently invoke this tool correctly based on the description alone.

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 12 parameters with 0% description coverage, and the tool description provides no explanations for any of them. It does not clarify what 'points' should look like, the meaning of 'closed,' or the role of 'sketch_ref' versus 'create_new_sketch.' The description fails to compensate for the schema's lack of parameter 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 the tool's purpose: 'Create one 2D sketch polyline' with the scope 'in a new or existing sketch.' The verb-resource combination is specific and differentiates this from other create_sketch_* tools (e.g., create_sketch_line_segment) by naming the polyline entity.

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

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

The description offers minimal contextual guidance ('new or existing sketch') but does not specify when to prefer this tool over alternatives like create_sketch_line_segment or create_sketch_circle. No exclusions or conditions are given, leaving selection to the agent's inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the tool verifies the before/after snapshot delta, but it does not explain mutation scope, required session state, failure behavior, or what the verification enforces.

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 single sentence is front-loaded and has no filler, which is good. However, a 12-parameter tool with no schema descriptions and no annotations needs more than a sentence, so the brevity is under-specification rather than appropriate 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?

The core action and one verification behavior are present, but the description is not complete enough for an agent to invoke the tool correctly. Missing context includes coordinate conventions, plane naming, whether a sketch/document must already exist, and how max_items/min_added/require_no_changed/require_no_removed control the verification.

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 for 12 undocumented parameters. It adds meaning only for corner1/corner2 ('two corners') and vaguely hints at verification, but leaves plane format, coordinate units, sketch_ref/document_id behavior, and the verification criteria parameters unexplained.

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

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

The description names a concrete operation, creating a sketch rectangle from two corners, which distinguishes it from sibling create_sketch_line_segment/circle/ellipse tools. The appended snapshot verification is a secondary behavior and slightly blurs the primary purpose, so it stops short of a 5.

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

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

No guidance is given on when to use this tool versus the many sibling sketch-creation tools, nor are prerequisites such as an open document or existing sketch mentioned. The purpose implies one use case, but there are no explicit conditions, exclusions, or alternative routing.

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

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

No annotations are provided, so the description must disclose behavioral traits. The definition implies a creation/modification operation but does not state whether it saves, alters the document, or is reversible. It mentions 'fill rows' which implies writing data, but doesn't disclose effects on the model or existing specifications. The absence of any mention of side effects or return behavior leaves the agent without crucial transparency.

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

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

The description is a single sentence, which is efficient and front-loads the primary purpose. It does not waste words, but could be expanded with critical details without losing conciseness. It's appropriately sized for a one-line intro, though deeper context is missing.

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 (8 parameters, 0% schema coverage, no annotations, no output schema), the description is far from complete. It lacks any explanation of parameters, return values, side effects, or conditions. An agent cannot reliably invoke this tool correctly without additional documentation. The description provides minimal context to operate in the broader toolset.

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

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

The schema description coverage is 0%, and the description provides no explanation for any of the 8 parameters. The parameter names might hint at their purpose (e.g., save, include_root), but the description does not explain the meaning or relationships. For instance, what does 'replace_existing' do? What is the role of 'style_id'? Without documentation, the agent has to guess, which is a serious shortfall for a tool with this many 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 action ('create') and the resource ('specification description') and includes an additional behavior ('fill rows from the current assembly tree'). This verb+object structure is clear, though it does not explicitly distinguish it from closely related siblings like preview_specification_generation or create_spw_from_model, but the core purpose is understandable.

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

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

There is no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites like having a document open or whether it's for initial creation versus updating. The phrase 'from the current assembly tree' hints at context but no exclusions or selections are provided. With many specification-related siblings, this is a notable gap.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a mutating operation, whether it saves to disk, what 'supported' means, or what side effects occur (e.g., creating a document, closing after save). The parameter close_after_save hints at behavior, but the description itself is silent.

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

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

The description is a single short sentence, which is concise, but it is under-specified. It front-loads the core action but omits essential context. It is not verbose, but it does not earn its place as a complete definition.

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

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

Given 7 parameters, no annotations, no output schema, and 0% schema description coverage, the description is incomplete. An agent cannot determine prerequisites, side effects, or how parameters interact. The tool appears to be part of a spring-creation workflow, but the description does not provide enough context to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any parameters. It does not clarify what catalog_id, entry_id, overrides, catalog_dir, output_path, visible, or close_after_save mean in context. The description adds no meaning beyond the schema's raw property names.

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

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

The description states a specific verb and resource: 'Create a supported spring from one resolved catalog entry.' It is clear that this tool creates a spring from a catalog entry, but it does not distinguish itself from sibling tools like create_compression_spring or preview_spring_from_size. The phrase 'supported spring' is somewhat vague about what kind of spring is created.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that the catalog entry must be resolved first, nor does it reference sibling tools like resolve_spring_size or preview_spring_from_size. An agent would not know the prerequisite workflow or when to choose this over create_compression_spring.

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

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

With no annotations provided, the description takes on the burden of disclosing behavior. It does disclose the default field set and the condition for engineering fields, which is useful. However, it omits other behavioral aspects such as whether an existing .spw file is overwritten, permission requirements, or the effect of omitting output_path.

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

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

The description is two concise sentences with the main action front-loaded and a clear conditions sentence. Every word earns its place, and there is no filler or redundant phrasing.

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 8 parameters, no annotations, no output schema, and 0% schema coverage, the description is not complete enough. It covers defaults and engineering conditions but leaves parameter semantics, output behavior, and return value unaddressed, making it difficult for an agent to call the tool correctly without additional information.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly explains the roles of 'columns' and 'include_engineering' via 'mapped by columns and opted in,' but six other parameters (style_id, document_id, layout_name, output_path, include_root, column_preset) receive no explanation. The description adds only minimal parameter meaning.

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

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

The description clearly states the action ('Create'), the resource ('.spw specification document'), and the source ('current model tree'). It also notes the default fields written, which helps distinguish it from sibling tools like create_specification that may target different output formats or scopes.

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

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

The description implies usage by specifying the default behavior and the condition under which engineering fields are included, but it does not explicitly state when to use this tool versus alternatives like create_specification or preview_spw_generation. No exclusions or alternative tool names are mentioned, leaving usage to inference.

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

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

With no annotations, the description carries the full burden. It states 'Delete' implying a destructive action, but doesn't disclose whether the deletion is permanent, undoable, requires confirmation, or affects dependent entities. No behavioral traits beyond the basic action are revealed.

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

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

The description is a single, concise sentence with no fluff. It front-loads the action and selection methods. Efficient, though it omits necessary details, so it's not perfect.

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

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

For a destructive tool with three optional parameters and no output schema, the description is underspecified. It doesn't explain selection semantics, error conditions, or side effects. An agent would likely need to probe the schema or guess to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by reference, index, or fingerprint' but doesn't map these to the actual parameters (entity, sketch_ref, document_id). The agent cannot derive how to populate these fields from the description 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 states a clear action (delete) and resource (sketch entity), and specifies selection methods (reference, index, fingerprint). This distinguishes it from sibling read-only tools like list_sketch_entities and inspect_sketch_entity, though it doesn't explicitly name them.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., must have a valid sketch entity) or exclusions (e.g., cannot delete if referenced elsewhere). The agent is left to infer usage context from the tool name alone.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It hints that deltas are bounded and that inputs can be payloads or paths, but it does not state whether the operation is read-only, how bounding is configured, or what effects ignore_keys, ignore_paths, and use_default_volatile_ignores have on the comparison.

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

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

The description is compact and front-loaded, with no filler words. It efficiently communicates the core operation and input types, though its brevity contributes to the missing behavioral and parameter context.

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

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

With no output schema, no annotations, six parameters, and no return-value documentation, the description leaves essential details unstated, such as delta structure, output formatting, and the exact semantics of 'bounded item deltas'. An agent would need to infer too much to invoke this tool confidently.

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

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

Schema description coverage is 0%, and the description adds no meaning for max_items, ignore_keys, ignore_paths, or use_default_volatile_ignores. The before/after parameters are evident from their names, but the filtering and bounding parameters are left entirely unexplained, so the description fails to compensate for the lack of 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 names a specific verb ('Compare') and a specific resource ('two readback snapshot/manifest payloads or JSON artifact paths'), and adds the qualifier 'with bounded item deltas', which clarifies the operation's scope. It differentiates this from a capture or verify operation, though it does not explicitly name sibling tools to fully disambiguate.

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

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

The description implies the usage context: comparing two snapshot/manifest payloads or JSON paths. However, it gives no explicit when-to-use vs when-not-to-use guidance and does not reference alternatives like verify_document_snapshot_delta, leaving routing to be inferred.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Search' implies a read operation, but the description does not clarify matching semantics, empty-query behavior, document scoping, or what result shape to expect.

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

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

The description is a single short sentence that is front-loaded with the core purpose. Every word earns its place and there is no redundant boilerplate.

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

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

For a tool with three optional parameters, no annotations, and no output schema, the description is too sparse. It does not specify document scoping or behavior on empty query, making it incomplete for reliable invocation by 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 0%, so the description must compensate, but it only explains 'text' and 'optional kinds.' The document_id parameter is omitted entirely, and no additional meaning is added beyond the schema's parameter titles.

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

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

The description states a specific action ('Search items') and the core filter mechanism ('by text and optional kinds'), which is more than a tautology. However, the resource 'items' is ambiguous and the description does not distinguish find_items from siblings like get_items or list_document_tree.

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

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

There is no guidance about when to use find_items versus alternative lookup tools such as get_items or document-scoped searches. The description implies text-based search but gives no exclusions, prerequisites, or selection criteria.

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

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

With no annotations, the description carries the full burden. It doesn't state whether this is read-only, whether it returns a list or a single entry, how multiple filter parameters combine (AND/OR), or the role of the limit parameter for pagination. The description only says 'find' without disclosing any behavioral details.

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

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

The description is a single, efficient sentence that front-loads the action. It is appropriately concise with no wasted words or redundancy.

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

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

Given 14 parameters, no annotations, and no output schema, the description is severely under-specified. It doesn't explain return format, pagination via limit, parameter semantics, or relationship to sibling tools. An agent would need to infer too much to call this 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?

Schema coverage is 0%, so the description must compensate by explaining parameters. It mentions 'type, size, class, tag' but doesn't map these to specific schema fields like spring_type, load_class, or the various dimension parameters. It adds minimal value over the raw schema, which itself has no 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 finds spring catalog entries and mentions filter criteria (type, size, class, tag). It distinguishes from sibling tools like recommend_spring_sizes by implying a direct lookup rather than a recommendation. However, 'size' and 'class' are vague and could map to multiple parameters.

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

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

No guidance is provided on when to use this tool versus alternatives like recommend_spring_sizes or resolve_spring_size. The description doesn't mention any exclusions, prerequisites, or conditions for selection, leaving the agent to guess which tool fits a given request.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Read', implying read-only behavior, but does not disclose that it returns bounded results (max_items), whether it requires an active document (require_active_document defaults true), or what the 'primitive operation pipeline' involves. This is minimal behavioral disclosure.

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

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

The description is a single concise sentence, but it wastes its brevity on the opaque phrase 'primitive operation pipeline' instead of explaining the tool's actual behavior. It is not verbose, but the short length does not compensate for the jargon and missing 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 five parameters, no output schema, no annotations, and no parameter descriptions, this one-liner is severely incomplete. It does not describe return values, parameter roles, or the meaning of 'bounded state', leaving the agent unable to call this tool confidently in most scenarios.

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

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

The schema has 0% description coverage and the description adds no parameter semantics. None of the five parameters (max_items, document_id, include_tree, include_items, require_active_document) are explained. The word 'bounded' hints at max_items but is too vague to count as meaningful 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 states a verb and resource ('Read bounded active-document state') but the modifiers 'bounded' and 'primitive operation pipeline' are undefined jargon. It does not distinguish this from sibling tools like get_document_tree, get_items, or get_session_state, which also read document/session state.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that it is for the active document, how it relates to get_document_tree or get_items, or any conditions for choosing it. With a large sibling list, this is a significant omission.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation but does not explicitly state that it is non-destructive, what happens when no document is active, or what the return value contains. The minimal description offers little beyond the verb 'read'.

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

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

A single sentence that is direct and front-loaded with the core action. No wasted words; the description is appropriately sized for the simplicity of the tool.

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

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

Given no output schema and no annotations, the description should clarify what 'composition' means, the return format, and potential error cases. It also fails to differentiate itself from get_file_composition. The description is too sparse to fully inform an agent for correct invocation.

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

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

The schema has zero description coverage, so the description must explain the parameter. It implies that document_id is optional and that when omitted, the selected or active document is used. This adds meaning beyond the schema, but does not clarify the parameter's type or format, leaving 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 reads the stored composition of a document, using a specific verb and resource. It distinguishes from siblings like get_file_composition by mentioning 'document' vs 'file', though 'composition' remains somewhat vague without context.

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

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

No guidance on when to use this tool versus alternatives like get_file_composition or get_document_tree. The description does not mention any prerequisites, selection rules, or scenarios where this tool is preferred.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation ('Return') but does not explicitly state it is read-only, nor does it describe potential side effects, performance characteristics, or error behavior. It also does not clarify what happens when document_id is null (though 'selected or active' hints at it). This is a significant gap given the lack of annotation support.

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

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

The description is a single, efficient sentence that front-loads the action and resource. Every word earns its place, and there is no filler. It is appropriately sized for a simple read operation.

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

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

For a simple tool with one optional parameter and no output schema, the description is adequate but not complete. It does not describe the structure of the returned tree, what nodes are included, or how errors are handled. Since there is no output schema, the description would need to provide this context for an agent to fully understand the result, but it remains minimal. It is sufficient for a basic call but lacks depth for robust decision-making.

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

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

The schema provides no description for the single parameter, document_id, and coverage is 0%. The description compensates by explaining the parameter's role: 'selected or active document' implies that omitting document_id uses the active document, while providing it selects a specific one. This adds meaning beyond the bare schema and effectively clarifies the optional 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 clearly states a specific verb ('Return') and resource ('assembly/model tree'), and clarifies the scope ('selected or active document'). It is unambiguous about what the tool does, though it does not explicitly distinguish it from sibling tools like get_document_composition or get_file_composition, which could be similar in 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 provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It simply states what it returns. An agent is left to infer that this is the tool for retrieving a tree structure, but there is no explicit routing or comparison to siblings.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does indicate a read-only operation ('Read') and that it accesses the file directly, which is useful, but it does not describe what the returned 'composition' includes, potential failure modes (e.g., missing file, unsupported format), or whether any session state is affected. This is incomplete for an unannotated tool.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the tool's purpose and mechanism. It is appropriately concise for the tool's simplicity.

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

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

Although the tool is simple (one parameter, no output schema, no annotations), the description does not fully cover what an agent needs to invoke it confidently. It omits usage guidance, output semantics, and error handling. The phrase 'stored composition' is vague and could mean different things depending on the file system context.

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

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

The schema provides no description for assembly_path (0% coverage), so the description must compensate. The only added meaning is that the path refers to an 'assembly file,' but it does not clarify path format, file type expectations, relative vs absolute paths, or any constraints. This falls short of compensating for the missing 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 states a specific verb ('Read'), a resource ('stored composition of an assembly file'), and a distinguishing mechanism ('directly from the file itself'). This makes it clear the tool reads from the file rather than the in-memory document, which differentiates it from the sibling get_document_composition. However, it does not explicitly name any sibling, so it lacks full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like get_document_composition or scan_model_files. No conditions, exclusions, or alternative tools are mentioned, leaving the agent to infer context from the name and description alone.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Return a practical properties snapshot' without indicating whether the operation is read-only, what happens if items are missing, performance implications, or any side effects. The behavior is effectively undisclosed.

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?

While the description is a single short sentence, it is under-specified rather than concisely informative. It conveys no more than the tool name already implies, which is wasteful for an agent trying to understand the tool's behavior.

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

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

Given two optional parameters, no output schema, no annotations, and a large sibling set, the description is drastically insufficient. It does not explain the nature of 'items', the output format, when items are 'selected', or how document_id affects results. An agent cannot reliably call this tool correctly from this description alone.

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

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

Schema description coverage is 0%, and the description does not mention the parameters (`item_ids`, `document_id`) at all. It gives no hint of what these inputs mean, how they interact, or which combinations are valid. It completely fails to compensate for the schema gap.

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

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

The description uses a clear verb ('Return') and identifies a resource ('properties snapshot for selected items'), but 'items' is ambiguous — it could refer to sketch entities, features, or document elements. It does not explicitly distinguish this from sibling tools like 'get_items' or 'inspect_sketch_entity', which likely have overlapping scopes.

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

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

There is no guidance on when to use this tool versus alternatives. No conditions, exclusions, or context are provided. The agent has no basis to choose this over 'get_items', 'inspect_sketch_entity', or other read-oriented 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It implies a read-only retrieval of current properties, but it does not mention side effects, permission needs, error behavior, or the scope of the returned items. It does not contradict annotations because none exist.

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

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

The description is a single front-loaded sentence with no redundant wording; every word contributes. It is concise but sacrifices necessary detail, so it does not quite reach the highest bar.

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

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

This tool has no annotations, no output schema, and 0% parameter schema coverage, yet the description explains none of the parameters, return shape, or selection semantics. An agent would not have enough information to choose or invoke this 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?

Schema description coverage is 0%, so the description must compensate by explaining item_ids and document_id. It does not mention either parameter, and 'selected tree items' only vaguely hints at item selection without clarifying how the parameters map to the call.

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

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

The description uses a clear verb ('Return') and names the resource ('tree items with their current properties'), so it is not a tautology. However, 'selected' is ambiguous, and the description does not distinguish this tool from close siblings like get_item_properties, find_items, or get_document_tree.

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

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

There is no guidance on when to use this tool versus alternatives such as get_item_properties or find_items. The description does not explain what 'selected' means, whether item_ids or document_id are needed, or what conditions favor this tool.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses the key behavioral trait: research tools are excluded unless explicitly opted in. However, it doesn't describe the return format, pagination, or what 'explicit opt-in' means operationally (e.g., whether include_research=true is the opt-in mechanism). The description adds some value but leaves the opt-in mechanism to be inferred from the schema.

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

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

A single sentence with zero waste. The core action ('Return the public tool catalog') is front-loaded, and the critical behavioral caveat ('research tools require explicit opt-in') is appended in the same breath. Every word earns its place.

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

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

For a simple catalog-listing tool with 3 optional parameters and no output schema, the description is mostly adequate. The main gap is that it doesn't explain what 'category' and 'stability' filter on, and it doesn't clarify the return shape. Given the tool's low complexity, this is a minor-to-moderate gap, so a 3 is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by explaining the 'include_research' concept ('research tools require explicit opt-in'), which maps to the include_research parameter. However, it doesn't explain the 'category' or 'stability' parameters at all, and with 0% schema coverage, the agent must guess at their semantics. The description adds some meaning but doesn't fully compensate for the coverage gap.

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

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

The description states a specific verb ('Return') and resource ('public tool catalog'), and adds a scoping qualifier ('public') that distinguishes it from research-oriented catalog tools. It doesn't explicitly name a sibling alternative, but the qualifier plus the 'research tools require explicit opt-in' clause gives enough differentiation from the many 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 implies when to use this tool: when you need the public catalog, and it warns that research tools are not included unless explicitly opted in. It doesn't name a specific alternative tool, but the opt-in warning effectively tells the agent not to expect research tools here and to look elsewhere or pass include_research=true. This is clear context without 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'returns' information, implying a read-only operation, but does not explicitly confirm lack of side effects. It also does not describe what 'basic information' includes, error behavior, or any session-related constraints. The disclosure is minimal and leaves key traits unspecified.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It efficiently states the tool's purpose and is appropriately sized for a parameterless getter.

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

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

The description is adequate for a simple getter, but since there is no output schema, it could provide more detail on what 'basic information' includes (e.g., session ID, status, or document references). The tool is simple enough that a 3 is fair, but it leaves room for more useful context.

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

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

The tool has zero parameters and the schema coverage is 100% (vacuously). With no parameters, the description does not need to explain parameter semantics; the baseline score of 4 is appropriate since there is nothing to clarify.

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

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

The description clearly states a specific verb ('Return') and resource ('basic information about the current KOMPAS session'), making the tool's purpose unambiguous. However, it does not explicitly distinguish itself from sibling state-related tools like get_active_document_state or get_document_tree, so it's clear but not fully differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives. Given the large set of sibling tools, an agent has no information about whether to call this or get_active_document_state, for example. There is no mention of context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It says 'Read' which implies a non-destructive operation, but it doesn't disclose what 'active or selected' means, how selection is determined, whether the operation can fail (e.g., no active document), or what happens with the max_objects limit. For a read tool with no annotations, this is a moderate gap.

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

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

The description is a single sentence that is concise and front-loads the core action ('Read the active or selected specification description'). It doesn't waste words, though it could add a bit more detail without becoming bloated.

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

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

With 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is too thin. An agent doesn't know what 'active or selected' means, how the parameters interact, or what the return structure looks like. Sibling tools like get_specification_descriptions suggest a related but different operation, and the description doesn't clarify the distinction.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'objects and columns' which maps to include_objects and possibly description_index, but it doesn't explain document_id, layout_name, max_objects, or description_index semantics. The description adds minimal value beyond the schema's parameter names.

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

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

The description states a clear verb ('Read') and resource ('specification description with its objects and columns'), which distinguishes it from sibling tools like get_specification_descriptions (which likely only lists descriptions) and create_specification. However, it doesn't explicitly name a sibling or contrast itself, so it's clear but not fully differentiated.

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

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

The description implies usage: call this when you need the active or selected specification's full content (objects and columns). It doesn't explicitly state when not to use it or mention alternatives like get_specification_descriptions for just the list of descriptions. The context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It states the operation is a 'List', which implies a read-only, non-mutating behavior, and that it returns available descriptions, but it does not disclose details such as output format, behavior on missing document, or error cases. This is minimal but not misleading.

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

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

A single sentence with no extraneous words. It is front-loaded with the verb and immediately states scope.

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

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

For a tool with one optional parameter and no output schema, the description is adequate but leaves the meaning of 'specification descriptions' ambiguous. It does not explain what a description is, how the list is returned, or how this relates to the broader specification workflow. Given the simple read-only nature, this is a moderate gap.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'document_id' parameter. The phrase 'selected or active document' suggests that a null document_id resolves to the active document, adding meaning beyond the schema's type and default. However, this is implied rather than explicit.

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

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

The description uses a specific verb ('List') and resource ('specification descriptions') and scopes it to the selected or active document. It is clear enough to distinguish from the sibling 'get_specification' by the word 'descriptions', but it does not explicitly name alternatives or exclusions, so it does not fully meet the 5-level bar.

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

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

The description provides a contextual condition ('selected or active document') that implies when the tool applies, but it offers no guidance on when to prefer this over siblings like 'get_specification' or 'preview_specification_generation'. This is implied usage, not explicit when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Inspect' which implies a read-only operation, but it does not state whether the operation is non-destructive, what it returns, whether it can fail (e.g., if the feature is not found), or any side effects. For a read tool, the lack of return-format or error behavior disclosure is a notable gap.

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

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

One sentence, front-loaded with the verb and resource, and it lists the selection methods compactly. No wasted words.

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

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

For a tool with no annotations, no output schema, and a vague input schema, the description is too thin. It does not explain what 'inspect' returns, how the selection methods are expressed in the 'feature' parameter, or what document_id is for. An agent would likely need to open the schema (which is unhelpful) or guess. The sibling list shows related inspection tools, but the description does not position itself among them.

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

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

Schema description coverage is 0%, and the schema itself is weak: 'feature' is an untyped object with additionalProperties true, and 'document_id' is a nullable string. The description mentions selection by reference, index, fingerprint, or name, which maps to the 'feature' parameter, but it does not explain how these selectors are structured or how document_id relates to them. The description adds some meaning but does not compensate for the schema's lack of detail.

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

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

The description states a specific verb ('Inspect') and resource ('one existing 3D feature'), and lists four selection methods (reference, index, fingerprint, name). It is clear what the tool does, though it does not explicitly distinguish it from sibling tools like list_features or inspect_sketch_entity. The phrase '3D feature' helps differentiate from sketch entities, but the description could be more explicit about how it differs from list_features.

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

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

The description implies usage: call this when you need to inspect an existing 3D feature, selected by one of four identifiers. It does not state when not to use it or name alternatives (e.g., list_features for enumerating features, inspect_sketch_entity for sketch entities). The context is clear enough for an agent to infer the primary use case, but explicit routing guidance is missing.

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

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

With no annotations, the description carries the behavioral burden. 'Inspect' communicates a read-only operation and 'existing' hints at failure modes for invalid selections, but it does not disclose what information is returned or whether any session state is affected. This is partial but insufficient disclosure.

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

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

One sentence with no padding; the core verb and object are front-loaded. Every phrase adds a constraint: one, existing, and selection mode.

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

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

With no output schema and no annotations, the description does not explain what an inspection returns, how the three optional parameters interact, or what errors may occur. The tool's call contract is underspecified for reliable agent use.

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

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

Schema description coverage is 0%, so the description must compensate. It hints that selection can be by reference, index, or fingerprint, but never maps those modes to the actual parameters (constraint, sketch_ref, document_id) or explains how the optional parameters combine. The agent is left guessing.

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

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

The description clearly identifies the action (inspect), the resource (one existing sketch constraint), and the selection modes (reference, index, fingerprint). This distinguishes it from list_sketch_constraints and inspect_sketch_entity without needing to name them explicitly.

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

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

No guidance is given on when to use this tool versus alternatives like list_sketch_constraints or inspect_sketch_dimension. There are no prerequisites, exclusions, or contextual hints beyond the implication that the constraint must already exist.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Inspect' implies a read-only operation with no modification, and 'existing' suggests it operates on already-created dimensions, but the description does not explicitly state that no changes are made, what is returned, or how selection failures are handled. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the core action and selection options, though a bit more structure or clarification of parameters would improve usefulness without harming 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?

For a tool with three undocumented optional parameters and no output schema, the description is too sparse. It omits parameter semantics, return behavior, error cases, and guidance on how the selection modes relate to the input schema. The presence of many sketch-related siblings increases the need for more context to prevent misuse.

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

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

Schema description coverage is 0%, and the description only vaguely mentions 'reference, index, or fingerprint' without mapping these concepts to the three parameters (dimension, sketch_ref, document_id). The description adds minimal meaning beyond the raw parameter names, and the agent is left without guidance on how to populate or combine these optional fields.

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

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

The description clearly identifies the verb ('inspect'), the resource ('sketch dimension'), and adds selection modes ('reference, index, or fingerprint'), which separates it from generic inspection tools. It does not explicitly distinguish itself from close siblings like list_sketch_dimensions or inspect_sketch_constraint, but the singular 'one existing sketch dimension' provides reasonable scoping.

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

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

The phrase 'one existing sketch dimension' implies this is for individual inspection rather than listing, but no explicit alternative or when-not-to-use guidance is provided. The intended use case is inferable from the name and description, but the description does not clearly state when to prefer this over list_sketch_dimensions or inspect_sketch_entity.

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

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

With no annotations, the description carries full burden. 'Inspect' implies a read-only operation but does not explicitly state it is non-destructive, what happens if the entity is not found, or any side effects. Missing critical behavioral disclosure.

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

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

A single sentence with no filler. The core action and object are front-loaded. It is efficiently concise, though brevity contributes to incompleteness.

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

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

For a tool with 3 parameters, no output schema, and no annotation coverage, this description is severely inadequate. It lacks parameter explanations, return value description, and usage context, making it impossible for an agent to correctly invoke the tool without external knowledge.

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

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

Schema coverage is 0% and the description does not explain what the three parameters (entity, sketch_ref, document_id) mean. It mentions 'by reference, index, or fingerprint' but does not map these to the parameters, leaving the agent without any semantic 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 states a specific action ('Inspect') on a specific resource ('one existing sketch entity') and indicates selection methods. It distinguishes from siblings like list_sketch_entities and inspect_sketch_full, though it doesn't explicitly name them.

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

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

No guidance on when to use this tool vs alternatives. It doesn't mention prerequisites like listing entities first, how to obtain a reference, or when to prefer inspect_sketch_full. No exclusions or contextual hints.

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?

Even though no annotations are provided, the description discloses substantial behavioral detail: it reads dimensions and constraints via API5, includes COM/API5 diagnostic blocks, can include begin-edit fallback data, and explains status code meanings. It also describes the shape of returned geometry, constraint links, and projection classifications, which goes far beyond what annotations would convey.

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

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

The description is front-loaded with a one-sentence summary and then organized into Parameters and Returns sections. Though detailed, every sentence provides necessary operational or return-structure information for a complex inspection tool, with no filler or redundancy.

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

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

For a six-parameter tool with no output schema, the description covers all inputs and every part of the return payload, including status codes, entity geometry formats, constraint owner/partner links, and diagnostic content. An agent has enough detail to invoke the tool correctly and interpret its results; only explicit sibling-selection guidance is absent, which is already covered under usage guidelines.

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

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

The input schema provides only names, types, and defaults, with 0% description coverage. The tool description fully compensates by explaining each parameter's purpose and effect, including document_id None meaning the active document, the 22 constraint types enumerated, what include_diagnostics adds, and that max_items caps entities per collection.

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

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

The description opens with 'Full dump of an existing sketch: entities, dimensions, constraints, status,' which names a specific verb, resource, and scope. 'Full dump' distinguishes this from sibling tools that inspect individual entities or list only one category of sketch data, so the tool's purpose is immediately clear.

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

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

The description implies the tool should be used when a complete sketch inspection is needed, but it does not explicitly state when to prefer it over list_sketch_entities, inspect_sketch_entity, list_sketch_dimensions, or list_sketch_constraints. There is clear context about what it does, but no mention of alternatives or exclusion conditions.