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

With no annotations, the description carries the full behavioral burden. It usefully discloses that "to is the exclusive upper bound" and that origin defaults to from, which are non-obvious semantics. However, it says nothing about prerequisites (an open project), which scope the cube is added to, or undo behavior for a mutating operation.

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

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

Front-loaded with the core action, then parameter guidance. Two efficient sentences with the coordinate-system caveat placed where it matters. Little wasted text.

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

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

For a 14-parameter mutation tool with no annotations and no output schema, the description covers the geometry essentials but leaves many parameters undocumented in both schema and text. Adequate but with clear gaps given the complexity.

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

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

Schema description coverage is only 21%, so the description must compensate. It explains from, to, size, origin default, and texture/faces/autouv behavior, but omits name, color, box_uv, parent, inflate, rotation, and uv_offset entirely. Partial compensation over a low-coverage 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?

"Create a cube element" states a specific verb and resource, so the agent can distinguish this from mesh/group/element creation siblings. It doesn't explicitly name an alternative (e.g., bb_add_mesh or bb_add_element), so sibling differentiation is implied rather than stated.

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

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

There is no when-to-use guidance and no alternative named. The only routing-like text is "Provide from+to, or from+size," which is a parameter constraint rather than usage context. An agent gets no help deciding between this and bb_add_element/bb_add_mesh.

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

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

With no annotations, the description carries the full behavioral burden. 'Pass its properties directly' hints that the properties object is passed through unvalidated, but nothing is said about required project/parent context, side effects, undo integration, or return values (no output schema exists either).

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

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

Two short sentences with the actionable type list front-loaded and no wasted wording. The trailing 'Pass its properties directly' is under-specified rather than verbose, but it is brief enough not to harm readability.

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 creation tool with a nested properties object, no annotations, no output schema, and zero schema-level parameter docs, the description is too thin. An agent still lacks guidance on required context, valid property keys, and what is returned or how the new element 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%, so the description must compensate. It substantially helps for the required 'type' parameter by enumerating the six valid values (the schema has no enum), but 'name', 'parent', and the nested 'properties' object remain unexplained beyond the vague 'pass its properties directly'.

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 (Create) and enumerates the specific element types it handles (locator, null_object, bounding_box, texture_mesh, armature, armature_bone), which distinguishes it from siblings like bb_add_cube and bb_add_mesh. The scope is specific, though it doesn't explain how these 'special elements' relate to the mesh/cube creation siblings.

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

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

The description says what can be created but never states when to choose this tool over bb_add_cube, bb_add_mesh, or bb_add_group, nor any prerequisites (e.g. an open project or an existing parent). Usage is only implied by the type 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?

No annotations are provided, so the description carries the full burden. It discloses that the created group is empty, but says nothing about undoability, persistence, name uniqueness, parent-child semantics, or what happens when a parent is supplied.

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 creation purpose followed by the one positional hint. No filler.

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

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

For a four-parameter mutation tool with zero annotation coverage, no output schema, and 0% schema descriptions, the definition covers only one parameter and none of the behavioral risks. Substantially incomplete.

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

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

Schema description coverage is 0% across four parameters. The description only clarifies origin ('Position it with origin'), leaving name, parent, and rotation 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?

The description gives a specific verb (create) and resource (empty group/bone) and clarifies the resource's role: holding elements or driving animation. It implicitly distinguishes from bb_group_elements (which groups existing elements), though it never names that sibling 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?

Usage is implied by 'to hold elements or drive animation,' and it hints that origin sets position, but there is no when-to-use/when-not guidance and no reference to alternatives such as bb_add_element or bb_group_elements.

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

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

With no annotations at all, the description carries the full burden, and it does add genuinely useful behavioral detail: x/y/z accept Molang expressions (default "0") or plain numbers, and the bone can be addressed by group name or uuid. However it says nothing about whether existing keyframes are overwritten, what happens if no animation is supplied, error conditions, or persistence — significant gaps for a mutation tool with zero 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?

Two tight sentences with no filler, front-loading the core action. It is efficient, though arguably too sparse for an 8-parameter 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 an 8-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description addresses only about half the parameters and omits how the animation/time context is resolved and whether the write is additive or destructive. It is under-specified for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the semantics of x, y, z (Molang expressions with a default) and bone (group name or uuid) and implies the channel enum values, but leaves time, animation, and interpolation (including its default) completely unexplained.

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

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

States a specific verb (add) and resource (keyframe) plus the target (a bone) and the channels affected (rotation/position/scale), which cleanly separates it from the sibling bb_delete_keyframe. It does not name or contrast any alternative tool, so it falls 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 guidance on when to use this versus bb_delete_keyframe, bb_set_animation, or bb_create_animation, nor any prerequisite such as needing an existing animation. Usage is only inferable from the verb.

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

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

No annotations, so the description carries the full burden. It does usefully disclose the internal data formats (per-vertex UVs, keyed vertex maps, face variants), which is real behavioral value. However, it says nothing about edit-mode requirements, permissions, return values, or what happens to any existing mesh.

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 tight sentences with the core action front-loaded, then format detail. No filler. Slightly dense prose but every clause carries 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 7-parameter mutation tool with no annotations and no output schema, the description covers the two critical data-format params well but leaves the remaining five params and all behavioral aspects (mode, side effects, return) unexplained.

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

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

Schema coverage is 0% and the schema for vertices/faces is empty ({}), so the description genuinely compensates by fully specifying those two formats — a real contribution. But five parameters (name, origin, parent, texture, rotation) are undocumented in both the schema and 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?

States a specific verb+resource: 'Create a free-form mesh.' The word 'free-form' implicitly separates it from bb_add_cube, but it never names that or any sibling explicitly, so the distinction is left for the agent to infer.

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 at all. With siblings like bb_add_cube, bb_add_element, and bb_edit_mesh available, the description should say when a free-form mesh is preferred, but it offers nothing about context or alternatives.

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

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

No annotations exist, so the description carries the full behavioral burden. It discloses the naming/index behavior ('names may contain {i} and starts at 1'), which the schema does not, but omits whether originals are retained, permission prerequisites, reversibility, and what select_originals does for this mutation 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?

Two sentences, front-loaded with the core purpose before the example list. Some minor filler ('and so on') and a slightly awkward trailing clause about names, but overall efficient.

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

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

For a 7-parameter mutation tool with 43% schema coverage, no annotations, and no output schema, the description leaves a majority of parameters and the create/retain semantics undocumented. It is not complete enough for correct invocation.

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

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

Schema description coverage is only 43%, so the description is expected to compensate but largely does not. It clarifies the names template ('{i}', starting at 1), yet axis, vector, targets, and select_originals are unexplained, and 'along a grid' only vaguely implies how axis/offset/vector interact.

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 repeated copies of elements') plus the mechanism ('along a grid'), with concrete examples (windows, treads, spokes) that make the intent unmistakable. It edges toward distinguishing itself from sibling duplication tools, but never names the closest alternatives like bb_duplicate_elements.

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

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

Provides a real when-to-use scenario ('build rows of windows, treads, spokes ... instead of placing copies by hand'), which is genuine context. However, it never routes the agent against sibling tools (bb_duplicate_elements, bb_mirror_elements, bb_transform_elements) that overlap, and gives no when-not conditions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the mode mapping but not whether existing UVs are overwritten, whether the operation is undoable (a bb_undo sibling exists), or what happens to targets not eligible for auto-UV. The title 'Regenerate UVs' also conflicts mildly with the description's 'Set ... mode' framing.

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 compact sentence with the operation front-loaded and the mode options enumerated with their internal mappings. No filler, though the semicolon-dense format slightly hurts scanability.

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 no annotations, no output schema, an undocumented required 'targets' object, and no mention of reversibility or side effects. The description covers only the mode vocabulary, not enough for an agent 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% and there is no enum on mode, so the description's enumeration of faces/relative/box/off with their underlying autouv/box_uv values is genuinely valuable. However, the required 'targets' parameter is an empty, undocumented object that the description never explains, leaving a critical 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+resource ('Set automatic UV mode on cubes') that is distinguishable from siblings such as bb_set_face_uv (manual per-face UV) and bb_generate_texture. It does not explicitly name a sibling, which keeps it short of a 5.

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

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

