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

With no annotations, the description fully discloses behavioral traits: the effect of operations on shared definitions, unreliability on non-manifold geometry, and the return format including how to interpret null bbox_mm for empty results. No contradictions.

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

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

The description is well-structured with the core purpose first, followed by clarifications and return details. Every sentence adds value, and there is no redundancy or wasted text.

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

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

Given the tool's complexity (4 parameters, one enum, no annotations), the description covers essential behavioral aspects and return format. It lacks detailed error conditions or prerequisites but is sufficient for most use cases.

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

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

All four parameters are fully described in the input schema (100% coverage). The description adds extra context beyond the schema, such as the special behavior on instances and the meaning of the difference operation, enhancing 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 'Perform a boolean operation (union / difference / intersection) on two solids', specifying the verb, resource, and operation types. It uniquely identifies this tool among siblings as no other tool offers boolean operations.

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

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

The description provides clear context on when to use the tool, including the difference operation semantics and behavior on shared definitions. However, it does not explicitly state when not to use it or suggest alternatives, although no alternatives exist among siblings.

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

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

With no annotations provided, the description carries full burden. It discloses the modification behavior (chamfering edges), notes unreliability on non-manifold geometry, and details the return value, including stats to check for failures. However, it does not explicitly mention destructiveness or undo 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 concise, with the main action stated first. The return value description is slightly verbose but structured with a clear format. Overall, it is efficient and avoids unnecessary 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?

Considering the tool's simplicity (2 parameters, output schema), the description covers key behaviors, default, reliability note, and return value. It does not compare with the sibling tool fillet_edge, but the context is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minimal extra meaning beyond the schema: it reiterates that 'distance' is in mm and that 'id' is an entity ID from a previous response. No additional parameter details or constraints are provided.

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 (chamfer/bevel), the resource (edges of a group/component), and the key parameter (distance in mm). It distinguishes the tool from siblings like fillet_edge (rounding) and boolean_operation by specifying the bevel operation.

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

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

The description explains default behavior ('By default ALL edges are chamfered') and warns about unreliability on non-manifold geometry, providing context for when to use the tool. However, it does not explicitly state when not to use it or compare it to alternatives like fillet_edge.

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 provided, so the description fully covers behavioral traits: units (mm), minimum dimensions per type, position as MIN corner, per-type dimension conventions, return value details, and suggestion to verify with bbox_mm. Thorough 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?

Multiple sentences but each adds essential detail without redundancy. Well-structured: purpose, units, size constraints, anchor point, per-type dimension mapping, Group wrapping, return value and verification advice. Efficient and front-loaded.

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

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

Given 100% schema coverage and presence of output schema, the description provides all necessary context: explains param nuances (ignored axis for cylinder/cone), behavioral constraints, and return format. No gaps for a primitive creation tool.

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

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

Schema description coverage is 100% (baseline 3), but description adds significant value: minimum sizes (0.1mm cube, 1.0mm sphere/cylinder/cone), clarifies that dimensions are interpreted differently per type (e.g., cylinder [0]=diameter, [2]=height), and reinforces that position is MIN corner.

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

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

Clearly states it creates a primitive (cube/cylinder/cone/sphere) in SketchUp and that geometry is wrapped in a Group. Distinguishes from transform_component by noting shared anchor convention, and from sibling creation tools by specifying primitive types.

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

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

Provides clear instructions on when to use (to create primitives) but does not explicitly state when not to use or compare to alternative creation tools like create_dovetail or create_finger_joint. However, it references transform_component for positioning, offering some 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 exist, so the description carries full burden. It explains the return JSON structure, warns about non-manifold geometry causing failed cuts, and advises verifying via bbox_mm, but lacks side-effect 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 three sentences plus a bullet, front-loading the core purpose with no wasted words, perfectly sized for quick comprehension.

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

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

Covers prerequisites, return structure, and unit context. For 10 parameters with full schema coverage and output schema, this is sufficient, though it could mention that the operation creates geometry.

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

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

Schema coverage is 100%, providing baseline 3. The description adds context beyond schema by specifying that dimensions are in mm, angle in degrees with valid range, offsets shift from board face center, and defaults suit ~100mm boards.

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

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

The description clearly states it creates a dovetail joint between two boards, with specific details on units, angle range, offsets, and defaults, making the purpose unmistakable.

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

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

It provides a prerequisite (boards must touch/overlap along joint axis) but lacks guidance on when to use this tool versus siblings like create_finger_joint or create_mortise_tenon.

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?

