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

With no annotations, the description carries the full burden and does so richly: it declares units (metres), that the whole plan is one undo step, that corners are auto-lengthened/trimmed, that errors equal wall thickness if 'ref' is misused, and that the reply reports built size and skipped openings. This is the kind of behavioral context an agent could not infer 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?

Front-loaded with the purpose, then the dense but necessary spec example. Every block (units, ref rules, corner trimming, undo/reply) earns its place, though the length is substantial and a couple of clauses could be tightened. Appropriate sizing for a complex nested-spec 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 a one-parameter nested object with zero schema coverage and rich output schema, the description supplies everything needed: the full spec contract, defaults, geometric conventions, and follow-up verification steps. Return values are not over-explained since an output schema exists.

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 single 'spec' parameter is an opaque nested object, yet the description fully compensates with a commented example covering defaults, per-wall overrides, opening rules, sill-based door/window inference, the 'infill' flag, 'material' values, 'ref' semantics, and 'extend' behavior. No ambiguity remains for calling it 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?

States a specific verb and resource: turns a floor-plan spec into 3D walls, doors, windows and a slab with tags and materials. This clearly distinguishes it from siblings like create_component, transform_component, and set_material, which operate on existing geometry rather than generating a whole floor.

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

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

Gives clear downstream context ('read the reply, then call verify_dimensions and look at export_scene(format="png")') and prescribes which 'ref' convention to use depending on how the plan is dimensioned. It stops short of explicit when-not-to-use or alternative-input guidance, but the workflow context is genuinely actionable.

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

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

With no annotations, the description carries the full burden and does well: it discloses that segments are summed and compared to the overall dimension, that units are metres, that no SketchUp session is needed, and gives an explicit conflict-handling rule ('show the user which one and ask which number wins; do not guess'). It never states whether it mutates anything, though the read-only nature is strongly implied by 'check'.

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?

Front-loaded with the core purpose, followed by a compact example and behavioral rules. Every element earns its place, though the conflict-handling sentence sits slightly apart from the rest of the flow.

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?

An output schema exists, so return values need no explanation. Combined with the explicit pre-modelling timing, units, dependency note, and conflict policy, the agent has enough to invoke it correctly. The only real gap is the undocumented tolerance parameter.

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 compensates for the required 'chains' parameter by showing the exact object shape (label, segments, total) and units. The optional 'tolerance' parameter (default 0.005) is never mentioned, so the coverage gap is only partially filled.

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

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

States a specific verb and resource: 'Check that the dimension strings on a plan add up,' with a worked example showing the chain structure. The purpose is unambiguous. It does not, however, distinguish itself from the sibling verify_dimensions, which an agent could reasonably confuse with it.

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

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

Gives a clear temporal precondition ('BEFORE modelling') and notes it 'Does not need SketchUp,' which tells the agent this is a pure computation independent of the live model. It does not name an alternative tool or state when NOT to use it, so it stops short of the 5 tier.

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 delivers genuinely useful, counterintuitive behavior: a cube at z=0 extrudes downward, and cylinder position is the bounding-box corner rather than the centre. It does not address persistence, undo, or what the created group contains beyond the primitive.

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?

Front-loaded purpose followed by the non-obvious unit and geometry caveats, then the alternative-tool pointer. Sentences are dense but each earns its place; the parenthetical layout is slightly cramped but readable.

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

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

An output schema exists, so return values need no explanation, and the description covers the tricky geometry semantics an agent could not infer. The remaining gap is which shape/position combinations are valid or what happens with an omitted position.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it fixes the unit (inches), enumerates the type values, and defines the dimensions array per shape ([diameter, ignored, height] for cylinders). It leaves sphere/cone dimension ordering and the null-default meaning of position/dimensions 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 verb and resource — 'Create a primitive (type: cube, cylinder, sphere, cone) as a group' — and enumerates the supported types. It does not directly differentiate itself from the geometry-oriented siblings (transform_component, build_floor_plan), though the eval_ruby mention hints at its niche.

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

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

Explicitly routes heavy modelling work away from this tool: 'For real modelling work prefer eval_ruby.' That names the alternative and the condition selecting it. It stops short of saying when this tool IS the right choice versus transform_component or build_floor_plan.

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 that the tool deletes a component, but does not disclose whether deletion is irreversible, whether child or related components are also removed, what permissions are required, or what side effects occur.

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

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