No statement of when to use this tool versus bb_set_face_uv or other UV tools, and no prerequisites (e.g. selection state, cube-only scope). The mode list describes options but not 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the information surfaced (port, file path, schema provenance) and the word 'Check' implies a non-mutating read, but it never explicitly states that the call has no side effects, requires no authentication, or is safe to repeat.

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, no filler. The diagnostic scope comes first and the activation condition is front-loaded at the end, so the agent gets both the 'what' and the 'when' immediately.

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 does the necessary work of naming the returned fields (port, connection path, schema source). It is close to complete for a zero-param diagnostic, missing only a note on how it differs from bb_status/bb_setup.

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 in the schema the description needs to explain or compensate for.

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 diagnostic verb ('Check whether') and enumerates the resources inspected: connection state, listen port, connection file path, and schema origin. The scope is clear enough to call correctly, though it never distinguishes itself from the closely named sibling bb_status.

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

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

Gives an explicit trigger: 'Call this first when any bb_* tool reports "not connected".' That is a clear when-to-use condition. It does not, however, compare against bb_setup or bb_reconnect, which an agent might reasonably reach for in the same failure scenario.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose allowed loop values and that length is in seconds, but it never says whether creation requires an active project, whether the animation is auto-selected, what happens to existing animations, or what the mutation returns. For a write operation with zero annotation coverage this is a significant gap.

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

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

Two short sentences with the purpose front-loaded and no filler. The parameter details are compactly attached, though they are somewhat terse and inline rather than structured, which keeps it just short of ideal.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is too thin for a four-parameter mutation tool. It omits what name and select do, whether a project context is required, and what the call returns, so an agent lacks enough information to invoke this 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 must compensate. It usefully documents two of four parameters: loop’s allowed values ('once', 'loop', 'hold') and length’s unit (seconds). But name and select receive no explanation in either the schema or the description, leaving half the parameters semantically 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?

The description states a specific verb and resource: 'Create a new animation.' This clearly distinguishes it from siblings like bb_delete_animation, bb_list_animations, bb_play_animation, and bb_set_animation. However, it does not explicitly name or contrast against those alternatives, which is what a 5 would require.

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 (e.g., must a project be open?), and no mention of alternatives or conditions for choosing this tool over bb_set_animation or bb_add_keyframe. The description only states what the tool does, leaving usage entirely to inference.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the texture is blank by default and that size falls back to the project texture resolution, but it says nothing about the side effect implied by select (default true) potentially changing the current selection, nor about undo behavior or permissions.

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, and every clause carries information the schema does not. No filler.

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

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

For a mutating creation tool with no annotations, no output schema, and 0% parameter coverage, the description is too thin. It omits the meaning of name and select, the effect on selection state, and any indication of what is returned or how to undo.

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

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

Schema coverage is 0%, so the description must compensate. It covers fill ('optionally filled with a colour') and size/width/height (defaults to project texture resolution), but leaves name and select entirely undocumented, so three of five parameters still have no semantic explanation anywhere.

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

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

States a specific verb and resource ('Create a blank texture') and adds the distinguishing qualifier 'blank', which separates it from siblings like bb_generate_texture, bb_draw_texture, and bb_import_texture. It does not name those siblings, but the purpose is unambiguous.

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

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

There is no guidance on when to use this versus bb_generate_texture or bb_draw_texture, and no prerequisites or exclusions are stated. The only usage hint is 'optionally filled with a colour', which is weak routing information.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a destructive removal but does not say whether the deletion is undoable via bb_undo, what happens to the animation's keyframes, or what occurs if the named animation does not exist.

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

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

A single efficient sentence with the action front-loaded and no filler. It is appropriately sized for a one-parameter tool, though it is arguably too terse to earn a top mark.

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 operation with no annotations, no output schema, and an undocumented identifier parameter, the description omits the information an agent needs to call it safely and correctly. Undo behavior and error conditions are 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 coverage is 0% and the single required 'animation' parameter is an undocumented string. The description adds nothing about whether this expects an animation name, an index, or an ID, leaving the caller to guess the identifier format.

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 (remove) and resource (animation) and scopes it to 'the project'. However, it does not differentiate itself from the closely related sibling bb_delete_keyframe, so an agent must infer the distinction from the name alone.

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 alternatives such as bb_delete_keyframe or bb_set_animation, nor any stated preconditions (e.g. animation must exist, animation must not be playing). The description is a bare statement of effect.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one important trait: the cascade behavior where deleting a group also deletes its children. However, it says nothing about irreversibility, whether an undo is available, permission requirements, or what happens to references to deleted elements.

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 destructive scope note is placed immediately after the verb. It is efficient, though terse enough that brevity shades into under-specification.

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 annotations, no output schema, and 0% parameter coverage, the definition is far too thin. An agent cannot determine accepted target formats, whether the operation is reversible, or what the tool returns.

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

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

The single required parameter 'targets' has an empty schema with 0% description coverage (no type, no structure), and the description never mentions it. The parenthetical at best hints that targets may be groups or elements, which is a thin semantic contribution against a completely undocumented parameter.

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

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

States a clear verb+resource ('Delete elements') that distinguishes it from sibling delete tools like bb_delete_path, bb_delete_texture and bb_delete_keyframe. The parenthetical scope note sharpens the operation further. It does not, however, explicitly route the agent away from overlapping tools such as bb_set_element or bb_undo.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as bb_undo or how this differs from other destructive siblings. The agent must infer all usage context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a deletion but does not state whether the change is reversible, whether undo is available, what permissions are needed, or what side effects occur on the owning animation or channel.

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

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

The description is a single front-loaded sentence with no filler. It communicates the action and the two target-selection modes efficiently.

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 five-parameter deletion tool with no annotations and no output schema, the description is under-specified. It leaves out the animation parameter, safety/reversibility details, and the interaction between uuid and time, which an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% across five parameters. The description mentions uuid, time, bone, and channel, but it omits the animation parameter entirely and does not explain channel default behavior, uuid/time precedence, or expected formats.

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

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

The description states a specific verb and resource: delete a keyframe. It also distinguishes two identification modes, by uuid or by nearest time on a bone/channel, which cleanly separates it from siblings like bb_add_keyframe and bb_delete_animation.

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

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

The description explains two ways to identify the target keyframe, but it does not state when to use this tool versus alternatives such as bb_delete_animation, nor does it provide prerequisites or exclusions. Usage is only implied by the operation itself.

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

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

With no annotations, the description carries the full burden; it usefully discloses the file-system permission requirement, which an agent must know. However, it omits key destructive-tool behavior: whether deletion is permanent/recoverable, what happens on a nonexistent path, and whether an undo path exists despite the sibling bb_undo.

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 zero waste; the condition for directory deletion immediately follows the core action.

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

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

For a destructive two-param tool with no annotations and no output schema, the description covers the action, the recursive branch, and the permission prerequisite, but leaves irreversibility, error behavior, and undo/alternative tooling 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 coverage is 0%, so the description must compensate. It explains 'recursive' in behavioral terms (directory deletion), but adds no format, path-resolution, or default semantics beyond the schema's own default:false, leaving 'path' undocumented.

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

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

States a specific verb ('Delete') and resource ('file', 'directory') and clarifies the branching behavior for directories. It is clearly distinct from file-reading siblings like bb_read_file/bb_list_dir, though it does not explicitly name any sibling it should be chosen over.

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 implies the recursive=true condition for directories, which is useful conditional guidance, but offers no when-to-use/when-not-to-use framing, no references to alternatives (e.g. bb_undo or bb_delete_elements), and no prerequisites beyond permission.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose whether deletion is destructive/permanent, whether it requires confirmation, how textures in use are handled, or what happens to assignments referencing deleted textures.

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 short sentence with no waste and the action front-loaded. Concise, though arguably too terse given the gaps 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?

