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

Annotations already disclose destructiveHint=false, idempotentHint=false and readOnlyHint=false, and the description adds genuinely non-obvious behavior: the whole batch is a single atomic undo unit, so partial application is not a concern. It does not say what happens on mid-batch failure or how errors surface, keeping it short of 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 sentences, no filler, with the core capability and the atomicity guarantee front-loaded and the exclusions trailing. Every clause earns its place.

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

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

For a 4-parameter mutation tool with no output schema and no per-parameter docs, the description is thin: it never defines the command object format, how model_id/active_path scope the batch, or what a caller gets back. It covers scope and atomicity adequately but leaves an agent guessing about the invocation payload.

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% across four parameters, and the description explains none of them: model_id, active_path, operation_name, and the shape of each command object (method/params) are all undocumented. The only parameter-adjacent detail, '1–100', merely restates the existing minItems/maxItems constraints, so it adds no meaning.

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

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

The description states a specific verb and resource ('Run 1–100 typed model mutations'), adds the distinguishing scope 'single atomic undo operation', and carves itself out from siblings by excluding Ruby, save, undo and nested batches. That is enough for an agent to separate it from model_undo or sketchup_run_ruby without opening the schema, though it never says what a 'typed model mutation' actually is.

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 exclusion list ('Ruby, save, undo, and nested batches excluded') is a useful when-not signal, but it stops short of naming the alternative tools (sketchup_run_ruby for Ruby, model_save, model_undo) or saying when a batch is preferable to individual calls. Usage is implied rather than directed.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuine value by enumerating what the inspection reports (connection state, active profile/instance, capability/optional-API discovery, queue and recent request states), which the annotations do not convey.

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

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

Two tight sentences with zero filler. The primary purpose is front-loaded, and the second sentence adds the distinct 'discovery' angle rather than restating the first.

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

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

No output schema exists, so the description must signal the return content — and it does so by listing the state categories it inspects. With no parameters and annotations covering mutability, this is largely complete; only the exact response shape remains undisclosed.

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 takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to compensate for, and it does not need to explain input syntax.

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 ('Inspect') and enumerates the exact resource surface — connection, profile/instance, capabilities, queue, recent request states. This is unmistakably distinct from every sibling, all of which are modeling/entity 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 line 'Runtime permissions and optional APIs are discovered here' implies this is the discovery/preflight step before invoking other tools, which gives implied usage context. However, it names no alternative and gives no explicit when-to-call-vs-when-not condition.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds essentially no extra behavioral context—no coordinate system, units, or whether values reflect the active view—so it does little beyond restating a read.

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

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

A single eight-word sentence with the verb and the complete return payload front-loaded, and no filler. Nothing could be removed without losing information.

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

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

With no output schema, the description carries the burden of describing the return value, and it does so precisely by naming the three vectors returned. Only the coordinate convention and units are left unspecified, a minor gap for a simple getter.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4.

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?

Names a specific verb (Read) and resource (camera) and enumerates exactly what is returned: eye, target, and up vector. It does not explicitly contrast itself with the sibling camera_set, but the get/set pairing is unambiguous from the name and field list.

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

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

No guidance on when to use this versus alternatives such as camera_set or view_capture, and no stated preconditions (e.g. an active model or scene). The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false. The description adds only the optional framing behavior, with no information about persistence, return values, side effects, or what happens to existing camera state. It adds little beyond the annotations.

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

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

The description is a single concise sentence, but for a 12-parameter tool it is severely under-specified. Brevity is not serving the agent here because essential invocation context is missing.

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

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

Given 12 parameters, no required fields, no output schema, and no parameter descriptions, the one-sentence description is completely inadequate. An agent cannot determine how to set the camera or what the optional framing arguments should contain.

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 12 parameters with 0% description coverage, so the description must compensate. It only vaguely references framing 'an entity or the whole model,' adding no meaning for eye, target, up, fov, path, height, unit, perspective, zoom_extents, active_path, or model_id.

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

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

The description states a clear verb and resource: 'Set camera' with optional framing of an entity or the whole model. It distinguishes itself from camera_get by using 'Set,' but it does not explicitly name or differentiate against siblings. The scope is reasonably clear but not razor-sharp.

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

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

There is no guidance on when to use this tool versus alternatives such as camera_get or the various view/snapshot tools. 'Optionally frame an entity or the whole model' hints at a use case, but no conditions, prerequisites, or exclusions are stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false. The description usefully adds that the operation is wrapped in an undo transaction (so it is reversible via model_undo) and notes the default unit, which is real value beyond the annotations. It does not clarify idempotentHint=false (repeat calls create multiple boxes) or the effect of the parent/origin parameters.

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 front-loaded sentences with no wasted words; the scoping constraint and default unit come first. It is terse rather than over-padded, though the extreme brevity contributes to the parameter gaps.

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 9-parameter mutation tool with nested objects, a 0%-covered schema, and no output schema, the description is far too thin. An agent has no way to know what nested parents are, how origin interacts with size, or what the undo transaction means for repeated calls.

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

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

