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

No annotations are provided, so the description alone must disclose side effects and prerequisites. It states the core effect (repeating geometry) but omits that the modifier is applied to the selected/active object, that geometry is instanced, and whether any object must be active. For a mutation tool, this is a significant behavioral 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?

A single sentence with no filler; 'fences, stairs, pillars' is compact but informative. The description is front-loaded with the action and follows with the purpose.

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

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

Despite the 7-parameter schema and no output schema or annotations, the description provides only one sentence. It doesn't mention the target object, prerequisites, or how the array parameters combine, so an agent lacks enough context to invoke the tool confidently beyond knowing its basic purpose.

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

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

With only 43% schema description coverage, the description needed to explain parameters like count, name, modifier_name, and merge_vertices, but it adds none of that. The only parameter-related information is the abstract 'repeat geometry' phrase; the offset parameters are already described in the schema. The description fails to compensate for the missing parameter docs.

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 ('Add') and resource ('an Array modifier'), then clarifies the function ('to repeat geometry') with concrete examples ('fences, stairs, pillars'). This clearly differentiates it from modifier siblings like add_mirror or add_bevel without needing to inspect schemas.

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

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

The examples convey the intended use case (repeating geometry for fences, stairs, pillars), so an agent can infer when to choose this tool. However, it never explicitly names alternatives or states when not to use it (e.g., generic add_modifier, or mirror instead of array), leaving the usage decision partially to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Add a Bevel modifier,' with no information about side effects, dependencies on the active object, modifier stack placement, destructiveness, or undo behavior. This leaves the agent without critical behavioral context for a mutating tool.

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

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

The description is one short sentence and immediately identifies the operation. The phrase 'cheapest way to make hard edges catch light' is slightly colloquial but adds a concise purpose statement. There is no unnecessary repetition of the tool name or schema fields, keeping the definition 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?

With eight parameters, no output schema, and no annotations, the description should explain prerequisites and behavior more thoroughly. It does not state whether the modifier is added to an active object, whether a selected object is required, or how the modifier is identified afterward. The definition is too sparse for an agent to use confidently in varied scene contexts.

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 38%, and the tool description adds no parameter explanations. Parameters like profile, segments, limit_method, and modifier_name have no prose context beyond bare names and constraints. Defaults and enums provide some signal, but the low coverage combined with complete silence in the description leaves major semantic gaps.

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

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

The description states a specific action and resource: 'Add a Bevel modifier.' It also hints at the purpose ('make hard edges catch light'), making the tool's role clear. It is distinct enough from sibling add_* tools because it names the exact modifier, though it does not explicitly contrast itself with the more generic add_modifier.

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 cheapest way to make hard edges catch light' implies when an agent might choose this tool, but it does not give explicit context, exclusions, or alternatives. There is no mention of selecting an object first, nor of when to prefer add_bevel over add_modifier or a manual bevel operation. Usage guidance is implied 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?

Annotations are absent, so the description carries a heavier burden. It does add useful behavioral context by warning that Booleans create messy topology and that results should be checked before applying. However, it does not describe side effects such as modifier-stack behavior, cutter visibility, or potential failure conditions.

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

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

The description is two sentences with the primary purpose front-loaded and a concise risk warning as the second sentence. There is no filler or redundant restating of schema 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 6-parameter tool with no annotations and no output schema, the description covers the core purpose and the main risk, but it leaves edge-case behavior to inference. The schema supplies solver and operation defaults, so basic invocation is viable, but deeper context such as modifier naming and non-watertight geometry is not addressed.

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 67%, and the key parameters name and cutter are already documented in the schema. The description adds no parameter-level detail and does not help clarify the undocumented operation or modifier_name parameters, so the schema carries most of the burden.

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 opening sentence uses a specific verb and resource ('Add a Boolean modifier') and states the intended effect ('cut one object with another'). This makes it easy to distinguish from sibling generic modifiers like add_modifier and from other specific modifiers like add_bevel.

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

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

The description implies a clear use case (cutting one object with another), so an agent can infer when the tool is relevant. However, it does not explicitly name alternatives or exclusion conditions, and the topology warning is post-operation guidance rather than tool-selection guidance.

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

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

No annotations are provided, so the description must disclose behavior. It only says the modifier reduces triangle count; it does not mention whether this is destructive, whether it modifies a named object or the active object, whether the modifier is reversible, or any side effects.

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

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

Two sentences, zero filler. Purpose is front-loaded, and the sibling alternative is stated in a compact second 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?

With five parameters, no output schema, and no annotations, this description is too sparse. It omits how the target object is identified, how modifier naming works, and how the decimation settings behave, leaving the agent to guess from the 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 description coverage is only 20%, so the description must compensate, but it adds nothing about the required 'name', 'ratio', 'triangulate', 'decimate_type', or 'modifier_name' parameters. Only the schema's ratio field has a helpful 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: 'Add a Decimate modifier to reduce triangle count.' The second sentence differentiates it from create_lod, making the purpose and sibling distinction 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?

Explicitly advises preferring create_lod for LOD chains and explains why ('builds named copies and leaves the source untouched'). This gives the agent a direct when-not-to-use signal.

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 only says a Mirror modifier is added and gives a figurative benefit, but it does not state prerequisites like requiring a selected object, the actual duplication/mirroring behavior, or side effects. This is too 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?

The description is a single sentence with no filler. The action is front-loaded, and the metaphor adds value without bloating the 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?

With 8 parameters, no output schema, no annotations, and low parameter coverage, a one-line description is not enough. It omits what 'name' refers to, how the modifier is applied, and what an agent should expect after invocation, making reliable use dependent on external knowledge.

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

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

Schema description coverage is only 25%, and the description adds no parameter meaning at all. It does not clarify the required 'name' parameter (object name vs. modifier name) nor explain axis defaults, merge_threshold, or modifier_name. The two schema-level descriptions for use_clip and mirror_object help, but most parameters remain under-explained.

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

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

The description clearly states the action and resource: 'Add a Mirror modifier'. The phrase 'model half an asset and get the other half free' adds useful intent. It does not explicitly distinguish itself from the generic add_modifier sibling, so it misses the top score.

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

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

The description implies a use case (symmetric modeling of half an asset), which gives some context for when this tool is appropriate. However, it provides no explicit when-to-use or when-not-to-use guidance and does not mention alternatives like generic add_modifier or set_modifier.

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

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