A destructive mutation tool with no annotations, no output schema, and an undocumented required parameter. The description is far too thin to safely and correctly invoke this tool.

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

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

Schema description coverage is 0% and the single required parameter 'targets' is completely undocumented in both schema and description. The description adds no meaning about what a target is or what form it 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?

States a clear verb (remove) and resource (textures) with scope (from the project). Sibling tools like bb_delete_elements, bb_delete_path, and bb_delete_animation make the resource noun necessary to distinguish, and it does that, though it's a fairly generic statement.

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 like bb_delete_elements or bb_set_texture_properties, and no mention of prerequisites or cautions. The description leaves the agent to infer context entirely.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses that the operation is additive and mutates existing content, but says nothing about permissions, reversibility (bb_undo exists), rate limits, or whether ops can overwrite prior content. This is thin for a mutation 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?

Two tightly worded sentences with the key scope constraint front-loaded and zero filler. Appropriately sized for the operation.

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

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

For a 3-param mutation tool with no annotations and no output schema, the description conveys the high-level behavior and a useful cross-reference, but leaves the seed parameter and the op payload structure unexplained. Adequate minimum but with clear gaps an agent would need to resolve.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely describes 'ops' (a list) and 'target' (an existing texture) but never explains the op object format or the 'seed' parameter at all. The pointer to bb_generate_texture for op format is the only help, leaving two of three params effectively undocumented.

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

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

States a specific verb (apply ops) and resource (existing texture) and clarifies the additive semantics with '(adds to what is already there)'. It implicitly distinguishes itself from bb_generate_texture, though it does not name that sibling as the 'not this' alternative as explicitly as a 5 would require.

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?

Usage is only implied: the parenthetical 'adds to what is already there' hints this is for modifying rather than creating, pointing the agent toward bb_generate_texture for new textures. There is no explicit when-to-use/when-not statement or named alternative, so the agent must infer the split.

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

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

With no annotations, the description carries full behavioral burden and does disclose one real trait: groups bring their children along. But it says nothing about how axis and vector interact, whether copies are linked/instanced, whether the operation is undoable, or what 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 short sentences, front-loaded with the core action and the group caveat. No filler, though it is arguably too sparse for the parameter surface it fronts.

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 five-parameter mutation tool with no annotations, no output schema, and zero schema descriptions requires far more from the description than this. The group-copy note is the only substantive detail; axis/vector/targets handling is entirely absent.

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

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

Schema coverage is 0% across five parameters, so the description must compensate and largely does not. 'Repeat and offset' loosely gestures at count/offset, but axis vs vector, the numeric meaning of offset, and the shape of 'targets' are all undocumented.

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

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

States a specific verb (copy/duplicate) and resource (elements), plus a useful nuance that groups copy their children. However, it does not distinguish itself from closely related siblings like bb_array_elements or bb_mirror_elements, which plausibly cover the same repeat/offset territory.

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 alternatives named. The phrase 'optionally repeat and offset each copy' describes capability, not when an agent should pick this tool over bb_array_elements or bb_mirror_elements.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses in-place mutation, the append-vs-overwrite distinction of merge, and key-based deletion. However, it does not say whether redefining geometry discards existing faces not listed, whether faces indices/UVs are preserved, or whether the operation is reversible (bb_undo exists but is not referenced).

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

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

Four dense sentences, front-loaded with the core action and mode semantics, with no filler. The key-discovery pointer is efficiently packed into the final sentence.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description covers the mode logic and key lookup well, but leaves 'target' unspecified and omits failure/destructive semantics. Adequate but leaving meaningful inference to the agent.

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

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

Despite only 33% schema description coverage, the description supplies meaning for nearly every parameter: vertices, faces, merge, delete_faces, and delete_vertices are all explained in prose. The required 'target' parameter is left unexplained, which is the one clear 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 opens with a specific verb+resource: 'Modify an existing mesh in place', which clearly distinguishes editing from siblings like bb_add_mesh or bb_add_cube. It stops short of explicitly naming the alternative tools, but the purpose is unambiguous.

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

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

It states the two operating modes clearly: vertices+faces redefine geometry, while merge:true appends, and delete_faces/delete_vertices remove by key. It also routes the agent to bb_list_elements {include_geometry:true} to discover keys. No explicit when-not-to-use or sibling comparison, but the mode selection guidance is solid.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses async execution, full global access, Node module availability, mandatory return values, console capture, and injected api helpers. It still omits details such as sandboxing, error handling, and side-effect persistence.

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

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

The description is front-loaded with purpose and usage before moving into behavioral details and the api helper list. It is appropriately sized for a powerful, complex tool, though the helper enumeration is dense.

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

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

Given the high-complexity execution tool, no annotations, and no output schema, the description is largely complete: it explains what the code can access, how return values work, and how console output is handled. It could still say more about error behavior or execution constraints.

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

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

Schema coverage is 100% for the single code parameter, so the schema already explains the parameter. The description adds meaningful context beyond the schema by describing the injected api helpers and the return-value behavior.

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 arbitrary async JavaScript inside Blockbench. It explicitly names the tool as the escape hatch for anything the structured tools do not cover, which clearly distinguishes it from its many siblings.

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

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

It gives clear usage context: use this for anything the structured tools do not cover. This implicitly says when not to use it, but it does not name specific sibling alternatives or provide more detailed routing conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that output is written to disk (a mutation) but says nothing about overwrite behavior, required permissions, failure modes, or whether the project state is modified. For a disk-writing tool this is a significant gap.

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

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

Two sentences: the action is front-loaded and the format list is compact and information-dense. 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?

No annotations, no output schema, and only partial parameter documentation for a tool that writes files to disk. An agent still lacks overwrite semantics, error behavior, and whether a return value (e.g., written path) exists.

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

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

Schema coverage is only 33% — only `options` is documented. The description partially compensates by enumerating valid `format` values (which are not constrained by an enum in the schema), but `path` semantics (extension, relative vs absolute, overwrite) are left 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 (compile/write) and resource (the project/model) and names the destination (disk). The enumerated format list makes the tool's output scope unambiguous and distinguishes it from bb_save_project and bb_export_texture.

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 format list implies when this tool applies (converting the project to an external representation), but the description never says when to prefer it over bb_save_project or what preconditions exist. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that it writes files to disk, but omits whether existing files are overwritten, whether directories are created, and what permissions or active-project state are required. For a filesystem-writing tool this is a notable gap.

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

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

Two tight sentences, front-loaded with the effect (writes PNGs) followed immediately by the two invocation patterns. 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?

No output schema, no annotations, and 0% parameter coverage mean the description is the only source of truth. It covers the main flow but leaves include_data_url, overwrite behavior, and error conditions unexplained.

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

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

Schema coverage is 0%, so the description must compensate. It explains the target/path/dir relationship well, but ignores the include_data_url parameter entirely, leaving one of four parameters with no semantics anywhere.

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: writes texture PNGs to disk. Clearly distinguishable from siblings like bb_export_model and bb_save_project, though it doesn't name them. The purpose is unambiguous.

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

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

The description explains the two invocation modes (single target+path vs. several targets+dir), which is implied usage guidance. However, it never states when to choose this over alternatives like bb_save_project or bb_export_model, nor any prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the permission requirement and the shape of the result, but says nothing about failure modes (e.g. whether a nonexistent path errors or simply reports exists=false) or whether it follows symlinks – gaps that matter for a stat operation.

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

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

Two short clauses, front-loaded with the action and its outputs, with no filler. It is terse rather than verbose, which is appropriate but leaves no room for the missing usage detail.

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

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

For a one-parameter read-only tool with no output schema, disclosing the returned fields inline is a reasonable substitute. Still, no error semantics and no path-format guidance leave it only minimally complete for an agent deciding between it and bb_read_file/bb_list_dir.

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

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

Schema coverage is 0%: the single "path" parameter has no description in the schema. The description only says "a path," without clarifying whether it expects an absolute path, a path relative to the project root, or a file vs directory, and the sibling tools mix project-scoped and filesystem concepts, so this ambiguity is real.

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?