Schema description coverage is 0% across 9 parameters, so the description must carry the burden, and it does not. It only restates the default unit ('mm'), which the schema already encodes as a default, and says nothing about size, origin, parent, model_id, parent_id, or active_path.

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 ('Create a box') and adds a distinguishing spatial constraint ('toward positive Z') that separates it from entity_create_cylinder. However, it does not explicitly name or contrast the sibling creation tools.

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

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

No guidance on when to use this versus entity_create_cylinder, entity_create_mesh, or entity_extrude, and no prerequisites or preconditions stated. The 'toward positive Z' clause hints at orientation but not at tool selection.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false), so the bar is lower. The description adds genuinely useful non-annotation facts: the cylinder axis (+Z), that units are mm, and that smooth sides are optional. It omits what the tool returns (entity id/handle?), whether parenting requires an existing model context, and how segments affects output.

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

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

One tight sentence, front-loaded with the verb and the two facts that matter most (axis, units). Nothing is wasted, but the brevity is partly under-specification rather than restraint.

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 12-parameter geometry-creation tool with a nested parent object and no output schema, the description is far too thin. An agent cannot tell how to place the cylinder in a model, what identifiers come back, or what minimum viable call looks like beyond the two required fields.

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% across 12 parameters, including a nested parent object, so the description carries the full burden and mostly fails it. It covers only unit (mm) and smooth; radius_mm, height_mm, segments, origin, parent, model_id, active_path and tag/name are all unexplained beyond their names.

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

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

Specific verb+resource: creates a cylinder primitive, with orientation and unit qualifiers. Siblings entity_create_box and entity_create_mesh make the resource class inferable, though the description never names them to draw the line explicitly.

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

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

No statement of when to use this rather than entity_create_box, entity_create_mesh, entity_extrude, or entity_duplicate. A parent/child insertion tool gives no guidance on how it interacts with the scene hierarchy or selection-based siblings.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the mutation/safety profile is covered. The description adds genuinely useful behavior beyond that: nonplanar faces are triangulated and smooth shading is supported, which tells the agent how geometry will be post-processed. It does not disclose parent/hierarchy side effects or coordinate-system 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?

Three short sentences, front-loaded with the core action before the triangulation and shading notes. No filler; each sentence adds information.

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

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

For a tool with 11 parameters, nested parent objects, a required parent_id/path hierarchy, and no output schema, three sentences are thin. Key calling decisions (units, whether parent context is required, limits on vertex/face counts) are left unaddressed.

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% across 11 parameters, so the description must carry the load. It clarifies the two required inputs and the important 'zero-based' indexing convention plus smooth shading, but leaves tag, name, unit, origin, parent, parent_id, active_path, and model_id entirely undocumented in both places.

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 arbitrary grouped geometry from vertices and zero-based face indices') and names the geometric inputs, which cleanly separates it from entity_create_box and entity_create_cylinder. It stops short of explicitly naming those siblings as alternatives, so it falls just below the top band.

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

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

There is no statement of when to use this versus entity_extrude, entity_create_box, entity_create_cylinder, or entity_group. The agent must infer applicability entirely from the phrase 'arbitrary grouped geometry'.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely new information not present in the annotations: the deletion is undoable, and it targets an 'existing' entity (implying failure on a missing id).

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 compact sentence that front-loads the action and states the one notable property (undoable). Nothing is wasted and nothing is buried.

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

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

For a destructive, non-idempotent tool with three undocumented parameters, no required-parameter signal, and no output schema, the description is too thin. An agent still cannot tell whether to pass entity_id, a path, or model_id, or what happens on a missing or invalid entity.

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% across three parameters (path, model_id, entity_id), and the description offers no parameter guidance at all. It never explains the relationship between entity_id and the path array, nor which of the zero-required parameters must actually be supplied, so it fails to compensate for the coverage gap.

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

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

The description gives a specific verb ('Delete') and resource ('an existing entity'), so an agent immediately knows the operation. It does not, however, distinguish itself from related siblings such as entity_update, entity_duplicate, or scene_clear, which limits the score to 4.

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

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

There is no statement of when to use this tool versus entity_update or entity_duplicate, nor any prerequisite (permissions, existence checks, model context). The only hint is that the operation is reversible, which is behavioral rather than selection guidance.

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

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

Annotations already disclose readOnly=false, idempotent=false, and destructive=false, so the mutation profile is partly covered. The description adds a genuinely useful behavioral detail — the offset is applied in the parent coordinate system — but says nothing about whether the duplicate is selected, what it returns, or how naming interacts with copies.

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 compact sentence, front-loaded with the action and resource. It earns its place but is arguably too terse given the undocumented parameters.

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 6-parameter mutating tool with no output schema and zero schema descriptions, the description leaves the agent without enough to call it correctly — it does not explain model_id, unit, path, or naming behavior.

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

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

Schema description coverage is 0% across 6 parameters, so the description must compensate. It only loosely maps to 'translation'/'offset' and the source entity; name, unit, model_id, and path are entirely undocumented in both schema and 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?