Without annotations, the description carries full burden. It discloses the return JSON structure, explains failure modes (non-manifold geometry via boolean_cuts.failed), and advises verification via bbox_mm. It also notes offsets shift from board face center and default sizes. Could further clarify if operation is reversible, but overall good.

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

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

The description is concise: a clear purpose statement, a compact paragraph of key details, and a structured return description. Every sentence contributes meaning, no redundancy.

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

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

Given the tool's complexity (9 params, output schema, no annotations), the description covers prerequisites, parameter interpretation, and failure modes concisely. It could include an example or more guidance on selecting board IDs, but the output schema reduces the need for return value details.

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

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

Input schema has 100% description coverage, so baseline is 3. The description adds value by stating all dimensions are in millimeters, explaining offsets shift from board face center, and noting defaults are sized for ~100 mm boards. This contextualizes the parameters beyond their individual schema descriptions.

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

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

The description clearly states it creates a finger joint (box joint) between two boards, using specific verbs and resource. It names the joint type, which distinguishes it from sibling tools like create_dovetail and create_mortise_tenon.

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

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

The description provides clear context: boards must already touch/overlap along the joint axis. However, it does not explicitly guide when to use this tool versus alternatives, such as dovetail or mortise-tenon, though the naming makes it implicit.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states the tool creates a layer and returns {id, name, visible}, which covers mutability and output. However, it does not disclose any side effects, permissions, rate limits, or constraints beyond the schema (minLength). For a simple creation tool, this is adequate but minimal.

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

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

The description is extremely concise—two sentences: one for purpose and one for return value. No unnecessary words, front-loaded with the action. Every sentence adds value.

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

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

Given the tool's single parameter and the presence of an output schema (which the description explicitly echoes), the description is complete. It covers purpose, input, and output. No critical information is missing for an agent to use 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 100% for the single parameter 'name', which already has a description. The tool description adds no additional meaning beyond the schema for this parameter (just 'with the given name'). Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Create' and the resource 'new layer (tag)' with a required name parameter. It distinguishes from sibling list_layers which reads layers, and other tools that modify components. The return format is also specified.

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

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

The description implies usage for creating a layer, but does not explicitly state when to use this tool versus alternatives like list_layers or other creation tools. No when-not or exclusion criteria are provided, but the simplicity of the operation mitigates the need for extensive 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?

With no annotations provided, the description carries full burden. It explains dimensions are in millimeters, offsets from board face center, and details the return format including how to interpret failed cuts: 'non-zero failed means some cuts did not apply (likely non-manifold geometry); verify via bbox_mm.' This is a good disclosure of behavior and failure mode.

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

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

The description is concise: two paragraphs with no filler. The first sentence states purpose, followed by critical details. Every sentence adds value, and the structure is front-loaded.

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

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

Given the tool has 8 parameters, an output schema, and no annotations, the description covers prerequisites, unit system, default sizing, return format, and error handling. It is complete enough for an AI agent to understand what the tool does, when to use it, and how to interpret results.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds some context (units, default sizing) but does not significantly enhance understanding of individual parameters beyond the schema. The explanation of mortise_id and tenon_id is already present in the schema's description field.

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 a mortise-and-tenon joint between two boards.' It uses a specific verb (create) and resource (mortise-and-tenon joint), which distinguishes it from sibling tools like create_dovetail or create_finger_joint.

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

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

Provides explicit prerequisites: 'The two boards must already touch/overlap along the joint axis.' Also notes that defaults are sized for ~100 mm boards, giving a usage hint. Does not explicitly state when not to use or list alternatives, but sibling tools provide that context implicitly.

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 states the return value but fails to warn about permanent data loss or side effects. For a delete operation, this 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 with two sentences, no redundant information, and the key information is front-loaded.

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

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

While the tool is simple with one parameter and an output schema, the description lacks details on error handling, idempotency, and permission requirements, which are important for a delete operation.

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

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

The schema already fully describes the 'id' parameter (100% coverage). The description only repeats 'by entity ID', adding no additional semantic value beyond what the schema provides.

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

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

The description clearly states the action ('delete') and the resource ('group or component') and specifies the method ('by entity ID'). It distinguishes itself from sibling tools, as it is the only deletion operation among 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 does it mention prerequisites or conditions for safe use. Given the destructive nature, such guidance is important.

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 and excels. It discloses that only the last expression's .to_s is returned, stdout is not captured, errors are returned as '[code] message' with the Ruby exception class, and describes the gate-closed scenario including the JSON-RPC code and how the message is surfaced. This gives an agent a clear picture of what to expect before calling.

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 moderately long but every sentence adds essential detail: purpose, gating behavior, return value nuances, and error format. It is front-loaded with the core purpose in the first sentence and then expands on critical behavioral details. No fluff is present, but it could be tightened by reducing the explanation of the gate message wrapper, which is somewhat tangential to the core call.

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

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