"Stat a path" gives a specific verb and resource, and the enumeration of returns (exists, type, size, modified time) marks it clearly as metadata-only, distinguishing it in practice from bb_read_file and bb_list_dir. It never names those siblings explicitly, so the differentiation is inferential rather than stated.

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

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

The description supplies one useful precondition ("Needs file-system permission"), which tells the agent this may fail without a grant, but it gives no when-to-use guidance relative to bb_read_file, bb_list_dir, or bb_request_fs. Usage is implied by the verb "stat" rather than explained.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that output is deterministic for a given seed and that ops are an ordered list, but it does not explain side effects such as whether a new texture is added to the project, selected, or returned, nor does it cover permissions or reversibility.

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

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

The description is front-loaded with purpose, then determinism, presets, ops, and an example. The long preset and op lists consume space but are necessary reference material rather than fluff. The structure is dense but efficient.

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

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

Given 8 parameters, no annotations, no output schema, and low schema description coverage, the description supplies the core procedural recipe syntax. However, it omits return behavior, side effects, and meanings for several parameters, leaving gaps an agent must infer before calling the tool reliably.

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

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

Schema description coverage is only 13%, so the description must compensate, and it does so for the most complex parameters. It lists all preset names, enumerates op names, and gives a concrete example showing op payload fields such as color, color2, scale, octaves, and strength. It still leaves width, height, name, select, and include_data_url largely unexplained.

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

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

The description states a specific verb and resource: "Paint a new texture from a preset and/or an ordered list of ops." This clearly communicates procedural texture generation. It does not explicitly differentiate itself from sibling tools such as bb_create_texture or bb_draw_texture, 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 an example invocation, which shows how to use the tool, but it never says when to choose this tool over alternatives like bb_create_texture, bb_draw_texture, or bb_paint_pixels. There is no when-to-use, when-not-to-use, or alternative-routing guidance.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the return shape ('rows of [r,g,b,a]'), which is real behavioral value, but omits coordinate origin/convention, out-of-bounds behavior, and texture-target semantics.

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

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

Two short sentences with zero waste; the core action is front-loaded and the return format is attached where it matters.

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, and while the return format is described, the five undocumented parameters (especially the required, untyped 'targets') and the absence of any annotation coverage leave significant gaps for calling this correctly.

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

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

Schema description coverage is 0% across five parameters, and the description does not compensate: x, y, w, h are only implied by 'rectangle', and the required 'targets' parameter is never explained at all. An agent cannot determine valid values for targets from this 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?

States a specific verb+resource ('Read a rectangle of pixels from a texture') and adds a downstream purpose ('verify what was drawn'). It is distinguishable from siblings like bb_draw_texture and bb_paint_pixels, though it never names them explicitly.

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

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

Provides one implied usage context ('verify what was drawn'), which is better than nothing, but gives no when-not conditions, no prerequisites, and no mention of alternative read paths (e.g. bb_screenshot).

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses recursion and the file-system permission requirement, but says nothing about the default limit of 200, truncation/pagination behavior, symlink handling, or what happens when nothing matches.

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 compact sentences; the core action is front-loaded and the permission caveat is a short trailing clause. No filler.

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

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

For a 3-parameter tool with no output schema and no annotations, the description covers the essentials of what and how, but omits result-limiting behavior and error/empty-result semantics that an agent would need to call it reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies 'path' as a directory and 'pattern' as a glob with examples, but leaves the 'limit' parameter (default 200) 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+resource ('recursively find files') plus the matching semantics, with concrete glob examples ("**/*.json", "*.png"). It is distinguishable from bb_list_dir and bb_read_file, though it never names those siblings 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?

The glob examples imply the intended use case (pattern-based discovery vs. simple listing), and the permission prerequisite is stated. However, there is no explicit when-to-use guidance or comparison against bb_list_dir/bb_file_info for the same directory.

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

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

With no annotations, the description carries the full burden, and it does disclose real behavioral traits: it creates a group, positions it at the elements' centre, and moves the elements into it, indicating a mutation with positioning side effects. However, it omits permission/auth requirements, what happens to pre-existing groups, and error behavior, so it is only partially complete.

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 well-formed sentence with the core action front-loaded and zero filler; every clause carries 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 mutation tool with no annotations, no output schema, and 0% parameter coverage, the description explains the core operation adequately but leaves the 'name' parameter and error/edge-case behavior 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% and the description does not mention the 'name' parameter at all — it is only faintly implied by 'Create a new group'. 'targets' is gestured at via 'the given elements', but neither parameter is meaningfully documented beyond what the schema already shows.

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: creates a new group around given elements and moves them into it. It implicitly differentiates from bb_add_group (which likely adds to an existing group), but never names that sibling, so the 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?

No when-to-use, when-not-to-use, or alternative guidance. The agent must infer from the description alone that this is for creating a fresh group versus bb_add_group, with no explicit routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a data-loading mutation but does not state whether the originating file must exist, what happens if both 'path' and 'data_url' are provided, the supported image formats, or where the resulting texture is placed. This is a significant gap for an unannotated tool.

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

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

A single, efficient sentence with no wasted words. It is front-loaded with the core action and format, though it is arguably under-specified rather than 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 3-parameter tool with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It omits parameter behavior, requiredness (0 required means the agent must guess), error conditions, and how the imported texture interacts with siblings, leaving the agent inadequately equipped to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate for all three parameters. It only vaguely hints at 'disk or a data URL', mapping to 'path' and 'data_url', but does not explain the 'name' parameter or the mutual exclusivity/priority between path and data_url. None of the parameters are meaningfully documented.

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 ('load an image as a project texture'), which is clearer than the tautological title 'Import a texture'. However, it doesn't distinguish this from sibling tools like bb_create_texture or bb_generate_texture, leaving the agent to infer where imported images differ from created ones.

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 or mention of alternatives. The agent is not told how this differs from bb_create_texture, bb_generate_texture, or bb_draw_texture, all of which appear to produce textures. 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?

With no annotations, the description carries the burden and does disclose important side effects: the code is written to the plugins folder, recorded for startup loading, loaded immediately, and executes third-party code inside Blockbench. It does not cover overwrite behavior, permissions, or error handling, but the core mutation behavior is clear.

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 tightly written sentences with no filler. The primary purpose is front-loaded, followed by persistence and execution behavior, and the security-relevant note is clearly placed at the end.

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 no-annotation, no-output-schema install tool, the description gives enough context to understand the main side effects and security implication. It could be more complete about overwrite behavior and prerequisites, but it covers the essential install 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?

Schema description coverage is 80%, so most parameters are already documented in the schema. The description reinforces the code/path/url source distinction but adds little beyond the schema for id and version.

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: install a Blockbench plugin. It also distinguishes the supported source forms (source code, local file, URL), which separates it from siblings like bb_uninstall_plugin, bb_reload_plugin, and bb_list_plugins.

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

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

The description implies when to use the tool by naming install sources, but it does not explicitly say when to prefer it over bb_execute_js, bb_reload_plugin, or bb_uninstall_plugin, nor does it state prerequisites or exclusions. Usage is inferable but not well guided.

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

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

With no annotations, the description carries the full behavioral burden. It confirms the listing returns id and name, but says nothing about the limit parameter's truncation behavior (default 60 implies a cap that isn't explained), result ordering, or whether the list is live from the editor state.

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 resource and scope front-loaded and zero filler. It is appropriately short for a simple list tool, though brevity here comes at the cost of the missing details noted above.

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 low-complexity, zero-required-parameter read tool with no output schema, the description is minimally adequate: it says what is listed and what fields come back. The unexplained limit semantics and absent tie-in to bb_run_action leave real gaps for a 0%-coverage schema.

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

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

Schema coverage is 0% and neither parameter is described in the schema. The description mentions filtering but not whether 'filter' matches id, name, or both, and 'limit' is never referenced at all despite its 60 default suggesting truncation.

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 ('List runnable Blockbench actions (BarItems) by id and name'), and clarifies what is returned. It does not name the obvious sibling bb_run_action, so the agent must infer that this enumerates what that tool executes.

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?