States a specific verb ('Copy') and resource ('a group or component'), plus the spatial behavior (offset in parent coordinate system). It does not explicitly contrast with siblings such as entity_group, entity_make_unique, or entity_create_*, so it stops short of a 5.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no alternative named for related operations like entity_make_unique or entity_group. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the mutation and safety profile is covered structurally. The description adds genuinely useful behavioral context about extrusion direction (XY polygons go toward +Z), but says nothing about errors on non-planar or degenerate input, nor about what entity is returned.

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 tight sentences with the core action front-loaded and the orientation caveat immediately after. Nothing is padded or redundant.

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 10-parameter geometry-mutating tool with nested parent/path objects, no output schema, and zero schema description coverage, two sentences leave major gaps — particularly which coordinate frames the points and origin occupy and how the resulting entity is identified.

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

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

Schema description coverage is 0% across 10 parameters, and the description mentions none of them. The reader must infer that 'points' is the planar polygon and 'distance' the extrusion length, and gets no help at all with origin, unit, parent, model_id, active_path, tag or name.

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 ('Extrude a planar polygon along its normal'), which is clearly distinct from sibling creation tools like entity_create_box or entity_create_cylinder. It does not, however, explicitly contrast itself with those siblings or clarify whether it creates a new entity or modifies an existing one.

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

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

The description offers no when-to-use guidance, no prerequisites (e.g., the polygon must be planar and closed), and no mention of alternatives such as entity_create_mesh for non-planar geometry. The orientation note is a hint, not usage guidance.

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

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

Annotations establish this is a non-readonly, non-destructive, non-idempotent mutation, but the description adds little beyond that. It does not disclose what happens to the source entities (e.g., they become children of a new group), whether the group is returned/referenced, or any nesting/permission constraints.

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 padding. It is efficient, though its brevity comes at the cost of the missing detail noted elsewhere.

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 mutation tool with no output schema and no parameter documentation, the definition is under-specified: it lacks side-effect details and parameter meaning. An agent could call it, but would be guessing about the group's name, target model, and the fate of the original entities.

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% across 4 parameters, and the description only loosely implies entity_ids (the entities to group) and active_path (current edit context). The name and model_id parameters, and the required nature of entity_ids, are never addressed.

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 (group) and resource (existing entities) scoped to the current edit context, which reads clearly against siblings like entity_duplicate or entity_make_unique. It does not explicitly name or contrast any alternative, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as entity_make_unique or whether grouping requires prior selection. Only the implicit 'existing entities in the current edit context' scope is offered.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds one genuine behavioral detail beyond that: translation entries in matrices are expressed in the requested unit. It does not cover pagination, error behavior, or what happens with invalid paths.

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 zero padding, and the returned-field list is front-loaded before the unit caveat. Nothing is wasted, though the second sentence is slightly cryptic in isolation.

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 read-only tool with full annotation coverage and no output schema, the description usefully enumerates the returned fields. However, with zero parameter documentation and a non-obvious 'path' array semantics, an agent still lacks enough to invoke it confidently.

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

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

Schema description coverage is 0% across 4 parameters. The description only explains the 'unit' parameter's effect on matrix translations, leaving 'path' (an array of entity_id refs, 1-32 items), 'model_id', and 'entity_id' entirely undocumented in both schema and 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?

States a specific verb (inspect) plus the exact data returned: persistent ID, instance path, world bounds, solid status, transform. This clearly separates it from mutation siblings like entity_transform/entity_update, though it doesn't explicitly contrast with entity_list or selection_get.

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

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

No when-to-use guidance and no named alternatives. With ~35 siblings including entity_list, selection_get and model_get_info, an agent gets no help deciding when entity_inspect is the right choice over those read tools.

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

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

Annotations already cover the read-only, idempotent, non-destructive profile, so the safety baseline is met. The description adds genuinely new behavioral context: recursive traversal behavior around shared component instances and the existence of a total_exact completeness flag. Return/pagination format details remain thin, but this is useful disclosure beyond the annotations.

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

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

Three short, front-loaded sentences with no filler. The reference to total_exact is slightly confusing given it is not in the input schema, but the overall brevity is appropriate.

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

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

For a 14-parameter, 0%-coverage tool with no output schema, the description is far too sparse to guide correct invocation. It leaves most filter, unit, depth, and pagination parameters unexplained, so an agent must guess at their semantics.

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

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

With 14 parameters and 0% schema description coverage, the description carries the full burden and mostly fails it, explaining only scan_limit (and referencing total_exact, which is not even an input parameter). Tag, name, path, type, unit, limit, offset, model_id, entity_id, max_depth, recursive, active_path, and include_total get no meaning from the text.

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

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

The description states a specific verb ('Paginate') and resource ('entities') and scopes it to paths and world bounds, so an agent knows it is a listing/query operation. It does not distinguish itself from the many sibling entity_* tools (notably entity_inspect), but the purpose itself is unambiguous.

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

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

The only usage cue is 'Use scan_limit for large models,' which is a parameter hint rather than when-to-use guidance. There is no indication of when to prefer this over entity_inspect or other siblings, nor any prerequisite or exclusion criteria.

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

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

Annotations already declare this is a non-destructive, non-idempotent mutation, so the safety profile is covered. The description adds real semantic context by explaining the effect on shared geometry, but omits what happens to the original shared definition and whether other instances are affected. Adequate but not rich.

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

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