The description covers all critical aspects an agent needs to call it correctly: return format, stdout limitation, error handling, and the special gate-closed case. It also alerts the agent to the verbatim-message mechanism. For a single-parameter tool with an output schema (though not shown), this is complete enough for accurate 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 already describes the parameter with 100% coverage, so the baseline is 3. The description adds valuable usage guidance by advising to end scripts with an explicit expression like 'result.to_json' to obtain structured data, which directly affects how the parameter should be used. This elevates it above baseline.

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

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

The description opens with 'Evaluate arbitrary Ruby code in SketchUp,' a specific verb and resource that unambiguously distinguishes it from all sibling tools which perform specific operations (create_layer, undo, get_version, etc.). There is no ambiguity about what the tool does.

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

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

The description does not explicitly contrast this tool with its siblings or state when to prefer it over other tools. It explains the gating behavior and error handling, but this is about behavioral context, not usage routing. The implied usage is as a general-purpose escape hatch for operations not covered by the specialized tools, but that is left 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?

No annotations are provided, so the description carries the full burden. It discloses important behavioral traits: the file is written on the SketchUp host, split-host path unreadability, and a warning field for certain exports. It does not explicitly state that the tool is non-destructive to the model, but the verb 'export' implies reading the scene without modification.

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

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

The description is concise with a clear front-loaded purpose statement, followed by compact listing of formats and return information. Every sentence adds value without redundancy.

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

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

For a single-parameter tool with an output schema, the description covers the essential behavior, return format, and an edge case (warning for never-saved models). Minor gaps include file naming conventions and how to access files on split-host setups, but these are acceptable given the output schema likely provides additional structure.

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

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

The schema has one parameter 'format' with enums and a default. The description adds meaning beyond the schema by noting that skp is native, obj/dae/stl are geometry, png/jpg are viewport renders with default resolution 1920x1080. This provides valuable context for the AI agent.

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

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

The description clearly states the tool exports the current scene to a temp file, lists all supported formats (skp, obj, dae, stl, png, jpg), and distinguishes it from sibling tools like get_viewport_screenshot which captures a viewport image without exporting.

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 context about the export destination (SketchUp host), split-host implications, and warning conditions for skp exports from unsaved models. However, it does not explicitly state when to use this tool versus alternatives like get_viewport_screenshot for image-only needs.

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 discloses the unreliability on non-manifold geometry, explains the return JSON structure, and advises checking specific stats fields. It could mention that the operation modifies geometry destructively but is implied.

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

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

The description is concise with three sentences plus a bullet of return info. It front-loads the main action. Could be slightly more streamlined, but no significant waste.

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

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

Given the presence of an output schema and 3 parameters, the description covers purpose, default behavior, non-manifold warning, and return interpretation. It is fairly complete for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining default behavior and return stats, but the parameter descriptions in the schema are already clear. The description does not provide additional semantics beyond the schema for the 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 ('Round (fillet) edges of a group/component') and distinguishes from sibling tool 'chamfer_edge' by specifying 'Round' vs bevel. It also mentions the parameters 'radius' and 'segments' directly.

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 context on default behavior ('By default ALL edges are filleted') and warns about non-manifold geometry. However, it does not explicitly contrast with chamfer_edge or specify when not to use this tool.

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

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

With no annotations, the description fully explains behavior: case-insensitive substring matching, exact layer matching, recursive search bounded by max_depth, pagination with truncation, and return format. No contradictions.

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

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

6 sentences front-loading purpose, then detailing matching, filter-less behavior, and return format. No extraneous text.

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

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

Covers all key aspects: filtering criteria, recursion, pagination, return structure. Output schema exists but description still gives helpful summary.

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

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

Schema has 100% coverage with good descriptions. The tool description adds behavioral context (case-insensitive, exact, recursive) not in schema, enhancing 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 tool finds components by name substring, layer, and type. It explains matching rules (case-insensitive, exact layer) and distinguishes from sibling list_components by noting the same traversal when no filters are applied.

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 mentions that without filters it behaves like list_components, implying an alternative for unfiltered listing. However, it could explicitly state when to use find_components vs list_components.

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. It states the return format but does not disclose error behavior, permissions, or that it is read-only. For a simple getter, this is minimally acceptable.

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

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