Since no annotations are provided, the description carries the behavioral burden. It usefully discloses the return value ('resulting state and the object's full stack') and a specific failure mode for unknown settings keys. However, it does not mention prerequisites, side effects beyond adding/configuration, or the effect of use_defaults, though 'Add' does imply mutation.

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 concise, front-loaded sentences with no filler. The action, return behavior, and a notable error case each earn their place, making it easy to parse quickly.

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

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

For a tool with no output schema and no annotations, the description communicates the postcondition, the return shape, and a key failure mode, while the schema covers all parameter details. It omits selection guidance among specialized modifier tools, but that gap is already reflected in usage_guidelines; for actually invoking the tool, the description is largely sufficient.

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

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

The input schema already documents all five parameters with 100% coverage, so the baseline is 3. The description adds one meaningful detail about settings validation — unknown property names fail with valid names — but it does not add meaning for type, use_defaults, or modifier_name beyond what the schema provides.

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

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

The description uses a specific verb, 'Add and configure', and names the resource, 'a modifier', so an agent can tell this is a creation tool. It does not explicitly name the generic-vs-specialized relationship with siblings like add_bevel or set_modifier, but the action and the type enum make the purpose 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?

There is no explicit guidance about when to use add_modifier instead of the many specialized modifier tools such as add_bevel, add_subdivision, or set_modifier. The phrase 'in one call' implies a convenience path, but no exclusions, prerequisites, or alternatives are stated.

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

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

With no annotations, the description must carry the behavioral disclosure; it does state that the operation adds a modifier and produces a thickness effect, which makes the mutating behavior explicit. However, it does not mention target-object requirements, whether repeated calls stack modifiers, or any side effects on the modifier stack, leaving the disclosure only at a basic level.

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

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

The description is a single sentence with no filler and it is front-loaded with the tool's action. It is slightly under-sized relative to the six parameters and the lack of annotations, but it is not redundant.

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

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

For a tool with six parameters, no output schema, and no annotations, one sentence is insufficient. It omits how the 'name' parameter identifies the target object, how offset direction works, modifier naming behavior, and which options are safe defaults for common use.

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

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

Schema description coverage is only 33%, so the description needed to compensate for the undocumented parameters. It adds no meaning for offset, use_rim, modifier_name, or use_even_offset; even the word 'thickness' is a loose restatement of the thickness parameter rather than a semantic explanation.

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

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

The description states a specific action ('Add'), a precise resource ('Solidify modifier'), and the intended outcome ('give a flat surface real thickness'). This clearly differentiates the tool from sibling modifiers like add_bevel or add_subdivision without needing to open 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?

The phrase 'to give a flat surface real thickness' provides a clear context for when this tool should be chosen. It does not explicitly compare against add_modifier or other modifier tools, but the dedicated purpose is obvious enough that an agent can route to 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 burden of behavioral disclosure. It adds a useful fact about face multiplication ('~4 per level') and a performance warning, but it never states which object receives the modifier, whether existing modifiers are preserved, or what side effects or errors may occur.

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

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

The description is a single sentence with the main action front-loaded and a practical warning included without redundancy. Every clause earns its place and nothing is restated from the schema.

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

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

Given five parameters, no annotations, and no output schema, the description is too thin. It leaves the target object implicit, does not explain the modifier naming behavior, and fails to cover render/type distinctions, making it insufficient for confident 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 coverage is only 20%, so the description must compensate. It does add meaning to 'levels' with the face-multiplication rule and the low-level recommendation, but the required 'name' parameter is unexplained, and modifier_name, render_levels, and subdivision_type receive no semantic guidance.

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

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

The description opens with a specific action and resource: 'Add a Subdivision Surface modifier.' This is not a tautology and clearly distinguishes the tool from generic add_modifier and other modifier-specific siblings like add_bevel and add_mirror.

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

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

The only usage guidance is 'keep levels low for game assets,' which is a parameter-level caution. The description does not state when to prefer this tool over alternatives like add_modifier or other specialized modifier tools, nor does it give any 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 burden of behavioral disclosure. It does add some behavioral context: the modifier must be placed last in the stack and affects export output ('survives export'). However, it does not disclose whether the operation is non-destructive, what object is affected, or any side effects on the existing modifier stack — 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 sentences with no wasted words. The verb and resource are front-loaded, and the ordering guidance follows immediately. Every sentence earns its place and the guidance is actionable.

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

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

For a 5-parameter tool with no output schema and no annotations, this description is incomplete. It explains the 'why' (hard-surface shading that survives export) but omits the 'how' — parameter meaning, required object context, and behavior of the modifier in the stack. An agent would struggle to invoke it with correct parameter values.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It provides no explanation of mode, weight, keep_sharp, name, or modifier_name semantics. The five parameters are entirely unsupported by the description, leaving an agent to guess the meaning and appropriate values for each.

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: 'Add a Weighted Normal modifier.' The modifier type is named precisely, which distinguishes it from the generic add_modifier sibling and the other specialized modifier tools (add_bevel, add_decimate, etc.). The purpose is immediately clear to an agent deciding which modifier tool to use.

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 explicit placement guidance: 'Put this last in the stack, after a bevel with harden_normals, to get clean hard-surface shading that survives export.' This is clear contextual instruction about when/how to use the tool. However, it does not explicitly exclude alternatives or explain when one would NOT use this tool versus other modifier tools.

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

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

With no annotations supplied, the description carries the full behavioral burden, and it opens with 'Read-only' and ends with 'Modifies nothing'—an explicit side-effect guarantee. It also discloses what is computed and which issue categories are reported, so an agent knows exactly what behavior to expect.

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

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

Everything in the description earns its place: a dense but ordered output list, the safety statement, and the render-pairing guidance. It is front-loaded with the key read-only fact, and the usage advice is delivered in one tight 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 tool with no output schema and no annotations, the description tells the agent what fields will appear in the report and how to interpret the results ('statistics catch budget problems'). Parameters are fully documented in the schema, so nothing needed to invoke the tool correctly is 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?

Schema description coverage is 100%, so the schema already documents all three parameters clearly. The tool description adds useful output context but no additional semantics for `objects`, `check_topology`, or `include_children` beyond what the schema provides.

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

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

The description names a specific resource (an asset) and enumerates exact report contents, so the tool's function is unambiguous. It does not explicitly contrast itself with the similar sibling validate_game_asset, and 'read-only report' only separates it from mutating/export 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 explicitly says to pair with a render and that statistics catch budget problems, giving a concrete usage pattern. It doesn't name alternative tools or exclusions (e.g., validate_game_asset for pass/fail, get_mesh_data for raw data), so it falls short of full 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?

With no annotations, the description carries the safety burden and discharges it well by flagging the operation as IRREVERSIBLE and advising a checkpoint. It also notes ordering behavior. It does not spell out that baked modifiers are removed from the stack, but the warning is sufficient context for a destructive 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 terse sentences front-load the operation and the critical danger. Every word contributes, with no repetition of schema or annotation data.

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

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

The destructive nature is flagged, but an irreversible tool with no output schema and an undocumented 'force_multi_user' parameter needs more context about what object is affected, what baking entails, and what the result is. The description is not complete enough for safe autonomous use.

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

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

Schema description coverage is 0%, and the description adds nothing about the two parameters. 'name' is not identified as the target object, and 'force_multi_user' is 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?

The description uses a specific verb ('bake') and a specific resource ('the whole modifier stack, in order'), which clearly distinguishes it from the single-modifier sibling apply_modifier and the modifier management tools. The scope is unambiguous.

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

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

The phrase 'whole modifier stack' implies use when all modifiers should be applied; the IRREVERSIBLE warning and 'checkpoint first' instruction give actionable preconditions. It stops short of explicitly contrasting with apply_modifier or saying 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly warns that the operation is "IRREVERSIBLE without undo or a checkpoint" and explains the return value (before/after geometry counts). This meaningfully reveals destructive behavior and output semantics, though it could go further by noting exactly what state changes occur.

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

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

The description is two well-structured sentences with no filler. The action and warning are front-loaded, and the return-value note earns its place. Every word contributes.

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?

Despite being concise, the description is not complete enough for a destructive tool with no annotations, no output schema, and low parameter coverage. The agent still lacks clarity about the required parameters and any prerequisites or error conditions. The irreversibility warning and return-count note are helpful, but the definition leaves too much unspecified.

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 low at 33%, so the description must compensate for the undocumented `name` and `modifier` parameters. It does not; it never clarifies whether `name` is the object name, modifier name, or something else, nor what format `modifier` expects. Only `force_multi_user` is described in the schema. This is a significant gap for correct invocation.

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

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

The description uses a specific verb and resource: "Bake a modifier into the mesh." It clearly names the operation and target, and the singular "a modifier" implicitly distinguishes it from `apply_all_modifiers`. It does not explicitly name a sibling, so it falls short of a 5, but there is no real ambiguity about what the tool does.

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

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

The description implies when to use the tool: when you want to permanently bake a modifier into a mesh. However, it does not explain when not to use it or how it relates to alternatives like `add_modifier`, `apply_all_modifiers`, `undo`, or checkpoints. The irreversible warning is useful context but not explicit 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?

With no annotations, the description carries the burden of disclosing side effects and explicitly warns that the mesh is modified and a checkpoint should be created first. It could add more detail about multi-user data refusal or transform reset, but the core destructive behavior is disclosed.

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 lead with the action, provide the use-case rationale, and end with a necessary warning. There is no filler or redundant restatement.

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 mesh tool with no output schema, the description supplies purpose, domain rationale, and a destructive-operation warning. It relies on the schema for parameter details, which is acceptable because force_multi_user and location behaviors are already documented there.

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 60%, so the description must help with the undocumented scale and rotation booleans; it does clarify that scale ends at exactly 1. However, it doesn't mention the location option or add much beyond what the schema already provides for names and force_multi_user.

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 exactly what the tool does: bakes rotation and scale into mesh data. This clearly distinguishes it from transform-setter siblings like set_transform, rotate_object, and scale_object by focusing on mesh data mutation.

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

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

The description provides clear context ('Game engines generally expect...') that tells an agent when this preparation step is appropriate. It also warns the user to checkpoint first, but it does not name alternatives or give explicit 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?

With no annotations, the description carries full responsibility, and it discloses the destructive default (replaces every existing slot), the append mode, and a performance consequence (extra draw calls). It does not state whether the material must already exist or whether assignment creates a new material, which is a meaningful behavior gap. Overall it provides substantive behavioral context beyond a bare verb.

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 paragraphs, front-loaded with the purpose sentence and immediately followed by the most important default behavior. Each sentence earns its place; no filler or repetition of schema details.

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

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

Covers the main operation, default behavior, and the primary parameter choice, which is enough for many calls. Missing are the material-existence requirement and how slot_index interacts with replace, which could trip up an agent without other context. Since there are no annotations and no output schema, these gaps lower completeness below the top tier.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds real value by explaining the replace=true behavior and the performance trade-off of appending slots. It does not clarify how slot_index relates to replace, but the schema already describes each parameter. The draw-call insight elevates the semantics beyond the schema.

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

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

States a specific action ('Assign a material to objects') with a clear resource. The description goes beyond the name by explaining the default replacement behavior, which distinguishes this from related material tools like set_material_properties. It is unambiguous about the operation.

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

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

Provides explicit guidance: default replaces all slots and is suited to single-material game props, while replace=false appends a slot and incurs extra draw calls. It does not explicitly name alternative tools, but it does give a clear decision rule for the key parameter. However, it does not explain when to use slot_index instead of replace=false, leaving some usage ambiguity.

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 clearly discloses that the tool creates an undo boundary and a checkpoint, and that the wrapper can be cancelled as one unit. It doesn't detail failure modes or the need for force when another operation is open, but the schema covers those.

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

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

Two concise sentences, with the core definition front-loaded and the practical usage immediately following. Every sentence earns its place and there is no 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?

The description explains the lifecycle well: begin opens, end_operation closes, and the operation can be abandoned in one call. It doesn't explicitly name cancel_operation, but the reference to abandonment combined with the sibling list makes the flow recoverable. For a stateful tool with no output schema, this is strong but not fully exhaustive.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds general conceptual framing about operations and checkpoints but does not add parameter-specific meaning beyond the schema. The baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Open a named operation.' It then clarifies the two key effects: an undo boundary and a checkpoint, which distinguishes it from related siblings like push_undo, create_checkpoint, end_operation, and cancel_operation. The purpose is immediately identifiable.

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 second sentence gives clear usage context: wrap multi-step asset work in begin_operation / end_operation so it appears as one history task and can be abandoned in one call. It does not explicitly enumerate when not to use it or name alternatives such as create_checkpoint, but it gives enough context for an agent to decide.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden. It explicitly warns that checkpoint reload 'DISCARDS everything done since begin_operation — including any of the user's own edits,' and accurately labels the undo-stack fallback as 'best effort' while noting the response reveals which path was taken. This is excellent disclosure of destructive, partial-recovery behavior.

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

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

Three short sentences front-load the core action and the destructive warning, then cover the fallback path and response signal. There is no wasted wording, and the description does not repeat schema content unnecessarily.

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

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

For a destructive tool with no annotations and no output schema, the description covers the important decision paths: with a checkpoint, without a checkpoint, and what the response will indicate. It does not specify behavior when no operation is open or when the undo stack is exhausted, but the essential calling context is well covered.

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?

Both parameters are already fully described in the input schema (100% coverage), so the description does not need to re-document them. It adds only minimal parameter-level meaning beyond echoing the checkpoint-versus-undo distinction, so the baseline 3 is appropriate.

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

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

The description opens with a specific verb and object: 'Abandon the open operation and roll back.' It then explains the two rollback paths, which distinguishes it from siblings like undo, redo, and restore_checkpoint by tying the behavior to the open-operation lifecycle.

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 clear context for when cancel_operation applies: it abandons the open operation, uses a checkpoint when available, and falls back to undo-stack stepping otherwise. It does not explicitly name sibling alternatives or state when not to use this tool, so it stops short of fully explicit 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?

With no annotations, the description must disclose behavioral traits. It only says 'Link' which implies a mutation, but it doesn't mention side effects like overwriting existing links (though the replace parameter hints at this in the schema), reversibility, or prerequisites. The description doesn't state whether the operation is destructive or if it modifies the material permanently. This is a significant gap 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?

The description is concise and front-loaded: the first sentence states the core purpose, and the second sentence adds a critical detail about socket name resolution. There is no redundancy or fluff. 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?

The description covers the main purpose and gives a key hint about socket names, but it lacks important context: it doesn't mention that this operates on material node graphs (though 'material' parameter implies it), doesn't describe the replace behavior (though the schema does), doesn't specify what happens on invalid inputs, and doesn't differentiate it from similar tools like set_node_inputs or disconnect_node_input. For a tool with 6 parameters and no annotations, more context is needed.

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 50% with three parameters (replace, to_socket, from_socket) having descriptions. The description adds value by explaining that socket names can come from get_material_nodes and that numeric strings select by index, which clarifies the from_socket and to_socket parameters. However, it doesn't explain material, from_node, or to_node, which are required and lack schema descriptions. The description partially compensates for the coverage gap but not fully.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Link one node's output to another node's input.' This distinguishes it from sibling tools like disconnect_node_input or create_node. It's immediately clear what action is performed.

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 a useful hint that socket names come from get_material_nodes and numeric strings select by index, which guides parameter usage. However, it doesn't explicitly state when to use this tool versus alternatives like set_node_inputs or disconnect_node_input, nor does it mention conditions to avoid using it. The guidance is implied but not explicit.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses meaningful behavior beyond the schema: local-space construction, tight oriented boxes for rotated assets, automatic UCX_<object>_01 naming, wireframe display, and exclusion from renders. This gives the agent a clear model of side effects.

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

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

Three concise sentences front-load the primary purpose, then add high-value technical details. There is no filler, repetition, or unnecessary context.

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

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

For a creation tool with no output schema or annotations, the description covers core behavior, coordinate space, naming, and rendering implications. It does not explicitly address return values or the collection/parent_to_source parameters, but the essential invocation context is present.

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 60%, and the description adds useful semantics for the key behavior ('matching an object's bounding box', local space, automatic naming). However, collection and parent_to_source have no description in either the schema or the tool description, leaving part of the parameter surface 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: 'Create a UCX_ box collider matching an object's bounding box.' It clearly differentiates this from the sibling create_convex_collision by specifying 'box collider' and gives the exact naming convention. An agent can confidently identify what this tool does.

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

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

The description implies usage through the phrase 'the convention Unreal expects,' but it never explicitly says when to choose this tool over create_convex_collision or when not to use it. With a close sibling present, the lack of explicit routing is a notable gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions aiming behavior but does not state side effects such as the camera becoming active by default, collection placement, or what happens to any existing camera. This is a meaningful gap for a creation 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 short sentences, front-loaded with the core purpose and followed by a targeted usage note about aiming. Every sentence earns its place and there is no redundant or filler content.

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

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

The description is adequate for basic camera creation and aiming, but it omits context around important defaults and side effects, such as set_active defaulting to true and making the camera the render camera. Given 13 optional parameters and no output schema or annotations, a bit more contextual guidance would improve completeness.

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 54%, so the description is not required to fully compensate, and it does add useful context for look_at and look_at_object by explaining their role in pointing the camera. However, it adds no meaning for the many other parameters such as clip_start, clip_end, collection, or ortho_scale.

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 and resource: 'Create a camera.' It also distinguishes itself from the related sibling frame_objects_with_camera by explaining that camera aiming can be done here or via that alternative, which also computes distance.

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 clear guidance for aiming: pass look_at/look_at_object for pointing, or choose frame_objects_with_camera when distance should be computed. It does not cover exclusions for other siblings like look_at or set_camera_transform, but the context for this tool is clearly stated.

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

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

With no annotations provided, the description carries the full burden, and it does so well by disclosing the write location, filename format, and the key safety guarantee that the user's own .blend file is not modified or re-targeted. It doesn't discuss overwrite or disk cleanup behavior, but the main behavioral risk is covered.

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

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

The description is compact and every sentence earns its place: purpose, mechanics, safety, usage timing, and automatic alternative. The most important information is front-loaded and there is no filler.

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

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

For a tool with one optional parameter and no output schema, this description is nearly complete: it explains what happens, where, why, and when to use it. It could mention how to verify or restore a checkpoint, but that is reasonably handled by sibling tools like list_checkpoints and restore_checkpoint.

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 label parameter, but the description adds real meaning by showing the label is embedded into the checkpoint filename as <timestamp>_<label>.blend. This connects the parameter to the observable artifact beyond the schema's generic 'Short description' wording.

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

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

The description states a clear verb and resource: save a timestamped checkpoint copy into workspace/checkpoints. It also distinguishes itself from save/save_as by explicitly saying the user's .blend file is never touched or re-targeted, so an agent can tell what this tool is and is not for.

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 explicit when-to-use guidance: before applying modifiers, deleting objects, or any multi-step change you might need to back out of. It also names an alternative/automatic path, 'begin_operation makes one automatically', which helps the agent avoid redundant checkpoints.

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 bears the full burden of disclosing behavior. It states the core creation action and nesting, but does not say what happens when parent does not exist, whether duplicate names are rejected, or whether creation is otherwise validated. This is minimal transparency for a mutating 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?

One sentence, eight words, action front-loaded and every phrase adds value. No redundant restatement of the schema.

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 creation tool this is mostly sufficient, but with no annotations and no output schema it remains thin on error cases, prerequisites (parent must exist), and behavior on duplicate names. The core operation is clear, yet an agent is left guessing at failure 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 coverage is 0%, so the description must carry parameter meaning. It does clarify the parent behavior ('optionally nested inside another'), which maps to the parent parameter, but leaves name semantics and any constraints entirely to inference from 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 action ('Create') on a specific resource ('collection') and adds the optional nesting scope. This clearly separates it from siblings like list_collections (listing) and move_to_collection (moving existing objects/collections).

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 no guidance on when to use this tool instead of alternatives such as move_to_collection or list_collections, and no prerequisites are mentioned. The only hint is that nesting is optional, but no if/then routing is provided.

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

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

No annotations are provided, so the description carries the burden. It does disclose the decimation/re-hulling behavior, but does not explain side effects: whether the source mesh is modified, what the UCX_ prefix means, whether a new object is created, or how collision_name relates to the result. This is a meaningful but incomplete disclosure.

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

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

Two tightly written sentences carry all the necessary high-level information. The core action and algorithm are front-loaded, and the usage guidance appears in the final sentence without waste. 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?

The description leaves out important operational details: what the tool returns, whether the original mesh is preserved, what collision_name does, and what parent_to_source means. Given no output schema and no annotations, these gaps make the definition incomplete for an agent that must 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 40% (only name and max_vertices have descriptions). The description adds context for max_vertices (decimation target) but says nothing about collection, collision_name, or parent_to_source. With low coverage, the description was expected to compensate for the other parameters and did 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?

Description opens with a specific verb+resource: "Create a UCX_ convex hull collider." It explains the core algorithm (build hull, decimate, re-hull) and explicitly distinguishes it from create_box_collision. An agent can clearly understand what the tool does and why it differs from its closest sibling.

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

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

Provides explicit when-to-use and when-not-to-use guidance: "Use this for shapes a box cannot approximate; use create_box_collision when a box will do, since it is cheaper at runtime." This is direct and names the alternative tool, leaving no room for inference.

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

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

No annotations are provided, so the description carries the full burden. It only states 'Create a cube' without mentioning side effects, required scene state, default behaviors (e.g., which collection the cube lands in), or any limitations. As a mutation tool, this is a notable gap in transparency.

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

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

The description is two sentences with no wasted words. The primary purpose is front-loaded, and the compatibility note is concise. It is appropriately sized for a simple tool.

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

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

With no output schema and no annotations, the description should cover the tool's full behavior and parameter meaning. It covers purpose and gives a hint at the alternative, but omits parameter details for size and name, and lacks behavioral context (e.g., what the cube is, where it appears, any prerequisites). This is insufficient 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%, so the description must compensate. It explains x, y, z as position coordinates but says nothing about the 'size' or 'name' parameters. Since half the parameters are unexplained, the description adds only partial value beyond the schema.

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

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

The description states a specific verb and resource: 'Create a cube at (x, y, z).' It clearly differentiates from the sibling create_primitive by noting it is kept for compatibility and that create_primitive is the general tool with rotation, scale, and collection. This allows an agent to distinguish the two without inspecting 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?

It names the alternative (create_primitive) and explains why create_cube exists (compatibility), implying create_cube is for simple cube creation without extra options. While not an explicit 'use this when...' statement, it provides enough context to route appropriately. It lacks a direct exclusion of other tools like create_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 burden, and it does disclose the core side effect: creating a new Empty object. However, it does not mention what happens after creation, such as whether the new Empty becomes the active object, how collection placement behaves, or whether any selection state changes. The fundamental behavior is clear, but some behavioral context is missing.

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 only two sentences, front-loads the core action, and every sentence contributes meaning. There is no filler, repetition, or unnecessary 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?

This is a creation tool with six optional parameters, no annotations, and no output schema. The description does not tell the agent what the tool returns, how the created Empty is referenced afterward, or what scene/collection behavior to expect. An agent would need to infer too much about the result of calling this tool successfully.

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 33%, so the description must compensate for the four undocumented parameters: name, collection, display_size, and display_type. It does not. The phrase about being an 'offset target of an Array modifier' hints at spatial use, but it does not explain any of the parameters or their practical meaning beyond what the schema already provides.

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

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

The description states exactly what the tool does: 'Create an Empty.' The use cases 'parent, a pivot, or the offset target of an Array modifier' make the unique role of an Empty clear and distinguish it from sibling creation tools like create_cube or create_mesh. The verb and resource are specific and the intent is immediately 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?

The description gives clear guidance on when to use this tool by naming concrete use cases: parent, pivot, or Array modifier offset target. It does not explicitly list alternatives or say when not to use it, but for a simple creation tool the intended context is clear enough.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a blank image is created but does not explain side effects, whether the image is registered in the scene's image list, persistence, defaults, or any constraints around 'generated.' This is a meaningful gap for a creation tool.

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

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

The description is a single front-loaded sentence with no filler: it gives the verb, object, and a purpose example efficiently. It is appropriately concise, though the content is sparse; that sparsity is penalized in other dimensions rather than here.

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 six parameters, no annotations, and no output schema, the description is too thin for correct invocation. It omits how the created image is returned or referenced, what defaults apply beyond the schema, and what nullable fields like height and colorspace mean. The high-level purpose alone is not enough.

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 17%, and the description names none of the six parameters. It adds no meaning beyond 'blank image,' leaving the agent without guidance on name, alpha, color format, width/height bounds, or colorspace values.

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

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

The description identifies a specific action and resource: 'Create a blank generated image' with a concrete example ('as a bake target'). It is clear, but it does not explicitly distinguish this tool from siblings like load_image or create_image_texture_node, so it falls just 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 'for example as a bake target' implies a use case, suggesting when creating a blank image is appropriate. However, the description does not state when to use this tool instead of alternative image-related tools, nor does it provide exclusions or when-not-to-use guidance.

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

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

With no annotations, the description must disclose all behavioral traits. It does reveal a key behavior: for role='normal', the image is set to Non-Color and routed through a Normal Map node. However, it omits other important behaviors such as whether existing connections are overridden, whether the material must already contain a Principled BSDF, what happens if both image and filepath are supplied, or what the function returns. The provided detail adds some value beyond the schema, but significant gaps remain.

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

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

The description is compact and well-structured, leading with the core purpose in the first sentence, then providing the most critical usage details (image vs filepath, role='normal') in a brief second paragraph. Every sentence carries information without waste, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity (10 parameters, no output schema), the description is far too sparse. It does not cover the meaning or effect of several parameters, does not describe error conditions, preconditions (e.g., material existence), or post-conditions (e.g., where the node is placed in the node tree). The description provides only a fraction of what an agent would need to use the tool correctly across its full parameter space.

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 60%, so the description should compensate for undocumented parameters. It does add meaningful semantics for the image/filepath choice (mutual exclusivity) and the role='normal' effect on color space and node routing. However, it does not elaborate on parameters like name, location, extension, or interpolation, which remain undocumented in both schema and description. The added value is real but partial, falling short of compensating for the coverage gap.

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

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

The description clearly states the action ('Add an Image Texture node') and the resource ('wire it into the material'), making the tool's purpose unambiguous. It also distinguishes itself from generic sibling tools like create_node by specifying the node type and the special handling for normal maps, so an agent can immediately tell when this tool is the right choice.

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

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

The description does not explicitly state when to use this tool versus alternatives such as create_node, set_node_inputs, or load_image. It only provides guidance on parameter choices (image vs filepath) and the role='normal' special case, but no exclusions or alternative routing. An agent is left to infer the tool's applicability from its purpose, which is insufficient given the many related siblings.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only repeats the creation intent without mentioning side effects, prerequisites, return behavior, or interactions with the scene. For a mutation 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?

The description is extremely concise, using only two sentences. The core purpose is front-loaded in the first sentence, and the alternative guidance is clearly separated. Every word earns its place.

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

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

With 14 parameters星的, no output schema, and no annotations, this tool is complex, yet the description provides almost no contextual overlay. It does not explain typical use cases (e.g., which parameters matter for which light type), what the tool returns, or what conditions must be met. The schema gives some per-parameter meaning, but the overall call context is under-specified.

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

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

The description adds no parameter-level meaning; it only says 'Create a light.' The input schema covers 10 of 14 parameters with descriptions (71% coverage), leaving 4 parameters (name, collection, spot_blend, look_at_object) undocumented in both schema and description. The description fails to compensate for the missing 29%.

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

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

The description states a clear verb and resource: 'Create a light.' It also explicitly names the sibling tool create_preview_lighting as an alternative for a different use case, which distinguishes it from that sibling and makes its purpose 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 explicitly says when not to use this tool: 'For a quick, even setup to inspect an asset, use create_preview_lighting instead of placing lights one at a time.' This names the alternative and provides a specific condition, giving the agent a clear when-to/when-not-to decision.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly promises that the source object is NEVER modified, states that new named objects are created, and explains the output as per-level triangle counts. It does not cover overwrite/conflict behavior, but the core side-effect profile 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?

The description is compact and efficiently structured: action first, then safety guarantee, then return value. Every sentence provides useful information without 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 7-parameter tool with no output schema and no annotations, the description is largely complete: it names outputs, states safety behavior, and summarizes the return value. Minor gaps remain around collection behavior and triangulation, but those are partly inferable from parameter names.

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 71%, and the description adds the <base>_LOD0 naming convention plus the return value meaning. However, it does not explain the undocumented collection or triangulate parameters, nor does it add significant semantics beyond the schema for parameters like ratios or apply.

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

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

The description uses a specific verb and resource: 'Generate an LOD chain by duplicating and decimating.' It names the exact output objects (<base>_LOD0, <base>_LOD1, ...) and clearly distinguishes itself from related tools like add_decimate by describing a multi-level chain workflow.

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

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

The intended use is implied: create LOD levels from a source mesh. However, it does not explicitly contrast with alternatives such as add_decimate, duplicate_object, or manual modifier workflows, nor does it state when NOT to use this tool.

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

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

With no annotations, the description must carry behavioral disclosure. It usefully warns about linear color space and states that the material's properties are returned, which adds value. However, it does not mention what happens when a material name already exists, whether it overwrites, or what side effects occur beyond creation.

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 deliver the main purpose first, then the critical usage caveat about color encoding. There is no filler or redundant restatement of the schema.

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

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

The description covers the most error-prone detail (color space) and the return value, but for a 12-parameter material creation tool with no annotations, it omits duplicate-name behavior and the optional assignment behavior. Much of the parameter context is already in the schema, so the description is adequate but not 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?

The description adds meaningful color-format semantics beyond the schema by explicitly defining linear [r,g,b]/[r,g,b,a] floats and warning against 0-255 or sRGB hex. Schema coverage is already 75%, so the color-format clarification is a valuable supplement rather than a compensation for missing schema.

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

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

The description opens with a specific verb and resource: 'Create a Principled BSDF material.' This clearly separates it from material inspection and assignment siblings like list_materials, get_material, and assign_material, which have different actions.

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

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

No guidance is given for when to use create_material versus alternatives; there is no mention of when to prefer set_material_properties or assign_material instead. The intended context is implied by the name and the creation verb, but exclusions and alternatives are not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context: indices are validated before creation, resulting in a clean error rather than a broken mesh, and a practical scale limit. This goes beyond what the schema reveals and helps the agent anticipate failure modes.

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

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

The description is two short paragraphs, front-loaded with the core purpose, followed by two high-value behavioral notes. Every sentence earns its place; there is 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?

Given the tool has 10 parameters and no output schema, the description covers the essential context: what it builds, when to avoid it, and how errors are handled. It doesn't explain the return value or whether it selects the new object, but the schema covers parameter semantics and the description fills the most important operational 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?

The schema already covers most parameters (80% coverage), so the baseline is 3. The description adds meaning to indices and vertices by explaining that bad face indices produce clean errors and that the tool is suited for a few thousand vertices. This enriches the semantics of the faces/edges and vertices parameters beyond their type definitions.

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

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

The description clearly states the tool builds a mesh from explicit geometry, which sets it apart from parametric primitive creation tools like create_primitive or create_cube. It doesn't name siblings explicitly, but 'explicit geometry' is a meaningful distinction among the mesh-creation tools.

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

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

The description gives an explicit when-to-use and when-not-to-use: 'Keep it to a few thousand vertices; for anything procedural and large, use execute_blender_python with bmesh.' This directly names the alternative and the condition, making the decision unambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('Add') with no mention of side effects, reversibility, required permissions, or what happens if the node_type is invalid. It also doesn't describe the return value or whether the node is automatically linked to the material's output.

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

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

The description is a single, efficient sentence with zero waste. The core action and target are front-loaded, making it immediately scannable.

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

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

Given the tool has 5 parameters (2 required), a 23-option enum, and no output schema or annotations, the description is far too minimal. It doesn't explain how name, inputs, or location affect the node, nor does it provide context on node relationships or typical workflows. An agent would need to infer too much from the schema alone.

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

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

The description adds no parameter-specific meaning beyond what the input schema already provides. Since schema coverage is 80% (4 of 5 parameters have descriptions), and the description doesn't compensate for the missing material parameter description or clarify the enum values, it fails to add value beyond the schema.

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

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

The description clearly states the action (Add) and the target (a shader node to a material). It is specific enough to distinguish from siblings like create_material (creates the material itself) and create_image_texture_node (adds a specific node type), though it doesn't explicitly mention the node_type parameter that selects the kind of node.

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

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

The description provides no guidance on when to use this tool versus alternatives like set_node_inputs, connect_nodes, or delete_node. It doesn't mention prerequisites, such as whether a material must already exist, or when to prefer this over more specific node-creation tools.

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

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

With no annotations, the description carries the full burden. It discloses two key behaviors: 'Safe to re-run: it replaces the previous rig' and 'power scaled to the asset's size.' These go beyond a simple 'creates lights' and give the agent confidence about side effects. It does not detail all possible effects (e.g., optional world settings), but for a creation tool this is adequate.

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

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

Two concise paragraphs: the first is a clear one-line summary, the second elaborates on specifics (light names, collection, scaling, re-run safety, usage context). No filler or redundancy; every sentence contributes.

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

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

Given the tool's complexity (5 params, all documented) and no output schema, the description is fairly complete. It covers what it creates, how it behaves on re-run, and when to use it. It does not mention error conditions or return values, but these are not expected for a creation tool. The optional world settings are described in the schema, so no 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 100% – every parameter (objects, replace, strength, world_color, world_strength) has a description. The tool description adds no parameter-specific meaning beyond the schema; the phrase 'power scaled to the asset's size' is not tied to any parameter. Per calibration, baseline 3 is correct when schema does the heavy lifting.

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 'Build a neutral three-point studio rig sized to the subject' – a specific verb, resource, and qualifiers. It names the exact lights created (AI_Key, AI_Fill, AI_Rim) and the collection (AI_PreviewLighting), which distinguishes it from siblings like create_light (single light) and delete_preview_lighting (removal).

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 explicitly states when to use: 'Use this before render_preview when the scene has no lighting of its own.' That is a clear condition. It does not name alternatives like create_light or set_world_background, but the condition implies when not to use (scene already lit). The re-run safety note is more behavioral than usage guidance.

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

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

With no annotations, the description carries full behavioral burden. It discloses that rotation is in degrees, sizes are in Blender units, and that primitive-specific options are ignored for incompatible primitives. It also states the return value (full record). This goes beyond the schema and gives the agent essential behavioral expectations, though it doesn't detail side effects like collection creation (though that is in the schema).

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

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

The description is three concise sentences, front-loaded with the primary purpose. It packs essential behavioral details without redundancy. Every sentence contributes to understanding how to use the tool correctly, with no wasted words.

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

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

For a tool with 14 parameters and no output schema, the description covers key behaviors: it returns the full record, explains units, and clarifies parameter applicability. It does not cover every parameter detail, but the schema descriptions handle most (86%). It lacks explicit mention of side effects like collection creation, but that is documented in the schema. Overall, it provides sufficient context for an agent to use the tool correctly.

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

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

Schema coverage is high at 86%, so baseline is 3. The description adds meaningful semantics by clarifying units (Blender units) for size/depth/radius, which are not fully specified in the schema (radius has no description), and by explaining that primitive-specific options are ignored when not applicable. This adds value beyond the schema, justifying a 4.

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

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

The description clearly states the tool adds a primitive mesh object to the scene, with a specific verb and resource. It does not explicitly differentiate from sibling tools like create_cube, but the general nature is evident. The mention of rotation, sizes, and return value adds specificity, though it doesn't distinguish from alternatives.

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

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

The description provides clear guidance on parameter units (degrees, Blender units) and that primitive-specific options are ignored by primitives lacking them, which is useful for parameter usage. However, it does not mention when to use this tool versus alternatives like create_cube or create_empty, nor any exclusions or conditions for use.

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

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

With no annotations, the description carries the behavioral burden. It usefully reveals the 8-layer limit and the lightmap convention, but it does not disclose side effects such as whether the new layer becomes active (related to make_active) or what happens if the limit is exceeded.

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

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

The description is two brief sentences, front-loading the core action and adding only the most relevant additional fact. Every sentence earns its place with no redundancy.

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

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

For a mutation tool with no annotations and no output schema, the description is thin. It omits prerequisites, side effects, failure behavior at the 8-layer cap, and explanation of make_active, leaving an agent with incomplete information for a correct call.

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

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

Schema coverage is 67%, with make_active lacking a description. The tool description adds no parameter-level meaning, leaving the behavior of make_active ambiguous and not compensating for the schema gap.

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

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

The description states a specific verb and resource: 'Add a UV map.' This clearly distinguishes it from sibling tools like list_uv_layers, set_active_uv_layer, and delete_uv_layer. It does not explicitly contrast with projection/unwrap tools, but the operation is concrete and understandable.

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

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

There is no explicit 'use this when' or comparison to alternatives. However, the note that a second UV map is the usual place for a lightmap implies a common use case, providing some contextual guidance without naming or excluding sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool deletes a light object and its data, which implies irreversibility, but it doesn't mention whether deletion is permanent, whether it affects scene references, or whether any confirmation is needed. The description adds minimal context beyond the obvious destructive action.

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

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

The description is a single, short sentence that is easy to parse and front-loads the action. It is concise, though it could earn a 5 by adding a brief usage note without becoming verbose.

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

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

For a destructive tool with no annotations, no output schema, and a single undocumented parameter, the description is too thin. An agent needs to know what 'name' refers to, whether the action is reversible, and what happens to the light's data. The sibling list shows many related deletion tools, but the description doesn't help an agent distinguish this one.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'name' parameter. It does not explain what 'name' refers to (e.g., the light object's name in the scene) or how to find valid names. The description adds no parameter-level meaning beyond the schema's bare property 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 states a specific verb ('Delete') and resource ('a light object and its data'), which clearly identifies the operation. It is distinguishable from sibling tools like delete_object and delete_objects because it targets lights specifically, though it doesn't explicitly name those alternatives.

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

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

No guidance is given on when to use this tool versus alternatives like delete_object or delete_objects. The description implies it is for lights, but it doesn't state exclusions or provide context for choosing it over similar deletion tools.

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

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

With no annotations, the description carries the full behavioral burden. It discloses a valuable, non-obvious safeguard: deletion of the Material Output node is refused unless force=true. It does not mention side effects on connected links or whether deletion is reversible, but the explicit refusal behavior is meaningful transparency.

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

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

Two short sentences with no filler. The main action is front-loaded and the important exception is stated immediately after, making the behavior quickly scannable for an agent.

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 deletion tool, the description covers the essential calling context: the shader-node domain and the Material Output special case. It does not describe return values, but no output schema exists and the operation is likely fire-and-forget. Sibling tools like get_material_nodes provide the discovery mechanism for node identities.

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 that 'node' is a shader node and that 'force' overrides the Material Output protection, which adds real meaning. However, the 'material' parameter is left implicit, and no identifier/format guidance is given for either required 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 action ('Delete') on a specific resource ('shader node'), which clearly distinguishes it from sibling tools like delete_object and delete_light. The extra clause about the Material Output node makes the tool's scope even more precise.

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 clear context: use this tool for shader nodes rather than scene objects, materials, or UV layers. It also provides a when-not condition by noting that the Material Output node is refused unless forced. It does not name alternative tools explicitly, but the domain is clear enough.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly warns of destructiveness and advises checkpointing, which is the critical behavior. It does not mention reversibility via undo or specifics about children, but the destructive warning is prominent and sufficient for a basic deletion 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 short sentences with zero wasted words. The core action is front-loaded, and the destructive warning immediately follows. Highly concise and structured for quick comprehension.

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

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

The description covers the core destructive nature and checkpoint advice, but omits the meaning of delete_children and any note about undo or return values. For a two-parameter destructive tool, the missing parameter explanation is a notable gap, though the tool is simple.

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 50%: only 'name' has a description ('Object to delete'); 'delete_children' has no description. The tool description adds no parameter details at all, leaving the behavior of delete_children (e.g., whether it recursively deletes) unexplained. This is a significant gap for a destructive operation.

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 'Delete one object' clearly states the action (delete) and the resource (object), and the singular 'one' differentiates it from the sibling delete_objects. 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 provides a clear usage caution: 'DESTRUCTIVE -- make a checkpoint first if it matters.' This tells the agent when to take a precautionary step. It implicitly distinguishes from delete_objects by the singular scope, though it does not explicitly name the alternative or conditions for using the plural version.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does warn 'DESTRUCTIVE' and advises creating a checkpoint first, which is useful. However, it doesn't explain what happens to child objects when delete_children is set, nor whether the deletion is permanent or undoable (given undo/redo tools exist). This is partial transparency.

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

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

The description is extremely concise—two short sentences with no filler. The primary action is front-loaded ('Delete several objects'), and the critical warning is placed immediately after. Every word earns its place.

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

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

For a simple 2-parameter tool with no output schema, the description is mostly sufficient: it states the action, warns about destructiveness, and the schema covers the parameters. However, it lacks usage guidance (when to use vs delete_object) and doesn't clarify the effect of delete_children. The checkpoint advice hints at a workflow but doesn't reference the create_checkpoint tool. Overall, adequate but with notable 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?

The description adds no information about the parameters beyond the schema. The schema has 50% coverage (names is described, delete_children is not), but the description doesn't compensate for the missing delete_children semantics. The parameter names are self-explanatory, but the description itself contributes nothing to parameter understanding.

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

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

The description clearly states the action ('Delete') and resource ('several objects'), which distinguishes it from the sibling delete_object by implying multiple items. However, it doesn't explicitly name the alternative or elaborate on the plural nature beyond the word 'several', so it's clear but not maximally differentiated.

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

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

No guidance on when to use this tool versus delete_object or other deletion/undo tools. The description only includes a destructive warning and checkpoint advice, which is behavioral rather than usage direction. An agent might be uncertain whether to choose this for a single object or multiple.

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 does disclose the key destructive side-effect (the collection is removed along with the rig), but it does not address reversibility, contained objects, or behavior when the preview lighting rig 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 front-loaded sentence contains the verb and a precise object with no wasted words; every element 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 zero-parameter destructive tool, the description provides the critical context: what will be removed and that a collection is included. It does not cover return/error behavior, but none is required 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 input schema has zero properties, so there are no parameter semantics to document. The zero-parameter baseline is 4; the description correctly requires no 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?

The description uses a specific verb, 'Remove', and names the exact resource, 'AI_PreviewLighting rig and its collection'. This is unambiguous and clearly distinguishes it from general-purpose delete_light or delete_object 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 intended use is inferable from the resource name, but there is no explicit statement of when to choose this tool over alternatives, no mention that it is the inverse of create_preview_lighting, and no exclusions.

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

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

With no annotations, the description discloses the key non-obvious side effect: textures bound to the deleted map lose their coordinates. It also warns about multi-layer meshes. It doesn't mention irreversibility, but the warning is the critical behavioral fact.

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, entirely on-topic. The action is front-loaded, and the side-effect warning earns its place. No wasted words.

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

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

For a two-parameter delete with no output schema or annotations, the description covers the action and the most important consequence. The missing parameter semantics is a gap, but the warning to check first compensates for common failure modes.

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

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

Schema description coverage is 0%, so the description should explain what 'name' and 'uv_name' mean, but it does not. Their roles are inferable from context, yet the description adds no parameter-level meaning beyond the schema's field titles.

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

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

Clearly states the action (delete) and resource (a UV map on a mesh). The verb + target make it distinct from siblings like create_uv_layer and set_active_uv_layer without requiring schema inspection.

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 advises checking list_uv_layers first when there are multiple layers, giving a concrete precondition and naming the relevant sibling. It doesn't describe exclusions, but the caution is strong usage guidance for a destructive operation.

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

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

With no annotations provided, the description carries the behavioral burden. It clearly discloses the operation and its intended effect on subsequent tools. It stops short of stating whether the action is undoable or whether it affects only the selection state, but 'clear the selection' is a minimal, non-destructive operation and the rationale adds useful behavioral context.

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

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

The description is two short sentences with no filler. The operation is front-loaded and the second sentence' usage rationale earns its place by explaining why the tool 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?

For a zero-parameter, no-output action, the description fully covers what the tool does and when to call it. There is no missing information required 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 input schema has zero properties, so there are no parameter semantics to document. The baseline of 4 for no-parameter tools applies here.

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 single precise operation, 'Clear the selection', which is a specific verb+resource and clearly distinct from sibling tools like select_objects or get_selected_objects. It also reinforces scope by explaining that a stale selection must not pull in unintended objects.

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 explicit invocation context: use it before export or before any tool that falls back to 'the selection', with the reason being to avoid stale selections affecting output. It does not name alternatives or exclusions, but for a zero-parameter utility there is no real alternative to route between.

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 does state the core action ('remove every link'), but it omits important behavioral details such as reversibility (despite an undo sibling), whether the operation fails if the socket is already disconnected, and any side effects on the node graph or material state. This is a significant gap for a mutating tool.

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

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

The description is a single, well-formed sentence with no wasted words. It front-loads the primary action and is appropriately sized for a simple 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 tool with three required parameters and no output schema, the description is too sparse. It does not explain how to identify the socket, what 'material' scope means, or what happens after disconnection. The agent would need to consult sibling tool names or guess, making the definition incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the bare parameter names. It does not explain what 'node', 'socket', or 'material' refer to, nor how to format them (e.g., socket names vs indices). This leaves the agent to infer parameter semantics from the tool name and context alone.

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

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

The description clearly states a specific verb ('remove'), resource ('every link'), and target ('one input socket'). It is distinct from siblings like connect_nodes (which adds links) and delete_node (which removes a node), making the tool's purpose immediately 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 guidance is provided about when to use this tool versus alternatives such as connect_nodes or set_node_inputs. The agent receives no context about prerequisites (e.g., whether the node must be selected) or when it would be inappropriate to use this tool.

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

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

With no annotations provided, the description carries the full burden. It discloses that a copy is created and that it can optionally be moved, but it does not mention side effects such as whether the original is affected, whether the copy shares data (though 'linked' param exists in schema), or any undo behavior. The description is not misleading but is minimal 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?

A single sentence that is front-loaded with the core action and includes the key optional behavior. Zero filler, efficient and to the point.

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 output schema, and no annotations, the description is too sparse. It does not explain what the tool returns (e.g., the new object's name), nor does it clarify the two undocumented parameters (new_name, collection) or the exact semantics of 'moving the copy' beyond the schema. An agent calling this tool would have to rely on schema alone for most details, which is inadequate for a multi-parameter operation.

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

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

Schema description coverage is 75% (6 of 8 parameters have descriptions). The description adds no extra semantic detail beyond the schema; 'optionally moving the copy' hints at offset/location but these are already documented. With high coverage, the baseline is 3, and the description does not elevate it.

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 ('Duplicate') and a resource ('an object'), and the optional moving of the copy adds a clear scope. It is immediately distinguishable from sibling tools like delete_object, translate_object, or create_cube. The action 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 provides clear context for when to use the tool: to duplicate an object. It does not explicitly name alternatives or exclusions, but the purpose is self-evident enough that an agent can infer usage without confusion. No misleading guidance is present.

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 tool closes the operation and returns created/removed objects plus duration, which is meaningful behavior. However, it does not clarify whether the operation is final/committed, whether it creates an undo point, or what happens if no operation is open.

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

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

The description is two short sentences: the first states the primary action, the second states the return value. Every sentence earns its place, with no filler or redundant schema 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 zero-parameter tool with no output schema, the description covers what the call does and what it returns, which is enough for a basic correct invocation. It could be more complete by placing end_operation in the begin_operation/cancel_operation lifecycle, but the core usage is still clear.

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

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

The tool has zero parameters, so the schema is trivially complete and there is no parameter detail the description needs to add. The baseline of 4 applies.

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

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

The description clearly states the action ('Close the open operation') and the resource it operates on, and 'summarise what changed' plus the return description helps distinguish it from cancel_operation and undo. However, it does not explicitly name or contrast a sibling tool, so it stops just short of full differentiation.

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

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

No explicit guidance is given about when to use this tool versus cancel_operation or get_operation_status. The phrase 'the open operation' implies it requires an active operation, but the description does not state lifecycle prerequisites or exclusions, leaving the agent to infer usage from the tool name and sibling set.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly says the result is the repr of the evaluated expression, but it does not warn that evaluating a Python expression in Blender can have side effects or mutate the scene, nor does it mention undo behavior.

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

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

Two tight, front-loaded sentences with no filler. The first sentence states the action and output; the second gives the usage context.

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

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

For a one-parameter tool with no output schema, the description covers the essential behavior and return format. It is slightly incomplete around side-effect risk and Blender context availability, but adequate for the intended quick-lookup use case.

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

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

The schema already fully documents the only parameter, expression, with a concrete example. The description adds little param-specific meaning beyond confirming the repr return, so the baseline of 3 applies.

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: evaluate one Python expression in Blender and return its repr. This clearly distinguishes it from script-execution tools like execute_blender_python.

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?

Describes itself as a quick lookup that does not need a whole script, implicitly guiding the agent to use it for lightweight one-off expressions rather than full Python scripts. It does not explicitly name the alternative or exclusion conditions, so it stops short of a 5.

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 disclosure burden — and it delivers extensively. It reveals main-thread execution, stdout/stderr capture, traceback-on-failure, appeared/disappeared object reporting, the result-return mechanism, and a stark security note that this is TRUSTED LOCAL EXECUTION with the reach of the scripting console, explicitly warning against trying to add shell, subprocess, or network capabilities. Exceptional for a high-risk 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?

Four short paragraphs, each with a distinct job: core purpose, usage routing, behavioral details, and security boundary. The most important information (what it is, when to use it) is front-loaded. Every sentence earns its place — the security warning is essential for a trusted-execution tool, and the structure keeps it scannable.

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?

Despite having no output schema, the description fully explains return semantics (result_repr via return_expression, traceback on failure, captured stdout/stderr). For the most complex and powerful tool in the set, an agent has everything needed to call it safely and correctly: what it does, when to prefer it, how to return values, and what the security constraints are.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds genuine value by connecting the mechanism: 'Assign to a variable named result (or pass return_expression) to send a value back,' which clarifies how code and return_expression interact to produce the return value — beyond what the bare schema states. Slightly above the baseline 3.

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 — 'Run Python inside Blender on the main thread' — and immediately positions itself as 'the escape hatch' for when structured tools fall short. This clearly differentiates it from the dozens of structured sibling tools by establishing it as the general-purpose fallback rather than a narrow operation.

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

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

Gives explicit when-to-use and when-not-to-use guidance: 'Use this when the structured tools cannot express what you need' with concrete examples (bmesh surgery, geometry nodes, uncommon operators, bulk edits), and 'Prefer the structured tools when they fit' because they validate inputs and return tidy results. This is textbook 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions defaults ('Defaults to meshes/empties/armatures with modifiers applied') and return values ('Returns the absolute path, file size and the triangle count'). However, it does not explicitly state that the tool writes a file to disk, potential overwriting behavior (though the overwrite parameter exists in schema), or any side effects on the scene. This is adequate but not rich.

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

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

The description is concise and well-structured, consisting of two sentences. The first sentence states the primary purpose, and the second provides key defaults and return information. There is no redundancy or extraneous detail, and the most critical information is front-loaded.

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

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

Given 15 parameters, no output schema, and no annotations, the description is moderately complete. It provides purpose, defaults, and return values, but does not explain all parameters or the file-writing process. Some parameters have schema descriptions (objects, path_mode, etc.), which helps, but the overall guidance for an agent to confidently call the tool is still incomplete, especially for nuances like axis orientation and smooth type.

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 33%, so the description must compensate. It adds value by clarifying defaults for object_types and apply_modifiers ('Defaults to meshes/empties/armatures with modifiers applied'). However, it does not explain the meaning of many other parameters like axis_up, axis_forward, or mesh_smooth_type, relying on the schema's enum names and defaults. The description partially bridges the coverage gap but leaves significant parameters unexplained.

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

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

The description clearly states the tool's purpose: 'Export to .fbx for Unreal or Unity pipelines.' It specifies the exact output format (.fbx) and target engine pipelines, which distinguishes it from sibling export tools like export_glb, export_gltf, and export_obj. The verb 'Export' is specific, and the resource is unambiguous.

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

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

The description provides a clear usage context by stating it is for Unreal or Unity pipelines, which tells an agent when to prefer this tool over other exporters. However, it does not explicitly mention alternatives or when not to use it, such as for web or other engines. This is a useful but not exhaustive 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 provided, the description carries the full burden. It does disclose the return value ('Returns the absolute path and file size') and the self-contained packaging, which is useful. But it does not disclose side effects on the Blender scene, overwrite behavior, failure modes (e.g., no objects/selection), or prerequisites such as needing a selection or existing objects. Adds some value but leaves behavioral gaps.

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

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

Three tight sentences with zero filler: the core function is front-loaded, followed by the use-case rationale and the return value. 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?

This is a 12-parameter export tool with no annotations and no output schema, so the description should carry substantial guidance. It covers the return format but does not explain parameter tradeoffs, prerequisites (objects must exist or be selected), or failure cases. A one-line format summary is thin for a tool this complex.

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 50%, leaving overwrite, export_uvs, export_normals, apply_modifiers, export_materials, and export_animations undocumented. The tool description contributes no parameter guidance at all — it never mentions any of the 12 parameters or their tradeoffs (draco compression, tangents for normal maps, animations). At half coverage the description should compensate but instead adds zero parameter semantics.

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

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

States a specific verb and resource ('Export to a single self-contained .glb file') and grounds the format in a concrete use case ('usual choice for game engines and web viewers'), which differentiates it from the sibling exporters (export_gltf, export_fbx, export_obj) without naming them. An agent can tell what it does and when it is the right format.

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 'usual choice for game engines and web viewers' line is an implicit usage cue, implying use when targeting those consumers and implying GLB's self-contained nature over GLTF's potentially external files. However, it never names an alternative explicitly, states when NOT to use it, or contrasts with export_gltf, the closest sibling. Guidance is implied, not 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?

No annotations are provided, so the description carries the burden. It discloses the output format (separate .bin and texture files), which is useful, but it does not mention side effects like file overwriting, whether the export is non-destructive to the scene, or what happens on failure. The overwrite parameter defaults to true, but the description doesn't warn about that 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?

Two sentences, zero filler. The core purpose is front-loaded, and the routing guidance is a single clear sentence. Every word earns its place.

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

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

For an export tool with 11 parameters but no output schema, the description is mostly complete: it states the format, the file layout, and the key selection rule. It doesn't explain return values or error behavior, but those are less critical for an export command, and the parameter names are largely self-documenting.

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 18%, so the description should compensate, but it only clarifies the filename stem and the loose-file behavior. Most of the 11 parameters (y_up, export_uvs, selected_only, etc.) are self-explanatory from their names and defaults, so the schema plus names carry the meaning. The description adds minimal value beyond the schema.

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

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

The description states a specific verb ('Export') and resource ('.gltf' with separate .bin and texture files), and explicitly distinguishes it from the sibling export_glb. An agent can tell exactly what this tool produces and how it differs from the closest alternative.

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

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

The description explicitly says 'Use export_glb unless you specifically need the textures as loose files.' This gives a clear when-to-use rule and names the alternative, leaving no ambiguity about tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the key limitation (static geometry only), but it says nothing about file overwriting, whether it modifies the scene, required permissions, or the output file location. This is a modest level of transparency.

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

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

The description is two short sentences with no filler. The core purpose and a key limitation are front-loaded, making it efficient and easy to scan.

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

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

Given the tool has 8 parameters, no output schema, and no annotations, the description is far too thin. It does not explain how to specify objects, how selection interacts with the selected_only flag, or what happens to the output file. An agent would struggle to use this tool correctly without opening the schema and guessing.

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%, yet the description mentions none of the parameters. It does not explain what 'objects', 'filename', 'triangulate', or other options do. The schema itself is largely undocumented, and the description provides no compensation, leaving the agent to infer parameter meaning from titles and defaults alone.

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

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

The description clearly states the action 'Export to .obj' and adds a scope limitation ('Simple static geometry only'), which distinguishes it from more capable export formats like glTF or FBX. However, it does not explicitly mention sibling tools or the export target (selection, scene, etc.), so it is clear but not fully differentiating.

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

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

The description provides a clear usage condition: use this tool only for simple static geometry without animation or PBR. This implicitly tells the agent when to choose another format, but it does not name specific alternatives like export_glb or export_fbx, so the guidance is implicit 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 disclosure burden. It states non-obvious behavior: distance is computed from render aspect ratio and FOV, and the clipping range is widened to suit. It could be more explicit that the camera transform is overwritten or that a camera may be created, but the core mutation and side effects are disclosed.

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, all useful and front-loaded. The first sentence states the purpose, the second explains the computed behavior, and the third gives usage context. No filler or repetition.

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

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

For a tool with six optional parameters and no output schema, the description is complete enough: it explains the operation, the computation, the side effect on clipping, and the intended workflow position. It does not discuss error cases or return values, but those are not essential for this camera-framing 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 83%, so the baseline is 3. The description adds a general angle-control rationale but does not meaningfully elaborate parameter semantics beyond what the schema already provides. The undocumented set_active parameter is not compensated for, though its name makes it reasonably self-explanatory.

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 and resource: 'Position a camera so the given objects exactly fill the frame.' This clearly distinguishes the tool from generic camera movement or look-at behaviors, and the mention of using it before render_preview situates it in a concrete workflow.

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 clear context for when to use it: 'Use this before render_preview when you want to control the angle.' It does not explicitly name exclusions or alternatives such as look_at, but the sequencing and framing intent are clear enough for an agent to select it appropriately.

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