The description is a single, front-loaded sentence with no filler or redundant elaboration. Every word contributes to understanding the tool's core function.

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

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

For a simple one-parameter tool with an output schema, the description is minimally adequate for basic invocation. However, because it is a destructive operation and annotations are absent, the lack of information about irreversibility or cascading effects leaves a meaningful completeness 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. The phrase 'by ID' does add some meaning by indicating that the required id parameter identifies the component to delete, but it does not explain the ID format, where to obtain it, or any constraints on its value.

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

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

The description clearly states a specific verb (delete), the resource (component), and the identifying mechanism (by ID). It is also easily distinguished from sibling tools, none of which perform deletion.

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

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

No guidance is given for when to use this tool versus alternatives, nor are prerequisites mentioned such as needing a valid existing component ID or whether the component must be selected. The usage context is only implied by the tool name and description.

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

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

With no annotations, the description carries the full burden and discloses useful behavioral traits: it returns the last expression as a string, warns of a ~15-second timeout, and requires transaction wrapping and an audit check. It does not explicitly warn that arbitrary Ruby code executes with full model privileges and can be destructive, which is a notable omission for a code-execution tool.

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

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

The description is front-loaded with the core action and return format, followed by a structured bullet list of rules. It is somewhat long but every bullet addresses a real failure mode, so the length is largely earned.

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 high-complexity code-execution tool, the description covers return value, timeout, required transaction pattern, geometric pitfalls, element creation, and completion criteria. With an output schema present, return values need not be explained further, though error behavior and security implications are omitted.

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

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

The single 'code' parameter has 0% schema description coverage, so the description must compensate, and it does so richly: units must be written as 3.m, 150.mm, etc., edits must be wrapped in operations, and the last expression should be a short summary string. This adds substantial domain-specific meaning beyond the bare string 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?

States a specific verb, resource, and environment: 'Run Ruby code inside SketchUp (full SketchUp Ruby API)' and return the last expression. It explicitly identifies itself as 'the main modelling tool,' distinguishing its role from siblings like build_floor_plan or create_component.

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

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

It gives clear usage context by calling itself the main modelling tool and provides several required patterns such as wrapping edits in start_operation/commit_operation and ending with SU_MCP.audit_model. However, it does not explicitly compare itself to sibling tools or state when an agent should prefer a specialized tool over raw Ruby.

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 does disclose meaningful behavior: the file lands in sketchup_exports inside %TEMP% and the full path is returned in content[0].text. It omits overwrite behavior (does exporting to an existing name replace it?) and any permission constraints, keeping it from a 5.

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

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

Two short sentences (plus the format list), front-loaded with the action, then the output location, then the png hint. Every clause carries distinct information and nothing is padded.

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?

An output schema exists, yet the description still pinpoints where the return path appears (content[0].text), and it covers format selection and file destination. For a single-parameter export tool this is fully sufficient.

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

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

Schema coverage is 0% and the schema defines format only as a bare string, so the description's list of valid values (png, jpg, skp, obj, dae, stl) is a real addition the schema lacks. It doesn't state the default skp that the schema declares, but the enum enumeration is the key information an agent needs.

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

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

States a specific verb and resource ('Export the current model') and enumerates the accepted formats, which lets an agent distinguish it immediately from the sibling manipulation tools (transform_component, set_material, etc.). No sibling does exporting, so the scope is unambiguous.

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

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

Gives a concrete use case for one format ('Use format='png' to get a screenshot of the current view so you can check the model visually'), which tells the agent when PNG is the right choice. It stops short of naming when-not to export or which sibling to prefer for in-SketchUp inspection.

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 burden. It conveys that the operation is a read ('List') and hints at the return shape (id, type, bounds), but says nothing about what happens with an empty selection, whether it requires an active model, or any ordering/limits.

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; the resource and its scope ('currently selected') are stated first, and the trailing field list adds useful detail without padding.

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

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

An output schema exists, so return-value documentation is already covered, and with zero parameters this is a simple read tool. The description is sufficient, though a note about the active-model prerequisite or empty-selection behavior would make it fully complete.

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

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