A single front-loaded sentence with no waste. It is efficient, though arguably too terse for a mutation tool with three undocumented parameters.

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 non-idempotent mutation with three parameters at 0% schema coverage and no output schema, the one-line description is insufficient. It should at least clarify the target parameters and the effect on the remaining shared 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 description coverage is 0% across three parameters (path, model_id, entity_id), and the description mentions none of them. Since the schema provides no descriptions, the description should compensate but does not, leaving parameter meaning fully undocumented.

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

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

The description gives a specific verb+resource+effect: making a component instance or group independent of shared geometry. It distinguishes the operation from siblings like entity_duplicate or entity_group implicitly, though it never names them. A clear statement of purpose, but no explicit sibling routing.

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

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

There is no guidance on when to use this versus entity_duplicate, entity_group, or other entity mutations, and no prerequisites or conditions are stated. The agent is left to infer context entirely from the purpose sentence.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, covering the safety profile. The description adds a genuine side-effect detail (faces scope makes instances unique first), but omits whether existing material is overwritten, what path/color do, and permission requirements.

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 tight sentences with the primary action front-loaded and no filler. It is efficient, though the second sentence could be clearer about the mechanism rather than just stating an outcome.

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?

A mutation tool with six parameters, no output schema, and 0% schema coverage needs more than two short sentences. The interaction with existing material, the role of path/color, and return behavior are all unaddressed.

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

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

Schema description coverage is 0%, so the description carries the full burden for six parameters. It only implicitly touches the scope enum (instance vs faces) and material, explaining nothing about path, color, model_id, or entity_id, leaving most parameters opaque.

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 (assign) and resource (material) plus the target (instance or its direct faces), so the core operation is clear. However, it does not differentiate from siblings like materials_set or entity_update, leaving the agent to guess which tool owns material assignment.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative named. The scope note implies behavior but gives no condition that tells the agent to pick this tool over materials_set or entity_update.

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

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

The annotations already declare this is a non-read-only, non-destructive, non-idempotent operation, so the description does not need to carry the full safety burden. It adds useful behavioral context beyond the annotations: the transform is applied in parent coordinates, the order is scale-then-rotate-then-translate, matrix format is column-major with translation in the specified unit, and axis-angle is preferred over legacy Euler.

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

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

The description is four short sentences, front-loaded with the core purpose and then dense with operational conventions. Every sentence adds specific information about how to invoke the tool correctly, with no filler.

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

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

Given 11 parameters, 0% schema description coverage, no output schema, and minimal annotation detail, the description is not complete enough for confident invocation. It explains transform semantics but omits parameter necessity, path/entity_id/model_id usage, pivot behavior, and expected return or error behavior.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It adds valuable semantics for several key parameters (matrix format, rotation convention, scale/rotate/translate order, unit handling), but it leaves many parameters unexplained, including entity_id, path, model_id, pivot, and the precise relationship between translation, rotation_degrees, axis, and angle_degrees.

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

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

The description states a specific verb and resource: 'Transform a group/instance in its parent coordinates.' It also specifies the transform order (scale, rotate, translate), which makes the operation unambiguous. However, it does not explicitly distinguish this tool from sibling tools such as entity_update, so it stops short of a 5.

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

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

The description gives parameter-selection preferences ('Matrix replaces transform', 'Axis-angle preferred'), but it does not say when to use this tool versus alternatives. There is no explicit when-to-use, when-not-to-use, or prerequisite guidance.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false), so safety is partly covered. The description adds nothing beyond field categories: it does not say whether unspecified fields are left untouched, whether changes are undoable via model_undo, or what happens if entity_id/path disagree.

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, which is structurally sound. However, the brevity comes at the cost of omitting essential targeting information, so it is under-specified rather than optimally concise.

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

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

For a mutating 7-parameter tool with no output schema and no schema descriptions, the description is far too thin. It leaves unclear how the target entity is selected and what subset of attributes a single call can change, which an agent needs before invoking it.

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% across 7 parameters with 0 required, so the description carries the full burden. It loosely names name, tag, 'visibility' and 'lock state' (presumably hidden and locked) but never mentions entity_id, path, or model_id, and gives no format or default semantics for any of them.

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

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

It names a specific verb and resource (set entity attributes) and lists four attribute categories, which is more than a tautology. But it omits how the target entity is identified and ignores three schema parameters (entity_id, path, model_id), so an agent cannot tell the full scope from the description alone. Sibling tools like entity_transform and entity_set_material are not referenced to disambiguate.

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

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

No when-to-use guidance, no preconditions, and no routing to alternatives such as entity_transform for transforms or entity_set_material for materials. The agent must infer everything about context of use.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint: false, and openWorldHint: false, covering the safety profile. The description adds no behavioral context beyond that—it does not mention scope, permissions, performance, or side effects.

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 that states the verb and the key returned attributes with no wasted words. It is appropriately terse for a simple list 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?

With no output schema, the description should explain the return values and scope more fully. It lists three properties (color, alpha, texture status) but omits whether it returns all materials or selected ones, and does not describe the structure of the returned list, leaving an agent without enough to predict the response shape.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain. Per the rubric, a zero-parameter tool receives a baseline of 4 because the schema fully covers the (empty) input contract.

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

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

The description uses a specific verb ('List') and resource ('material') and names the attributes returned (color, alpha, texture status). It clearly distinguishes from the setter sibling materials_set, though it does not explicitly name alternatives or scope.

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

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