Only 'optionally filtered' hints at usage; there is no statement of when to call this versus bb_run_action or any prerequisite/context. An agent can infer the discovery-then-execute pattern, but the description never says it.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully discloses what the output contains (loop mode, length, per-bone keyframe counts) and implies a safe read, but says nothing about permissions, scoping to the active project, or result size/pagination for large rigs.

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 fields are packed in efficiently and 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 simple parameterless list tool with no output schema, describing the returned fields (loop mode, length, per-bone keyframe counts) covers most of what an agent needs. Only scoping and pagination caveats are missing.

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. The description correctly implies it operates on the whole current project with no filtering 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 specific verb+resource ('List the project animations') and even previews the returned fields, which distinguishes it from mutation siblings like bb_create_animation, bb_set_animation and bb_play_animation. It does not explicitly name those siblings, but the read-only list 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?

No when-to-use guidance, no mention of alternatives (e.g., use bb_play_animation to preview instead of list, or bb_add_keyframe to modify), and no prerequisites. The agent is left to infer that this is a read-only inventory call.

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

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

With no annotations, the description carries the full burden and does disclose a key behavioral prerequisite: the plugin file-system permission, the one-time user prompt, and the role of bb_request_fs. However, it omits other behavioral traits such as read-only nature, default limit behavior, output shape, and error handling.

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

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

The description is three short, front-loaded sentences with no filler. The core action is first, followed by the permission prerequisite and the supported options.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description is only partially complete. It addresses the permission requirement and two optional features, but does not explain the limit parameter, return value structure, or edge-case 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 explain all four parameters. It covers 'recursive' and 'filter' (as a glob filter) but leaves 'path' and especially 'limit' without additional semantic detail 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?

The description states a specific verb+resource ('List the entries of a directory') and adds two capability hints (recursion and glob filter). It is clear, but it does not explicitly differentiate itself from siblings such as bb_glob or bb_file_info.

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

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

The description implies usage by mentioning the file-system permission requirement and that bb_request_fs can trigger the prompt. It does not say when to use this tool instead of alternatives like bb_glob or bb_file_info, nor does it state when not to use it.

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

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

No annotations are provided, so the description carries the full burden; it does disclose the return payload (ids, transforms, optional geometry) which is genuinely useful. However it does not state that this is a read-only/non-mutating operation, nor anything about result size or limits, leaving the safety profile implied by the word "List".

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

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

A single front-loaded sentence with no filler; the resource and return contents come first and the filter capability last. It is efficient, though the terseness leaves some ambiguity that a slightly longer treatment could 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?

With 4 params, no annotations, and no output schema, the description covers the core operation adequately but leaves include_faces undefined and says nothing about the expected shape or volume of results. For an unpaginated list tool this 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?

Schema coverage is only 25%, so the description needs to compensate. It maps reasonably to type, parent, and include_geometry ("optionally geometry"), but include_faces is never referenced and its distinction from include_geometry is left unaddressed, and the value format for parent is 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 (List) and resource (outliner elements) plus what is returned (ids, transforms, optionally geometry). It clearly distinguishes itself from adjacent list tools like bb_list_textures or bb_list_animations, which target different resources.

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?

"Filter by type or parent" implies the intended usage but does not say when to prefer this over alternatives such as bb_select_elements or bb_glob, nor does it state that no filtering returns everything. Usable guidance, but no explicit when/when-not routing.

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

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

No annotations exist, so the description carries the full burden. It discloses the returned fields (id, version, source, install state, reloadability) but never states that this is a side-effect-free read with no mutations, nor any ordering or scope limits. For a zero-param query tool the residual risk is low, so a 3 is fair rather than punitive.

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

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

One sentence, front-loaded with the verb and resource, with the return attributes appended compactly. 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?

No output schema exists, so the description must describe the result itself — and it enumerates exactly which fields come back. For a zero-parameter listing tool this is sufficient for correct invocation.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly implies the tool operates on all plugins with no filtering 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 specific verb ('List') and resource ('Blockbench plugin') and even enumerates the attributes returned. Sibling write operations (bb_install_plugin, bb_uninstall_plugin, bb_reload_plugin) are clearly distinguished by the enumeration-only verb.

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?

Usage is implied rather than stated: an agent infers this is the discovery step before install/reload/uninstall. The mention of 'whether it can be reloaded' hints at the reload workflow but no explicit when-to-use, 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?

No annotations are provided, so the description carries the full burden. It discloses that values returned are the 'current values' and that filter matches ids, which is useful, but says nothing about pagination/limit behavior, result ordering, or the read-only safety profile an agent would want confirmed.

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 purpose, followed by a usage hint and one parameter note. No filler; each clause contributes something, though it is terse.

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 two-parameter list tool with no annotations or output schema, the description gives purpose, a usage cue, and partial filter semantics. It still omits limit behavior and any hint about the returned shape beyond 'current values', leaving gaps.

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

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

Schema coverage is 0%, so the description must compensate. It explains that filter matches the id (adding real meaning), but the limit parameter is left completely undocumented in both the description and the schema.

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

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

States a specific verb (List) and resource (user settings with their current values), which distinguishes it from the many other bb_list_* siblings and from bb_set_setting. The phrase 'by id' is slightly confusing since neither declared parameter is an id, but the core purpose is unambiguous.

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

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

'Handy before bb_set_setting' gives a concrete usage context and points at the complementary write tool. It lacks any when-not guidance or explanation of how to use limit, so it is clear but not exhaustive.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses what each texture record contains (size, UV resolution, layers, saved state), which establishes this as a non-destructive read, but it says nothing about the cost or side effects of requesting embedded data, or about result size/pagination.

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 front-loaded sentence with no filler, and the resource is stated before the payload detail. It is appropriately sized for a simple list tool, though the space spent enumerating return fields arguably belonged to the parameter.

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 one-parameter, no-output-schema listing tool the description is nearly sufficient — it conveys the record shape — but with no annotations and no output schema the agent still cannot tell what include_data_url does or how large the response can get.

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 sole parameter, include_data_url, is not mentioned anywhere in the description even though it materially changes the response (embedding full image data). With only one optional boolean, the omission is the single biggest gap in the definition.

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

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

The description names a specific verb and resource ('List the project textures') and even enumerates the fields returned (size, UV resolution, layers, saved state). It is clearly distinguishable from mutation siblings like bb_create_texture or bb_delete_texture, but it never contrasts itself with the other read-oriented listers (bb_list_elements, bb_list_animations), so it stops short of full sibling differentiation.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The agent can infer it is a read-only listing from the verb, but nothing tells it when this is preferable to bb_project_info or a targeted query.

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

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