There are zero input parameters, so the baseline is 4. The parenthetical '(id, type, bounds)' describes output fields rather than parameters, which is harmless but not additive to 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?

States a specific verb (List) and resource (entities the user currently has selected in SketchUp), and even previews the returned fields. It is immediately distinguishable from all siblings (which mutate, export, or evaluate), but it doesn't explicitly name a sibling to differentiate against, so 4 rather than 5.

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

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

The phrase 'currently has selected' implies the usage context (inspecting the live selection), but there is no explicit when-to-use, prerequisite (e.g. an open model), or alternative guidance. Adequate but with clear gaps.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the closed set of valid colour names, which is real behavioral information, but it says nothing about what happens to an existing material on the entity, whether the change is reversible, or any permission requirements for a write 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?

Two short sentences with the core action front-loaded and the enumeration plus escape hatch following. Every element (verb, resource, valid values, alternative) earns its place with no filler.

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

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

An output schema exists, so return values need not be described. The description adequately covers the constrained mutation and its escape hatch; the only meaningful gap is the unexplained id parameter and the absence of any note on how existing material is handled.

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 schema gives only bare names. The description fully illuminates the "material" parameter by listing valid values and the fallback path, but the "id" parameter is never explained (which entity, what identifier format), leaving half the parameters 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?

States a specific verb and resource ("Paint an entity") plus the constrained input domain (a named colour), so an agent knows exactly what operation this is. It does not explicitly contrast itself with siblings like create_component or transform_component, but the purpose is unambiguous.

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

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

Explicitly enumerates the accepted names and routes the agent to the alternative tool (eval_ruby with Sketchup::Color.new) for any colour outside that set. This is a clear when-to-use / when-to-use-something-else statement naming the sibling by 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 full disclosure burden. It usefully reveals that position is a RELATIVE translation added to the current position (not an absolute target) and that rotation is in degrees, which is real behavioral value. However, it omits scale semantics, units for scale, and whether omitted parameters leave the entity unchanged.

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?

Front-loaded with the action, then parameter clarifications in short sentences. The emphasis on RELATIVE is justified because it prevents a costly misuse, though the sentence fragmentation is slightly awkward.

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?

An output schema exists so return values need not be described, and the critical relative-position semantics are covered. Still, for a mutation tool with no annotations and 0% schema coverage, the missing scale semantics and the behavior of unspecified optional parameters leave a real 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. It documents position (relative, inches) and rotation (degrees) but says nothing about scale or the meaning/format of id, leaving two of four 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?

States a specific verb set and resource: move, rotate, or scale an entity by ID. This clearly separates it from siblings like create_component, delete_component, and set_material.

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 versus alternatives such as create_component or delete_component, and no prerequisites or constraints stated. The agent must infer usage entirely from the 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?

With no annotations, the description carries the full behavioral burden and does well: it discloses that clear distances are measured between wall faces, that doors, glass, and furniture are ignored, that openings won't fool it, and that each line returns OK or SELISIH with a mm difference. It omits behavior of the tolerance parameter (default 0.005), which governs pass/fail, leaving a gap for a mutation-adjacent verification 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?

Purpose is front-loaded in the first sentence, followed by structured examples that each carry necessary format information. Slightly long, but almost every line earns its place; no filler.

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

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

For a tool with a complex nested check format, an output schema present, and no annotations, the description is nearly complete: it defines inputs, behavior, and the OK/SELISIH result form. The only real omission is the tolerance parameter's role in deciding OK vs SELISIH.

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 'checks' array is free-form with no item schema, so the description must compensate, and it does extensively by documenting three check shapes and their fields (label, overall, expected, at, axis, building, floor, z). The tolerance parameter is never explained, so compensation is strong but incomplete.

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

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

States a specific verb+resource ('Measure the model in SketchUp and compare it with the plan') and frames the output as an accuracy report. It is clearly distinguishable from siblings like build_floor_plan and check_dimension_chains by naming the measurement-vs-plan comparison task.

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

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

Gives explicit sequencing ('Run this after build_floor_plan with the key dimensions from the plan, fix what differs, and pass the report on to the user'), which is strong when-to-use guidance. It does not, however, contrast against the closely related check_dimension_chains sibling, so no exclusion guidance is offered.

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