There is no explicit guidance on when to use this tool versus alternatives like materials_set or entity_set_material. Usage is only implied by the tool's name and description, with no context, prerequisites, or exclusions provided.

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

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

Annotations already declare writable, non-destructive, non-idempotent behavior, so the bar is lower. The description adds one useful behavioral detail (roughness silently degrades on older SketchUp versions), but says nothing about update-vs-create semantics, overwrite behavior, or required context.

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, front-loaded with the core purpose and no filler. It is appropriately terse, though the terseness is partly a symptom of under-specification rather than disciplined editing.

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

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

For a 7-parameter mutation tool with no output schema and no annotation depth, the description is too thin. It covers only roughness and omits the payload semantics and effect of almost every other field.

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

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

Seven parameters with 0% schema description coverage, so the description is the only channel for semantics. It clarifies roughness is optional and PBR-only, but leaves name, color, alpha, texture, model_id, and active_path entirely unexplained.

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

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

States a specific verb pair (create/update) and resource (material), so the agent knows it is a write operation on materials. However, it does not differentiate from the closely related sibling entity_set_material, leaving ambiguity about which to pick.

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 materials_list or entity_set_material, and no prerequisites (e.g., an open model context) are stated. Usage is only implied by the verb 'create/update'.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful behavioral context: it operates at the entity-metadata level and deliberately excludes per-vertex detail, telling the agent what granularity of change it will and will not report.

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 primary action leads and the scope caveat trails. Slightly terse for the amount of undocumented behavior, but no wasted words.

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

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

With no output schema, the description usefully sketches what is reported, and annotations carry the safety profile. However, given 0% parameter documentation and no return structure, the definition is only minimally complete for an agent trying to call it with the right arguments.

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

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

Schema description coverage is 0% and there are three parameters, yet the description only hints at snapshot usage. It gives no meaning for model_id (which model is diffed?) or active_path, so it fails to compensate for the fully undocumented 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 ('compare') and resources ('entity metadata' vs a 'snapshot') plus the exact output scope ('additions, deletions and changes'). It implicitly distinguishes itself from siblings like model_snapshot or model_undo, though it does not name them outright.

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 never says when to use this tool versus alternatives such as model_undo/model_redo, nor does it state that a snapshot must already exist (e.g. via model_snapshot). The dependency on snapshot_id is only inferable from the schema, not from the text.

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

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

Annotations already declare this is a non-read-only, non-destructive, non-idempotent write. The description adds genuine context: exporter selection is driven by the file extension and availability is host-dependent. It does not explain what overwrite does, whether an existing file is clobbered by default, or where output lands, so it goes beyond annotations only partially.

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, front-loaded with the core action, no filler. It is efficient, though the terseness cuts into useful detail rather than being a model of packing information densely.

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 five parameters, a nested options object, no schema descriptions, and no output schema, the description is far too thin. It omits parameter meanings, overwrite behavior, and the shape of the result, leaving the agent with substantial guesswork.

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?

Five parameters with 0% schema description coverage, so the description carries the full burden, yet it names none of them. The 'selected by file extension' phrase implicitly gives meaning to path, and options is left entirely opaque despite being a nested object, but most parameters are undocumented in both places.

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: exporting the model via the installed SketchUp exporter, with the notable detail that the exporter is chosen by file extension. It does not explicitly distinguish itself from siblings like view_export or model_save, but the mechanism it describes is unique enough that an agent can tell it apart.

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 only guidance is a caveat that availability depends on host edition/version; there is no statement of when to use this versus view_export, model_save, or model_snapshot. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so safety behavior is covered. The description adds content-level detail (what context is retrievable) but says nothing about return format, whether session ID is stable, or how 'edit context' behaves — acceptable given the annotation coverage.

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

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

A single front-loaded sentence with no filler; the returned field list is packed efficiently and every word earns its place.

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

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

With no output schema, the description carries the burden of explaining returns, and it enumerates the five categories of data delivered. For a zero-param read-only info tool this is largely sufficient, with only minor gaps around format and stability of the returned values.

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?

Zero parameters, so the schema imposes no semantic burden on the description; the baseline of 4 applies. The description does not need to explain any argument 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 ('Get') and resource ('model'), then enumerates the concrete data returned: session ID, path, units, edit context, runtime capabilities. That distinguishes it reasonably from siblings like model_stats or bridge_status, though it never names them or explicitly contrasts.

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 when-to-use or when-not-to-use guidance, and no alternatives are named. Usage is only implied: an agent infers this is the orientation call for retrieving model/environment context before other operations.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the safety profile is covered. The description adds one real behavioral trait not in the annotations — that redo may be unavailable depending on SketchUp version — but says nothing about what state is altered or how to confirm success.

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

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

The single sentence is front-loaded with the verb, but at this length it is under-specified rather than concise. For a destructive, two-parameter tool this size is not appropriate.

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?

A destructive mutation tool with 0% parameter coverage, no output schema, and no explanation of the undo/redo stack it acts on. The description leaves the agent without enough information to invoke it correctly or predict its effect.

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

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