With no annotations, the description carries the full disclosure burden. It usefully notes that copy=true duplicates first and that 'meshes keep correct winding', but says nothing about whether copy=false mutates existing geometry in place, whether the operation is undoable, or how targets must be selected.

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, each earning its place, with the core action front-loaded ahead of the copy-mode caveat and the winding note. No filler.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description covers the geometric behavior well but leaves the required targets parameter and the mutation/undo semantics unaddressed. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does: it clarifies the x-axis/plane=0 defaults and the semantics of copy. However the required 'targets' parameter is entirely undocumented (untyped in the schema, unexplained in 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 specific verb and resource: 'Reflect elements across an axis-aligned plane (default x=0)'. The reflection action is inherently distinct from neighbors like bb_transform_elements, bb_duplicate_elements and bb_array_elements, so an agent can identify the operation without opening the schema.

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?

'copy=true ... is the usual way to build a symmetrical half' gives a useful usage cue for one parameter, but the description never states when to prefer this tool over bb_array_elements or bb_duplicate_elements, nor any prerequisites. Usage is implied rather than routed.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the default recursion behavior and the permission requirement, but omits what happens if the directory already exists and how failures surface.

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 recursion default immediately following. No filler; nothing to trim for a tool this simple.

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 two-parameter mutation with no output schema and no annotations, the essentials (action, recursion default, permission need) are present, but existing-directory behavior and error semantics are missing, leaving some uncertainty for the agent.

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

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

Schema description coverage is 0% across 2 parameters. The description clarifies the 'recursive' parameter via 'recursively by default' and its default value, but 'path' is left entirely to the schema; partial compensation only.

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

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

States a specific verb and resource ('Create a directory') and adds the recursive-by-default scope, which distinguishes it from path-listing siblings like bb_list_dir and from bb_delete_path. It does not explicitly name alternatives, but the operation 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?

Provides one prerequisite ('Needs file-system permission') but gives no guidance on when to use this over siblings such as bb_write_file (which may implicitly create parents) or bb_request_fs for permissions. Usage is implied by the tool name rather than explained.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the empty-state nature and the required ordering, but does not say what happens if a project is already open (replace vs. error) or what the call returns. That gap is significant for a state-creating 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?

Three tight sentences, front-loaded with the core action, then the format enumeration, then the sequencing constraint. No filler.

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

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

For a 6-parameter, no-annotation, no-output-schema tool, the description covers format and sequencing well but omits behavior on an already-open project and most parameter meanings. Adequate but with clear gaps.

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

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

Schema coverage is only 17%, so the description must compensate. It does explain the most important parameter, format, with concrete id values, but leaves name, box_uv, texture_width, and texture_height 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 and resource ("Create a new empty Blockbench project") and implicitly distinguishes itself from bb_open_model by naming it as the alternate entry point. An agent can tell it apart from 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?

Explicitly gives the when-to-use rule ("Always call this ... before building, unless a project is already open") and names the alternative (bb_open_model). Nothing about sequencing is left to inference.

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

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

With no annotations, the description carries the full burden. It implies a transient, non-blocking UI display ('toast / quick message') but says nothing about whether the call waits for the user, what it returns, or how it behaves if Blockbench is unfocused. Key behavioral traits are left to inference.

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

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

Two short sentences, front-loaded with what the tool does before how to use it. No filler, though the second sentence could be tightened.

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 three-parameter UI tool with no output schema, the description adequately conveys purpose and usage. However, in the absence of annotations and with zero parameter documentation, an agent still lacks the details needed to use icon/expire correctly.

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

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

Three parameters with 0% schema description coverage: 'icon', 'expire', and 'text' are undocumented. 'Text' is inferable from 'toast / quick message', and 'quick' faintly hints at the auto-dismiss behavior of 'expire', but icon type and duration units/semantics are not addressed 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?

States a specific verb and resource ('Show a toast / quick message inside Blockbench'), which is unambiguous. It does not explicitly contrast itself with siblings, but no sibling tool overlaps with user-facing notifications, so the intent is clear.

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

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

Gives positive guidance on when to call it: to tell the human what the agent is doing, or to ask them to look at the screen. No when-not or alternatives are offered, but the use case is narrow enough that none are needed.

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

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

With no annotations at all, the description carries the full burden, and it does disclose the key behavioral trait: operation replaces the current project unless importing. It also explains codec inference from the extension list and points to bb_status for format ids. It stops short of stating failure behavior for unknown codecs or whether unsaved changes are preserved or discarded.

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 dense sentences with the destructive effect front-loaded before the codec detail. No filler, no restating of the name or title.

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?

There is no output schema and no annotations, so the description must stand alone, and for a 3-parameter tool it covers load semantics, replace/merge behavior, and codec resolution adequately. It lacks any statement of what is returned or how errors (bad path, unsupported codec) surface.

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

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

Schema coverage is 67%, and the description compensates: it enumerates the recognized extensions that drive inference for path, points to bb_status as the source of valid format ids, and restates the merge-vs-replace meaning of import_to_current. Format remains an open string with no enum, so ids are still not resolvable from this definition alone.

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

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

States a specific verb and resource ("Load a model from disk") plus the scope of the effect (replacing the current project or importing into it), which separates it from bb_new_project and bb_save_project. It does not name any sibling explicitly, so sibling differentiation is inferential rather than stated.

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

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

Gives clear selection context: replace by default, or set import_to_current to merge into the open project. It also explains how the codec is chosen (extension inference vs. the format parameter), but offers no exclusions or prerequisites, such as what happens to unsaved work or unsupported extensions.

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

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

With no annotations, the description carries the full behavioral burden, yet it only describes the pixel data shape. It says nothing about prerequisites (must the target texture already exist?), reversibility/undo, whether existing pixels are overwritten, or performance on large lists.

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, purpose front-loaded before the data-format detail. No waste, though it could have surfaced the format as structured detail rather than a trailing clause.

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 two-parameter mutation tool with no annotations and no output schema, the description covers the core action and one parameter well, but omits target semantics, side effects, and undo behavior, leaving meaningful gaps.

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

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

Schema coverage is 0%, so the description must compensate. It thoroughly documents the 'pixels' entry format ([x, y, color] with hex/rgb/rgba variants), which is genuinely useful, but leaves 'target' entirely unexplained (texture name vs id vs handle). Partial compensation warrants a middling score.

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 ('Set individual pixels on a texture') and frames itself as 'the precise way to hand-draw pixel art', which hints at its distinction from coarser texture tools like bb_draw_texture. It does not name a sibling explicitly, 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?

The phrase 'the precise way to hand-draw pixel art' implies when this is preferable to bulk operations, but there is no explicit when-to-use, when-not-to-use, or named alternative. Usage is left to inference.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it never says whether playback is blocking or asynchronous, whether it mutates project state permanently, which parameter is required for which action, or what happens on error. The 'action' string has no enum, so valid values (only 'set_time' is visible via the schema default) are left to guesswork.

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 resource and operations front-loaded and no filler. It is efficient, though its brevity contributes to the specification gaps elsewhere rather than being purely a virtue.

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 annotations, no output schema, and 0% schema coverage leave the agent without the essentials for a state-mutating timeline tool: valid action values, which params each action needs, default vs explicit animation targeting, and return/async behavior are all absent.

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

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

Schema description coverage is 0% and the description only loosely maps to the params: 'set the time' hints at 'time', and the verbs hint at 'action' values. The 'animation' parameter is entirely unexplained — no indication whether it is a name, ID, or defaults to the active animation.

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 ('control') and resource ('the animation timeline') plus the concrete operations (set time, play, pause, stop). It is clearly distinct from create/set/delete_animation siblings, though it never explicitly contrasts itself with the adjacent bb_step or bb_list_animations 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?

It enumerates the operations but gives no when-to-use context, no prerequisites, and no routing away from alternatives like bb_step or bb_add_keyframe. The agent must infer from the tool name when this is the right call versus manipulating the animation state directly.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one useful trait (geometry is 'verbose') and implies a read-only, non-mutating dump, but says nothing about cost, output size, permissions, or side effects of a large dump.

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 tightly written sentences with the payload scope front-loaded and the usage cue second. No filler or repetition of the title.

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 parameterless-required, read-only inspection tool with no output schema, the description covers what the tool returns and how to toggle it. Missing only the default-on behavior of elements/textures/animations and any note on output volume for large projects.

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

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

Schema description coverage is only 25% (just geometry), but the description compensates by enumerating the three optional payload families — element tree, textures, animations — which map onto the elements/textures/animations booleans. It adds real meaning beyond the bare boolean names, though it never mentions that all three default to true.

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 concrete verb and resource plus the exact payload categories (format, mode, sizes, elements, textures, animations), so an agent knows what comes back. It does not explicitly distinguish itself from near-neighbors like bb_status or bb_list_elements, which is the only thing keeping it off 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?

'Call this to re-orient after a large edit' gives one positive usage trigger. There is no statement of when NOT to use it and no named alternative (e.g., bb_list_elements for elements alone, bb_status for connection state), so the routing guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden and does disclose non-obvious behavior: encoding 'auto' auto-detects text vs binary, the operation uses Blockbench's own file layer, and it requires no plugin permission. It stops short of covering failure modes (missing file, path resolution, size limits), which keeps it from a 5.

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

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

Three sentences, zero filler, and the encoding behavior — the one non-obvious detail — is front-loaded after the one-line purpose. Every sentence 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 two-parameter read tool with no annotations and no output schema, the description covers the encoding dimension well but leaves gaps: what path is relative to, what happens on failure, and how large files are handled. Adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does: encoding's default ('auto') and the meaning of each enum value ('text'/'base64') are explained, which is more than the bare enum list in the schema provides. The path parameter is self-explanatory and needs no elaboration.

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 ('Read a file from disk'), and the read direction clearly separates it from bb_write_file and bb_delete_path. It does not explicitly contrast with other file-adjacent siblings like bb_file_info or bb_glob, but the core purpose is unambiguous.

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

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

No when-to-use guidance, no exclusions, and no mention of alternatives such as bb_file_info (metadata) or bb_glob (discovery). The agent must infer that this is the tool for retrieving file contents.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the core behavior (drops the connection, plugin reconnects), which is real value, but says nothing about whether the drop is immediate, whether in-flight requests are aborted, or what happens if no plugin is listening.

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, zero waste, with the primary action front-loaded and the usage condition following. Nothing to trim.

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, no-output-schema maintenance tool, the description covers what it does and when to invoke it. Only minor edge-case behavior (failure mode when no plugin is connected) is 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?

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate beyond what the empty schema already conveys.

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

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

States a specific action ('drop the current Blockbench connection') plus the resulting behavior ('the plugin dials back in'), which distinguishes it from sibling bb_bridge_status (a read) and bb_reload_plugin (a different remedy). An agent can tell exactly what this tool does without opening a schema.

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

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

Explicitly gives the triggering condition: 'Use after reloading the plugin in Blockbench.' That is clear when-to-use guidance, though it names no when-not case or chalk alternative (e.g., bb_reload_plugin) to disambiguate further.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing behavioral. It does not say whether this mutates the document, whether the redo is itself reversible, what occurs when nothing is undone, or whether history state is affected beyond the edit.

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 short, front-loaded sentence with no wasted words, but brevity here comes at the cost of under-specification rather than genuine information density. It is appropriately sized for what it says, not for what an agent needs.

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

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

With no annotations, no output schema, and an undocumented parameter, the definition is too thin for a state-mutating history tool. An agent cannot know the preconditions, the effect of a failed redo, or the meaning of steps from this description alone.

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

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

Schema description coverage is 0% and the single 'steps' parameter has no description anywhere. The phrase 'the last undone edit' actually implies a single step, giving no hint that multi-step redo is supported, so the description adds little and slightly misleads on the default behavior.

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 (redo) and resource (last undone edit), which an agent can distinguish from bb_undo by the undo/redo pairing. However, it never names the sibling it mirrors or clarifies that it applies to the editor's history stack rather than some other edit context.

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

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

Usage is only implied by the undo/redo convention; there is no explicit statement of when redo is applicable (e.g. only after an undo) or what happens when the redo stack is empty. No alternatives or exclusions are named.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that no host restart is required and that store plugins cannot be reloaded in place, but says nothing about whether reload discards plugin state, what happens on failure, or any 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 short sentences with zero waste; the core action is front-loaded and the caveat follows. Every sentence 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 one-parameter tool with no output schema, the description covers the key behavioral caveat but leaves the required argument's meaning unexplained. Adequate but with a clear gap on the only parameter.

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

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

Schema coverage is 0% and the description never mentions the single 'id' parameter, so it does not clarify whether it expects a plugin id, a file path, or a URL. Given low coverage, the description should have compensated but does not.

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 (reload a plugin) and immediately scopes it to dev/URL plugins, explicitly excluding store plugins. An agent can distinguish this from bb_install_plugin and bb_uninstall_plugin without opening any schema.

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

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

Gives a clear when-not (store plugins are not reloadable in place) and implies the use case of iterating on a dev/URL plugin without restarting Blockbench. It does not name a sibling alternative, but the exclusion rule is the operative guidance here.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: whether existing transforms are preserved, what happens to children of the moved elements, how conflicts with an existing parent are resolved, or what errors occur. "Move" clarifies mutation intent but no side effects or preconditions.

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

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

One short, front-loaded sentence with no filler; the action and destination are stated immediately. It is under-specified rather than bloated, so conciseness is fine but it is arguably too terse for a required-parameter mutation 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?

A mutation tool with two required, wholly undocumented parameters, no annotations, and no output schema should do more work in the description. Callers cannot determine target format, parent reference format, or the effect on the hierarchy from the text provided.

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 both required parameters. The description partially clarifies "parent" by indicating it accepts a group or the literal "root", but says nothing about the format of "targets" (IDs, names, list, single element) or whether parent accepts an ID versus a 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?

The description states a specific verb+resource ("Move elements") and names the destination concept (a new parent group or "root"), which is enough to distinguish it from sibling mutators like bb_transform_elements, bb_group_elements, or bb_duplicate_elements. It does not, however, explain how reparenting differs from grouping or how the hierarchy is affected.

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, when not to, or which sibling (e.g. bb_group_elements, bb_set_element) handles adjacent hierarchy tasks. The agent must infer the use case entirely from the name and one 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?

With no annotations, the description carries the full burden and does most of it: it discloses that this is an interactive user-consent prompt, that the permission is narrowly scoped, and that existing read/write tools bypass it entirely. It stops short of saying what happens if the user declines or whether the call blocks.

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, zero filler. The parenthetical listing dependent tools is placed immediately after the core action, and the scope note comes last, which is the correct front-loading order.

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 one-param, zero-required permission request with no output schema, the description covers the essentials: trigger, dependents, and scope limitation. It omits the outcome of a denial or what the call returns, which is the one remaining ambiguity for an agent deciding whether to call 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 coverage is already 100% for the single optional scope param. The description adds a genuine nuance beyond 'Optional directory to limit access to': that scope restricts the permission to exactly one directory, clarifying the bounded effect on all five dependent tools.

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: 'Ask the user for the plugin file-system permission.' It goes further by scoping exactly which sibling tools require it (bb_list_dir, bb_glob, bb_file_info, bb_mkdir, bb_delete_path) and which do not, so the agent can place it precisely among ~60 siblings.

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

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

States both when to use it ('needed only by' the five named tools) and when not to ('reads and writes work without it'), naming the alternative path explicitly. No inference required from the agent.

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

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

With no annotations, the description carries the full disclosure burden. It usefully adds behavioral detail the schema cannot express: nearest-neighbour resampling and the coupling of UV dimensions to the new size unless keep_uv is set. However, it says nothing about whether the resize is destructive to source resolution, permission requirements, or undo behavior, leaving the mutation profile largely opaque.

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 compact sentences with the core action front-loaded and the conditional caveat trailing. No filler, every clause carries 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 texture-mutating tool with no annotations and no output schema, the definition covers the essential mechanics (interpolation, UV handling) but omits the 'target' semantics and any note on persistence, reversibility, or return value. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does: keep_uv's effect is explained and width/height are self-evident, but 'target' (the identifier of which texture to resize) is never clarified, and uv_width/uv_height are mentioned despite not appearing in the schema, which may confuse rather than clarify.

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

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

States a specific verb+resource ('Resize the texture image') and even names the resampling method (nearest neighbour), which distinguishes it from sibling texture tools like bb_create_texture or bb_set_texture_properties. It stops short of explicitly routing the agent away from those siblings, but the purpose is unmistakable.

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

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

There is no guidance on when to resize versus alternatives such as bb_set_texture_properties, nor any prerequisites or side-effect warnings. The only conditional ('unless keep_uv is true') describes a parameter effect, not when to choose this tool over another.

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

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

With no annotations, the description carries the full burden. It does disclose the output format (contact-sheet PNG), that a path is returned, and that the agent can then read the image file, which is useful behavior beyond the schema. However it says nothing about permissions, whether an existing file at 'path' is overwritten, or cost/time of rendering.

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 tight sentences that front-load the core action; no filler or repetition. Slightly more verbose than strictly necessary but 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 tool with no annotations and no output schema, the description covers purpose and workflow intent but omits parameter meaning and file-write semantics. It is adequate to call correctly in the common case but leaves real gaps.

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

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

Schema coverage is only 50%: 'width', 'angles', and 'background' defaults are partly documented in the schema, but 'path' and 'background' have no meaning supplied anywhere. The description adds zero parameter guidance, so the coverage gap is not compensated.

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 (render) plus resource (the model from several camera angles) and the concrete artifact produced (one contact-sheet PNG path). This is clearly distinct from the nearby bb_screenshot and bb_export_model siblings, which an agent can tell apart 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?

Gives explicit motivation and timing: 'LOOK at your own work and catch proportion and texture problems before declaring a model finished.' That is clear when-to-use context, but it names no alternative (e.g. bb_screenshot) and offers no 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?

No annotations are provided, so the description carries the full burden, and it does not say what happens on an invalid id, whether triggered actions are undoable, or that these commands may mutate/destroy project state. 'Reaches every built-in command the UI exposes' hints at broad, potentially destructive scope but stops short of warning about 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?

Two short sentences, zero waste, with the essential mechanic (id-driven dispatch) front-loaded before the scope note.

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

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

For an unannotated, output-schema-less dispatcher that can invoke any UI command, the description omits error behavior, undo/reversibility, and side-effect expectations. The agent has enough to attempt a call but not enough to anticipate its consequences.

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 the single 'id' parameter, so the description must compensate. It does explain that the value is a BarItems id obtainable via bb_list_actions, but adds no format, casing, or example beyond that. Partial compensation only.

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 ('Trigger') plus resource ('any Blockbench action') and it names the mechanism (BarItems id). It also routes to bb_list_actions, cleanly separating the enumeration tool from the execution tool.

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

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

The parenthetical '(see bb_list_actions)' tells the agent where to get a valid id, which is useful context. But there is no guidance on when to prefer this over bb_execute_js, nor any exclusions or preconditions for the call.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one genuinely useful trait: the default-path-reuse vs save-a-copy distinction. But it says nothing about whether an existing file is overwritten, what happens to unsaved state, permissions needed, or what is returned, so the disclosure is partial for a disk-writing 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?

Two sentences, zero waste, purpose front-loaded before the parameter nuance. Nothing needs trimming 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?

No annotations, no output schema, and 0% schema description coverage means the description is the only documentation available. It leaves `embed_textures` unexplained and omits overwrite/return behavior, which is thin for a tool that writes a file to disk.

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 both parameters. It explains the `path` parameter's default/save-as semantics well, but `embed_textures` (boolean, default true) is never mentioned anywhere, leaving half the surface 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: compile the project to .bbmodel and write to disk. That is concrete and actionable. It does not, however, distinguish this tool from plausible siblings like bb_export_model or bb_write_file, so an agent cannot tell from the text alone why it would pick save over export.

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 conditional given ('without a path... pass one to save a copy') is parameter behavior, not when-to-use guidance. There is no statement of when to prefer this over bb_export_model, bb_set_project, or bb_write_file, and no exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden and does well: it discloses the on-disk side effect (writes a PNG), the return value (path, plus optional data URL), and transparency compositing behavior. It omits any failure/error behavior, but coverage of the core traits is strong.

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

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

Four tight sentences, front-loaded with what the tool does and why it exists. Minor redundancy with the schema on background, but essentially no wasted prose.

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, no-annotation tool, the description covers the main behavior, output, and two key flags, but leaves width/height unexplained and says nothing about limitations or failures. Adequate, but not fully complete.

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

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

Schema coverage is only 33%, so the description must compensate. It usefully explains crop semantics (auto-crop vs full viewport) and include_data_url, but width and height are undocumented in both schema and description, and the background explanation largely repeats the schema 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?

States a specific verb+resource+effect: render the preview to a PNG on disk and return the path. No sibling performs screenshots, so it is unambiguously distinguishable from the surrounding 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?

"This is how an agent looks at its own work" gives a clear purpose/context for reaching for this tool, and it explains the crop=true default choice vs crop=false and the background override. It stops short of naming explicit alternatives or when-not-to-use conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the mode options (replace, add, remove, toggle, none), which is useful, but it omits what targets should contain, whether empty targets are valid, how selection interacts with existing state, and whether any permissions are needed.

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

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

The description is one front-loaded sentence followed by an inline mode list with zero filler. It is appropriately sized for the content it chooses to include; the problem is omission, not verbosity.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description needs to do more. It never explains the critical targets parameter, so an agent cannot confidently invoke the tool with correct arguments.

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

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

Schema description coverage is 0% and the description documents only the mode parameter (values and default). The targets parameter is entirely unspecified in both schema and description, so half the parameters remain semantically 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 (change) and resource (outliner selection), so the core action is clear. It does not explicitly differentiate itself from sibling selection-related tools like bb_list_elements or bb_set_element, but the scope is still understandable.

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

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

No when-to-use or when-not-to-use guidance is provided. The description lists mode values but never says when this tool should be chosen over alternatives such as listing, setting, or transforming elements.

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

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

With no annotations, the description carries the full burden but only lists editable fields. It does not say whether the target is an existing animation identifier, whether unspecified fields are left unchanged (important since 0 params are required), whether edits are undoable, or what the response contains.

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, but it is terse to the point of under-specifying rather than optimally concise for a 4-parameter mutation 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 mutation tool with no annotations, no output schema, 0% schema description coverage, and no required parameters, the description leaves key questions (target identification, partial-update semantics, return behavior) unanswered.

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

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

Schema coverage is 0%, so the description must compensate. It names 'name', 'loop' and 'length' but leaves the 'animation' parameter (presumably the target identifier) undocumented, and gives no valid values for the 'loop' string nor a unit/format for 'length'.

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 (change) and resource (animation) plus the editable fields, which distinguishes it from the create/delete/list/play animation siblings. It is clear but never explicitly names those siblings to confirm the boundary.

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 bb_create_animation, bb_delete_animation, or bb_add_keyframe, and no preconditions. Usage is only implied by the verb 'change'.

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

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

No annotations are present, so the description must carry the behavioral burden. It discloses that this is a mutation tool and that multi-element renaming is refused, but remains silent on permissions, reversibility, side effects on unspecified properties, and return behavior.

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

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

The description is front-loaded with the verb and resource, and the long property list is necessary for parameter semantics. It is dense but largely free of filler, though a bulleted list would improve readability.

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 nested objects, no annotations, and no output schema, the description leaves critical gaps. It omits how to specify targets, what apply_to_children does, and other behavioral details needed to invoke the tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly documents the `properties` object keys and the nested `faces` override structure, but gives no explanation of the `targets` format or the `apply_to_children` parameter.

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

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

The description states a specific verb and resource: 'Change properties of one or more elements,' then enumerates the property set. It is clear what the tool edits, but does not explicitly differentiate from overlapping siblings such as bb_transform_elements or bb_set_face_uv.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternatives are named. The only constraint, that renaming multiple elements is refused, is operational rather than a usage guideline.

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

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

With no annotations, the description carries the full burden; it usefully discloses the null-to-clear semantics and the cube-only meaning of 'faces'. It does not say whether an existing texture is overwritten, whether the change is undoable, or what happens on invalid texture names.

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, front-loaded with the core action and followed by the one conditional detail. No filler or restatement of the title.

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 annotations and no output schema, the description covers the texture and faces parameters adequately but leaves 'targets' entirely unexplained, which is a real gap given it is required and untyped.

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

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

Schema coverage is only 33% and the 'targets' parameter is both undocumented and untyped in the schema, yet the description never explains it. The description does add value for 'texture' (name/uuid, or null to clear) and 'faces' (limits sides on cubes), but that value largely duplicates the schema's own note.

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 ('Assign a texture ... to cube or mesh faces') plus the clearing behavior with null. It is clearly distinguishable from UV-oriented siblings like bb_set_face_uv and property-oriented ones like bb_set_texture_properties, though it never names a sibling 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?

'For cubes, pass faces to limit which sides are changed' gives concrete usage context for one parameter. There is no statement of when not to use it, no prerequisites, and no mention of alternatives such as bb_set_face_uv for coordinate work.

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