Two sentences fix, no unnecessary information. Concisely states purpose and return format.

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 simple input and presence of output schema, the description is largely complete. It could mention error handling or that the ID must come from previous responses, but overall is 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 description coverage is 100%, so baseline is 3. The description does not add new meaning beyond the schema's parameter description.

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

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

The description clearly states the tool retrieves detailed info for a single group or component by entity ID, distinguishing it from sibling tools like find_components, list_components, and get_selection.

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 when the user has an entity ID, but lacks explicit guidance on when to use versus alternatives, or when not to use this tool.

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

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

No annotations are provided, so the description carries the burden. It implies a read-only operation but does not explicitly state that it does not modify the model or any side-effect guarantees.

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

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

Two sentences, no waste. The first sentence states purpose, the second lists return format concisely.

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 info retrieval tool with no parameters and an output schema, the description is largely sufficient. However, it misses potential preconditions (e.g., model must be open) and failure modes.

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

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

No parameters exist (0 params), baseline is 4. The description adds value by detailing the return structure beyond the empty schema.

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

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

The description clearly states 'Get current SketchUp model info' and lists all returned fields (path, title, units, etc.). It is specific and distinct from sibling tools like get_component_info which focus on individual components.

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 vs alternatives. The context is implied as a general model information retrieval, but there is no mention of when not to use it 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?

No annotations are provided, so the description carries the full burden. It details the output format and differentiates entity types, but does not mention side effects, permissions, or behavior in empty selection.

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

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

Two concise sentences plus an example schema structure. No wasted words, highly efficient.

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

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

Given the tool's simplicity (no parameters, straightforward purpose), the description fully explains what it returns and the format. Output schema exists, so no need for further return value explanation.

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

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

No parameters exist, and the description provides no parameter information, which is appropriate since there are none. Schema coverage is 100%, so baseline score of 4 is suitable.

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

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

The description clearly states the verb ('Get') and the resource ('entities currently selected in the SketchUp UI'). It differentiates itself from sibling tools like boolean_operation or create_component by being a read-only getter.

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 or when not to use it. For a simple getter, the necessity may be obvious, but explicit context would improve clarity.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool always returns a payload, even during connection or other errors, and describes the result structure (JSON string with specific fields). This provides meaningful behavioral context beyond basic purpose.

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

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

The description is two sentences plus a field listing, with no wasted words. The main purpose is front-loaded, and every sentence adds value.

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

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

Given no parameters and an output schema, the description is remarkably complete: it explains when to use, what it returns, and its reliability. It adds details about the compatibility fields beyond the bare schema.

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

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

The tool has zero parameters, so baseline is 4 per guidelines. The description adds no parameter information because none exist. It correctly focuses on return value and usage context.

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

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

The description clearly states it returns server version and compatibility verdict, which is a specific verb+resource. It distinguishes from sibling tools by describing its unique role as a runtime sanity probe.

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

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

The description explicitly recommends using it as a runtime sanity probe and notes it always returns a payload even when other tools error. While it doesn't list alternatives or exclusions, the context is clear enough for an agent to decide when to invoke it.

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

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

No annotations are provided, so the description carries the full burden. It describes the snapshot process, parameter effects, and retry/flicker behavior. It does not explicitly state non-destructiveness but implies it via the restore_view parameter and its description.

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

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

The description is well-structured with clear paragraphs and a parameter list. It is concise enough but could be slightly tighter by removing some 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 no output schema, the description includes the return format (PNG + JSON). It covers all parameters, retry behavior, and the purpose, making it fully informative for an agent.

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

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

Schema coverage is 100%, but the description adds significant context beyond the schema for each parameter, such as aspect ratio scaling for max_size and the specific rendering options toggled by style.

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 captures a screenshot of the SketchUp viewport and returns a PNG image along with a JSON block containing dimensions and style info. It is distinct from sibling tools like export_scene or get_selection.

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

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

Explicitly states it is 'useful for letting Claude visually verify the scene between steps', providing clear context for when to use it. However, it does not explicitly mention when not to use it or compare with alternatives.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It explains the return format (detailed vs. concise), pagination behavior (truncated flag, offset increment), and recursion depth limits. This is comprehensive for a read-only list 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 concise (three short paragraphs) and well-structured: purpose, object format, parameters, return value with pagination instructions. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (5 parameters, pagination, two response formats), the description covers all necessary aspects: what is returned, how recursion works, and how to paginate. The presence of an output schema is acknowledged but the description still fully explains the return structure.

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

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