Schema description coverage is 0% and neither model_id nor active_path is referenced anywhere in the description. With two undocumented parameters and no compensating text, the agent gets no semantic help from the description at all.

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 verb 'Redo' is specific and the sibling model_undo makes the intended direction clear, but the description never names the resource or scope (which model, what undo stack). 'When supported by this SketchUp version' cheapens an otherwise identifiable operation into a vague conditional.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as model_undo or sketchup_run_ruby. The only qualifying statement, 'when supported by this SketchUp version', hints at a precondition but never tells the agent how to detect or handle unsupported versions.

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

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

Annotations declare non-read-only, non-destructive, non-idempotent, and closed-world, so safety profile is already given. The description adds genuinely useful behavior: the explicit overwrite flag gates destruction of existing files, which explains why destructiveHint can remain false. It does not, however, mention permissions, return value, or what happens to the currently open document.

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, front-loaded with the operation and followed by the safety-relevant detail. Zero 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 4-parameter mutation tool with no output schema and no annotation detail on side effects, the description is adequate but thin: two of four parameters and the relationship to sibling save/export tools remain unaddressed.

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 carry parameter meaning. It documents only path (must be absolute) and overwrite (protects existing files); model_id and active_path are completely unexplained in both schema and 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?

States a clear verb+resource ('Save SKP') and adds a scope constraint (absolute path). However, it does not distinguish itself from the closely named sibling model_export, leaving the save-vs-export distinction to inference.

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

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

No when-to-use guidance, no prerequisites, and no mention of the alternative model_export or model_snapshot for capturing state. The sentence about the overwrite flag implies a safety condition but never says when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds the meaningful behavioral fact that the capture exists to enable later comparison, but leaves opaque what 'bounded' means and whether the snapshot persists across calls or sessions.

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 economical sentence with no filler and the intent front-loaded. It is tight, though the brevity comes at the cost of the clarity issues noted elsewhere.

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

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

With no output schema, a read-only snapshot tool still needs to tell an agent what the snapshot contains and how it is consumed. The description omits both, and with 0% parameter coverage it is not sufficient for an agent to call this correctly in the model_diff workflow.

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 carry parameter meaning and it does not. 'entity/path' only loosely gestures at active_path, and it never explains model_id, why active_path is an array of positive integers, or what form a path takes.

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 verb 'Capture' plus the resource 'entity/path metadata' gives a general sense of the action, and 'for subsequent changes comparison' hints at intent. However, 'bounded entity/path metadata' is jargon that never resolves into concrete terms, and the tool is not distinguished from near-siblings like model_diff, model_get_info, or model_stats.

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 'for subsequent changes comparison' weakly implies this should be called before a diff, but neither model_diff nor any other alternative is named, and there is no statement of when this snapshot is required versus when model_get_info or model_stats would suffice.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds one genuine behavioral fact beyond that — results are truncated at max_entities — but does not say what happens when the bound is hit, whether counts are approximate, or what the response looks like.

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

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

Two short sentences, front-loaded with the action and free of padding. Nothing is wasted, though the second sentence is a terse fragment that could have carried more of the missing parameter detail at the same length.

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

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

With no output schema, 0% schema description coverage, and three undocumented parameters, the description leaves core questions unanswered: what the returned counts look like, how they are grouped, and what model_id and active_path select. For an aggregation tool this is substantially under-specified.

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 carry all three parameters, yet only max_entities is referenced and even then only as a bounding limit with no mention of its default of 100000 or its 1000–1000000 range. model_id and active_path are entirely unexplained — notably active_path, whose array-of-positive-integers structure has no obvious meaning without prose.

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 gives a concrete verb and resource ("Count entities") and names the dimensions counted over (instance paths, materials, tags, scenes), so the agent knows this is a read-only aggregation tool rather than a mutation. However, it never distinguishes itself from close siblings like entity_list or model_get_info, which also enumerate entities.

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

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

There is no statement of when to reach for model_stats versus entity_list, entity_inspect, or model_get_info, and no prerequisites or exclusions are given. The agent must infer usage purely from the name and 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?

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is covered. The description adds only the single-step scope ('most recent'), with no mention of what state is restored or that a redo is required to reverse it.

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

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

A single front-loaded sentence with zero waste. It is efficient, though its brevity reflects under-specification rather than tight editing.

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

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

For a destructive mutation tool with no output schema and two undocumented parameters, the description omits usage context, parameter meaning, and any reversal semantics. Annotation coverage is the only thing carrying the behavioral story.

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% for two parameters, and the description mentions neither model_id nor the non-obvious active_path array. It fails to compensate for the documentation gap.

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

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

States a specific verb (undo) and resource (most recent SketchUp operation), making the effect unambiguous. It does not name its obvious sibling model_redo, so it stops short of full differentiation.

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

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

No when-to-use guidance, no prerequisites, and no reference to the complementary model_redo tool, which is the natural alternative in the sibling list. An agent must infer all routing behavior.

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

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

Annotations already declare destructiveHint=true and non-idempotency, so the safety bar is partly met. The description adds genuinely new context beyond annotations: that the wipe is undoable and that a root edit context is required. It still omits any warning about irreversibility outside an undo stack, but it contributes real behavioral value.

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 tight sentences that front-load the destructive action before the prerequisite. Nothing is wasted.

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

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

For a destructive bulk operation with no output schema and zero param documentation, the description covers the safety-relevant essentials (destructive, undoable, context requirement) but leaves the two parameters fully unexplained. Adequate but with a clear 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% and the description never mentions model_id or active_path, so the agent gets no explanation of what these required-ish parameters do or how to supply them. The description does not compensate for the coverage gap.

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

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

The description gives a specific verb and resource ('Erase all model entities') with a scope word ('all') that distinguishes it from single-entity siblings like entity_delete. It stops short of naming an alternative tool, but the bulk-delete intent 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?

It states a prerequisite ('Requires root edit context') which is useful, but gives no explicit guidance on when to use this versus entity_delete or how it interacts with model_undo. Usage is only implied by the scope word 'all'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the full safety profile is covered without the description. The description adds no behavioral context beyond confirming these are 'saved' scenes; it neither contradicts nor enriches the annotations.

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

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

A single, front-loaded sentence with zero filler. Nothing is repeated from the schema or annotations, and there is no ambiguity to resolve.

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

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

For a zero-argument list tool this is close to sufficient, but with no output schema the agent is not told what a scene entry contains (name, index, description) or how scenes are referenced by siblings like scenes_set. That identifier information is what an agent would need to chain this call.

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 takes zero parameters, so the baseline is 4. There are no parameter semantics for the description to clarify, and it correctly avoids describing nonexistent arguments.

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 clear verb ('List') and resource ('saved SketchUp scenes'), so an agent immediately knows this is a read of scene data. It does not differentiate itself from its closest siblings (scenes_set, scene_clear), relying on the name alone to do that work.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites or exclusions, and no pointer to the related scenes_set/scene_clear tools. The usage is only implied by the tool name and the verb 'List'.

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

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

Annotations already declare this is a non-read-only, non-destructive, non-idempotent write, so the safety profile is covered. The description adds the save/update/select modes, but says nothing about what 'update' overwrites, whether re-selecting is reversible, or any authorization requirement. With annotations carrying the safety burden, this is adequate but thin.

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 compact sentence that front-loads the primary action, with zero filler. It is efficient, though the terseness comes at the cost of the missing detail noted in other dimensions.

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

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

For a 4-parameter tool with 0% schema coverage and no output schema, the description is too thin. An agent cannot infer what model_id scopes, what active_path is, or what happens to an existing scene on update.

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% across 4 parameters, so the description must compensate but largely does not. The words 'save/update' and 'select' loosely map to the action enum, but name, model_id, and active_path are never explained in the 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 states a specific verb and resource ('Save/update the current view as a scene, or select an existing scene'), and it distinguishes the two modes (save vs select). It does not explicitly name sibling tools like scenes_list or scene_clear, so no sibling differentiation is present beyond the resource name.

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 dual purpose hints at when each mode applies (create/update vs. select), but there is no explicit guidance on when to use this versus scenes_list, scene_clear, or model_save. Usage is implied rather than stated, no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds only the word 'current', hinting that it reads live state, but says nothing about return shape or behavior on an empty selection. With annotations carrying the load, a 3 is appropriate.

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 short sentence with no filler, front-loaded with the verb and resource. It is appropriately sized for a zero-parameter getter, though it is so terse that it borders on under-information rather than crisp conciseness.

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

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

For a simple zero-parameter read tool with full annotation coverage this is nearly sufficient, but there is no output schema, and the description never hints at what a 'selected entity' record contains (IDs, types, counts) or what happens when nothing is selected. That is a minor but 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?

The tool takes zero parameters and schema coverage is 100%, so the baseline is 4. There is no parameter detail the description needs to supply or could add value with.

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 ('Read') and resource ('current selected entities'), making the get-vs-set distinction with the sibling selection_set reasonably inferable. It stops short of naming or explicitly differentiating itself from any sibling, so it lands at 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 description offers no when-to-use context, no preconditions, and no mention of alternatives such as entity_list, entity_inspect, or selection_set. Usage is only implicitly inferable from the name and 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?

Annotations already declare this is a non-read-only, non-destructive mutation, so the safety profile is covered. The description adds the genuinely useful fact that this replaces the selection and that an empty list clears it, but says nothing about invalid-ID handling, model scoping, or what active_path does.

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 tight sentence with the core contract front-loaded and the clear-behavior edge case second. Efficient, though its brevity is partly under-specification rather than pure economy.

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 3-parameter mutation tool with no output schema and zero schema descriptions, the description leaves model_id and active_path undefined and gives no error or return semantics. What is present is accurate but far from 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 0% across three parameters. The description only gestures at entity_ids ('existing entity IDs'); model_id and active_path are entirely unexplained in both schema and description, so the agent has no way to know what active_path (a bounded integer path) means.

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

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

States a specific verb+resource ('Set selection') and the input contract ('existing entity IDs'), which is enough to distinguish it from sibling selection_get. It does not explicitly name that sibling as the read counterpart, so differentiation is left to inference.

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 'using existing entity IDs' implies IDs must already be valid (hinting at entity_list/entity_inspect as the source), but this is never stated. There is no explicit when-to-use, no mention of selection_get as the read alternative, and no exclusions.

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

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