Schema description coverage is 100%, so each parameter is already described. The description adds significant value by explaining the meaning of response_format (detailed includes bbox_mm, concise omits it) and the interaction between recursive and max_depth. This goes beyond the schema.

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

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

The description begins with a clear verb+resource: 'List groups and component instances in the model (paginated)'. It immediately distinguishes itself from siblings like find_components (search) and get_component_info (single component), as it is a paginated listing tool.

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

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

The description provides clear guidance on using pagination and recursion (e.g., 'Set recursive=true to descend into nested components... bounded by max_depth, default 3' and instructions for pagination via offset increment). However, it does not explicitly state when to use this tool over siblings like find_components, which would improve the score.

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

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

No annotations provided, so description carries full burden. It mentions return format and that it lists all layers, implying a read-only operation but does not explicitly state no side effects. Adequate for a simple 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?

Very concise, single sentence plus return format example. Structurally clear and front-loaded.

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

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

Given zero parameters and presence of output schema in description, it is fairly complete. Lacks details on layer definitions or edge cases, but sufficient for a simple list tool.

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

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

No parameters exist, so schema coverage is 100%. Baseline of 3 applies; description adds no parameter information, which is acceptable given no params.

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 lists all model layers (tags). The verb 'list' and resource 'layers' are specific. The parenthetical 'tags' might cause minor ambiguity but overall the purpose is 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?

No explicit guidance on when to use this tool versus alternatives (e.g., create_layer). However, as a simple read operation with no parameters, usage context is implicitly understood.

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 discloses key behaviors: instance vs definition coloring, valid material formats, and error code for invalid material. It could also mention side effects like undo but is adequate.

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

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

Description is concise and well-structured: purpose first, then material details, then behavioral nuance, then return type. No superfluous sentences.

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 output schema exists and only two simple parameters, the description fully explains input, behavior, and return format. No gaps for a coloring tool.

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

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

Schema coverage is 100%, but description adds value: examples of valid colors, case-insensitivity, error code, and behavior context for the 'id' parameter (instance vs definition).

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

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

Description clearly states 'Assign a material (color) to a group or component.' It specifies the action, resource, and distinguishes from sibling tools by focusing on coloring, which no other tool does.

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

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

The description implies usage for changing color but provides no explicit guidance on when to use vs alternatives or when not to use. No mention of prerequisites or when this tool is preferable.

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 provided, so description carries full burden. It discloses position as absolute and applied last, rotation as relative sequential about world axes, scale as relative with non-zero validation, and return JSON structure. All key behavioral traits are explained beyond 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?

Concise bullet-pointed description with no fluff. Each sentence provides essential information about parameters, validations, and output. Front-loaded with main action.

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

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

Given the tool has 4 parameters with full schema coverage and an output schema, the description covers all needed context: operation order, validation scope, return format, and verification hint (read bbox_mm). No gaps perceived.

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

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

Schema coverage is 100%, but description adds critical semantics: position is NOT relative but absolute and idempotent, rotation order is X then Y then Z, scale factors are relative with non-zero constraint. These enrich the parameter understanding significantly.

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

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

Description clearly states verb 'Move, rotate and/or scale' and resource 'a group or component', distinguishing it from creation/deletion/evaluation siblings like create_component, delete_component, and eval_ruby. The title is null but name suffices.

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 contrasts with eval_ruby by noting validations only apply to this typed tool, guiding the agent to use this for safe transformations. However, it does not elaborate on when to prioritize this over other transformation-like operations among siblings.

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

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

With no annotations, the description carries the full burden. It discloses that it undoes the last atomic operation and returns {ok: true}. This sufficiently describes behavior for a straightforward undo 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 consists of two short sentences: one explaining the action and one specifying the return value. Every word adds value with no redundancy.

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

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

Given no parameters and a simple return, the description is complete. It omits potential edge cases (e.g., multiple undos), but overall it provides sufficient context for a basic undo tool.

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

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

There are no parameters (0 parameters, 100% schema coverage). The description adds no extra parameter info, which is fine as the schema already covers everything.

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 'Undo the last atomic operation in SketchUp', using a specific verb and resource. It is distinct from sibling tools which create, modify, or query; no other tool performs undo.

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

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

The description explains that one MCP tool-call equals one undo step, clarifying usage. No explicit when-not-to-use or alternatives are given, but the simple 0-parameter interface and unique function make guidance adequate.

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