Goes well beyond the annotations, which already declare destructive/openWorld/non-idempotent. It adds UI-thread execution, the ruby_enabled prerequisite, the default transaction rollback-on-failure behavior, stdout capture, and the inability to forcibly cancel — all material 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?

Five terse sentences, each carrying a distinct constraint, with the core action front-loaded. No filler or redundancy.

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

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

For a destructive, open-world code-execution tool with no output schema, the description covers side effects, preconditions, and return-ish behavior (stdout capture). The main shortfall is the undocumented parameters, which the schema does not cover either.

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% across 5 parameters, so the description carries the full burden, yet it only hints at 'transaction' semantics ('Default transaction rolls back failures'). model_id, active_path, and operation_name are entirely unexplained, and the code parameter's expectations are only loosely implied by 'trusted Ruby'.

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 ('Execute trusted SketchUp Ruby on the UI thread') and names the execution context. No sibling tool runs arbitrary code, so it is trivially distinguishable from model_undo/entity_* 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?

Provides a precondition ('Requires ruby_enabled') and a guardrail ('do not start nested SketchUp operations'), which imply when it is safe to call. However, it never states when to prefer this over task-specific siblings (entity_create_box, entity_transform, etc.) nor frames it as an escape hatch for unsupported operations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds only that visibility information is returned, which is a small but real piece of behavioral context beyond the annotations.

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

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

A single five-word sentence with the resource front-loaded and zero filler. It is efficient, though 'and visibility' is slightly terse and could have been made more explicit without adding much length.

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

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

For a zero-parameter, non-destructive list tool with no output schema, the description covers what the tool returns and its scope. The ambiguity about what 'visibility' contains is the only gap, and it is minor at this complexity level.

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 takes zero parameters, so the schema carries no semantics to explain and the baseline is 4. No parameter-level guidance is needed or missing.

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 gives a clear verb+resource ('List tags') and adds that visibility data is included, so an agent knows what it retrieves. It does not explicitly differentiate from the sibling tags_set or from other *_list tools, but the resource 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?

There is no statement of when to use this over alternatives, no prerequisites, and no mention of tags_set as the mutation counterpart. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the safety profile is partly covered. The description adds little: it does not state that a call without an existing tag creates one (an upsert), what happens to visibility when omitted, or how model_id/active_path scope the tag. No contradiction with annotations, but the disclosure gap is large.

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 short sentence, front-loaded with the primary action. It is efficient, though arguably too terse to be genuinely helpful given the parameter complexity.

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

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

For a 4-parameter mutation tool with no output schema and no schema descriptions, the definition is far too thin. It fails to explain the upsert semantics, tag scope via model_id, or the active_path parameter, leaving an agent unable to invoke it confidently.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it names only the implicit tag name and the 'visible' flag. model_id and active_path are undocumented in both the schema and the description, leaving half the parameters opaque.

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 verb (create/set) and resource (tag), which is more than the name alone. However, the description covers only two of the four parameters' concerns ('visible' explicitly) and never explains that this is effectively an upsert keyed by name, so an agent cannot fully predict the operation.

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

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

No when-to-use guidance is offered. The sibling tags_list is the obvious counterpart, but the description never says to use tags_set for mutation vs tags_list for reads, nor when creating a tag is preferred over updating one.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context that the image is returned directly rather than written to a path, but says nothing about image format, resolution limits, or what happens with the viewport.

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

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

Three short sentences, front-loaded with the core action, with no filler. Every sentence contributes (purpose, output behavior, usage timing).

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

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

With five undocumented parameters and no output schema, the description leaves real gaps. It covers purpose and timing adequately for a simple capture tool, but a caller cannot know how to size the image or what model_id/active_path do.

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% across 5 parameters (width, height, model_id, active_path, transparent), and the description mentions none of them. An agent must guess at the meaning of model_id, active_path, and transparent entirely from their names.

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

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

States a specific verb and resource: capturing the current SketchUp view as an image. The phrase 'No output path required' implicitly contrasts it with file-writing siblings like view_export, but it never names that sibling, so differentiation is left to inference.

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?

'Use after modeling to visually verify the result' gives a clear when-to-use context, which is better than nothing. However, it does not name alternatives such as view_export or model_snapshot, nor state when this tool is the wrong choice.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false). The description adds no behavioral context beyond that: it doesn't mention that a file is written to disk, the overwrite policy implied by the schema, or permission/format constraints. With 7 parameters and an overwrite flag, more disclosure was expected.

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 zero filler. It is efficiently written, though its brevity borders on under-specification for a 7-parameter export 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?

For a tool with 7 parameters, 0% schema coverage, and no output schema, the description is far too thin. An agent gets no guidance on required vs optional arguments, output location, resolution bounds, or overwrite behavior.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and does not. It mentions only the image formats, saying nothing about path, width/height bounds, model_id, overwrite, active_path, or transparent.

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 (Export) and resource (PNG/JPG from SketchUp) plus an intent (visual verification), so the core action is unambiguous. However, it does nothing to distinguish itself from close siblings like view_capture or model_export, so an agent cannot tell why it would pick this one over those without opening schemas.

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

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

The phrase 'for visual verification' hints at intent but gives no conditions for when to use this versus view_capture, model_snapshot, or model_export. No prerequisites, no exclusions, no alternative named.

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