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

The description does not disclose any side effects, success/failure conditions, or interaction with the scene. With no annotations, the burden falls on the description, which provides nothing beyond the basic 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 extremely concise—a single phrase '添加一根骨骼' (Add a bone). It is efficiently front-loaded with no redundant information, though it may be too terse to be fully useful.

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 7 parameters, no output schema, and no annotations, the description is highly incomplete. It provides no context on prerequisites, return values, or how the bone is added in relation to the armature.

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 lists 7 parameters (head, tail, name, roll, parent, connect, armature) but the description does not explain any of them. Schema coverage is 0%, so the description adds no semantic meaning to the parameters.

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

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

The description clearly states the action (add) and resource (bone), matching the tool name. It distinguishes from sibling tools like remove_bone and set_bone, but lacks detail on the armature context.

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

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

No guidance is given on when to use this tool versus alternatives like list_bones or set_bone. The description does not mention any conditions or scenarios.

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 for revealing side effects, error conditions, or requirements. It fails to mention any potential failures, mutations beyond the constraint addition, or dependencies like the bone/armature existing.

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, consisting of two sentences. The first sentence states the purpose with examples, and the second clarifies key settings. It is well-structured and free of unnecessary 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?

Given the presence of 4 parameters and no output schema, the description is minimal but functional. It lacks details about constraint types, how to set them, or any side effects, making it incomplete for agents needing robust execution context.

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 provides no descriptions. The description explains only 'target' and 'subtarget' within settings, leaving 'type', 'armature', and 'bone' undefined (though type is partially exemplified). This gives partial but incomplete parameter coverage.

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: adding a constraint to a bone, and provides example constraint types. It identifies the resource (bone) and the operation (add constraint), which is sufficient for an agent to understand the tool's core purpose.

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 mention when to use this tool versus alternatives or any conditions for its use. It provides some configuration guidance (target and subtarget) but no situational context or prerequisites.

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

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

With no annotations, the description must disclose behavioral traits. It only states that it adds a modifier and that settings are its properties, but it does not explain side effects (e.g., whether existing modifiers are overwritten), permissions, return values, or what happens with invalid input. For a mutation tool, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the action and type list. It is efficient and easy to parse, though it sacrifices detail for brevity. It earns a 4 for being compact and direct.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the purpose of 'object' and 'data_path', does not mention return behavior, and provides no usage context. An agent would be hard-pressed to call this tool correctly without additional documentation.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'type' by listing examples and notes that 'settings' are properties, but it does not explain 'object' or 'data_path'. These are critical for calling the tool correctly, leaving the agent to guess their meaning. The description adds partial value but is not sufficient.

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 the action clearly: '给 fcurve 加修改器' (add modifier to fcurve) and lists supported types (CYCLES/NOISE/LIMITS/STEPPED/GENERATOR…). It is specific about the verb and resource, and the type enumeration gives useful detail. However, it does not explicitly differentiate this from the sibling add_modifier tool, which likely handles object modifiers, so it relies on the resource name for distinction.

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. It does not mention that add_modifier is for object modifiers, nor does it state prerequisites (e.g., having an fcurve selected or a valid data_path). An agent must infer usage from context, which is insufficient.

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, and the description does not disclose side effects, required context, permissions, or side effects on the node tree. As a mutation tool, this lack of transparency is a significant gap.

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

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

The description is brief and to the point, but it is also minimal to the point of being sparse. It contains one useful tip but omits other essential context, so it is not optimally concise for a tool with six parameters.

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

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

Given the complexity of geometry node operations and the presence of many related tools, the description is incomplete. It fails to mention required parameter relationships, expected input formats, or any interaction with the node tree, leaving the agent to infer most 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?

Only the 'type' parameter is partially explained via the prefix rule. The other five parameters (name, inputs, location, node_group, properties) are left entirely to schema names, offering no semantic guidance. Schema coverage is zero, so the description adds minimal value.

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

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

The description clearly states the action ('add') and the resource ('geometry node'), making the primary purpose unambiguous. However, it doesn't differentiate this from other add operations (e.g., add_shader_node, add_modifier), though the resource type is specific enough.

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 on when to use this tool versus alternatives like create_geometry_nodes, build_geometry_node_tree, or link_geometry_nodes. The only additional hint about type prefix is not a usage guideline but a parameter tip.

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 explaining side effects. It conveys that the tool modifies a node group by adding a socket, which is clear, but it does not mention potential side effects, dependencies, or the impact on existing sockets.

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 brief and to the point, consisting of one action sentence and a socket type example list. It is well-structured and easy to parse, though the socket types could be formatted more clearly.

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 5 parameters and 2 required, the description does not fully cover the tool's usage context. It omits explanations for key parameters like in_out and default, and with no output schema, the agent is left without essential operational details.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains socket_type by listing possible values, leaving name, in_out, default, and node_group entirely undocumented. This is insufficient for a multi-parameter tool.

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 ('add') and resource ('socket to node group interface'), and clarifies the purpose of exposing it to the modifier panel. It does not explicitly name sibling tools, but 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 no explicit guidance on when to use this tool versus alternatives. It mentions exposing to the modifier panel, which gives some context, but does not state conditions or contrast with related operations like adding geometry nodes.

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 disclosing side effects. It mentions that the Normal target automatically adds a Normal Map node, which is a useful behavioral detail. However, it doesn't disclose whether the tool creates a new node, replaces existing connections, modifies the material in place, or how colorspace and projection are handled.

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

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

The description is a single, front-loaded sentence that states the core action and lists target options efficiently. It avoids fluff but is borderline terse, earning a high conciseness score.

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 5 parameters, no annotations, and no output schema, the description is inadequate. It fails to explain how to specify image_path, colorspace, or projection, and doesn't clarify whether the material must exist or if the tool creates new nodes. The overall context for successful invocation 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 0%, so the description must compensate. It explains the 'target' parameter's possible values, but provides no guidance for material, image_path, colorspace, or projection. The description adds partial meaning only for one parameter, leaving the rest ambiguous.

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 states a specific action: loading a texture and connecting it to Principled BSDF, and lists the target sockets. This clearly conveys the tool's function and distinguishes it from set_principled_inputs by focusing on the image texture loading aspect, though it doesn't name alternatives explicitly.

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

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

No guidance on when to use this tool versus sibling tools like set_principled_inputs or create_material. The description only states what it does without any context, prerequisites, or exclusions, leaving the agent to infer usage.

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 is the only source of behavioral information. It states that the tool adds a modifier but does not disclose side effects, such as modifying the object's modifier stack, potential overwriting, or destructiveness. It also fails to mention prerequisites like object selection or any irreversible consequences. This lack of transparency is a significant gap.

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

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

The description is concise and well-structured, with the action stated first and additional details provided in a compact parenthetical and a short follow-up sentence. It avoids unnecessary words and is easy to scan. The structure is highly efficient 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?

The description gives enough context for a basic add-modifier operation, including type examples and notes on object referencing and settings format. However, it lacks details on the 'name' parameter, the expected behavior of the settings dictionary, and any return values or side effects. Given the simplicity of the tool and the absence of an output schema, this is a moderate level of 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?

The description partially explains the parameters: it notes that the 'object' parameter takes an object name directly, and the 'settings' parameter uses bpy property names. It also provides example values for 'type' and states there are 83 total types. However, the 'name' parameter is not explained, and the structure of 'settings' is only vaguely described. Since the schema has no parameter descriptions, this partial compensation earns a moderate score.

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

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

The description clearly states that the tool adds a modifier and lists common modifier types (SUBSURF, BEVEL, ARRAY, etc.) along with a total count of 83. It uses the specific verb 'add' and the resource 'modifier,' making it distinct from sibling operations like apply_modifier or remove_modifier. 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 no guidance about when to use this tool versus alternatives such as apply_modifier, remove_modifier, or add_geometry_node. It only states the function and parameter hints, with no mention of conditions or contexts where this tool is preferred. Thus, there is no 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It merely states that an action strip is added, without noting any side effects, requirements (e.g., the object must have an action assigned), or whether the operation is reversible. It does not contradict annotations since none exist, but it is insufficiently transparent.

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

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

The description is a single concise sentence, which is front-loaded and free of fluff. However, it is so brief that it borders on under-specification rather than effective conciseness. It earns a middle score because while it is efficient, it lacks substance for a tool with multiple parameters.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the purpose of each parameter, any constraints, or what happens after execution. An agent would struggle to use this tool correctly without additional documentation or API details.

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

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

Schema description coverage is 0%, meaning the description mentions none of the five parameters. The schema itself has sparse documentation (only titles and defaults), so the description fails to explain what 'track', 'action', 'object', 'blend_type', or 'frame_start' mean or how they interact. This is a critical gap for a tool with required parameters.

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

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

The description '在 NLA 轨道上添加动作片段' clearly states the action (add), the resource (action strip), and the location (NLA track). It is specific enough to distinguish from many siblings, though it doesn't elaborate on what an 'action' means in this context. It is not a tautology and conveys a distinct operation.

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

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

The description provides no guidance on when to use this tool versus alternatives like nla_push_down or bake_animation. There is no mention of prerequisites, typical scenarios, or exclusions. The agent is left to infer usage solely from the name and generic description.

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

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

The description indicates the tool adds a metarig, implying scene modification, but does not mention side effects like object creation or whether it replaces existing rigs. No annotations to supplement.

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

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

The description is a single concise sentence, directly stating the purpose and listing types without any extraneous 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?

While the core action and types are clear, the description omits details about the 'name' parameter and any prerequisites or effects, making it relatively complete for a simple add operation but not fully comprehensive.

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 lists possible values for the 'type' parameter, but does not explain the 'name' parameter or its purpose; schema provides no descriptions either.

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 a Rigify metarig) and enumerates the supported types, distinguishing it from related rig-generation tools.

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

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

No explicit guidance on when to use this tool versus alternatives like generate_rigify_rig; it only lists metarig types, not usage context.

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 reveals some operational behavior (type prefix can be omitted, inputs are set by socket name, properties accept values like blend_type), but says nothing about success/failure behavior, return value, whether existing nodes are replaced, or error handling for invalid types or missing sockets.

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 clauses front-load the core action and pack genuinely useful operational detail (prefix omission, socket-name inputs, property setting) into minimal space 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?

A six-parameter tool with no annotations, no output schema, and 0% schema coverage requires much more context than this. The description covers only half the parameters and omits return behavior, error conditions, and the meaning of name and location, leaving an agent with significant gaps when invoking the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for three parameters (type via the TexNoise prefix example, inputs via socket-name setting, properties via blend_type example), but leaves name, location, and material entirely unexplained, failing to fully compensate for the complete absence of schema descriptions.

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

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

Description clearly states verb '添加' (add) and resource '节点' (node), making the core action unambiguous. It provides useful detail about type prefix handling, but does not differentiate from related siblings like add_image_texture, add_geometry_node, or build_node_tree, which all add nodes in different contexts.

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

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

No guidance on when to use this tool versus alternatives such as set_node_input, set_node_property, or link_nodes. The description gives operational hints (prefix omission, socket-based inputs) but never states the conditions under which this tool is preferred over its many shader-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?

The description only states the high-level action and does not disclose side effects such as whether the new UV map becomes active, how the optional 'set_active' parameter behaves, or what happens if the name already exists. Since no annotations are present, the description carries the full burden and fails to provide this information.

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 short and contains no fluff, but it is under-specified. It lacks the detail needed to be properly informative and is too terse to be considered well-structured for an API tool.

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

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

Given the complete absence of parameter descriptions, output schema, and any behavioral notes, the description is far from complete. An agent would not be able to correctly invoke this tool based solely on this description.

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?

None of the parameters (name, object, set_active) are described in the schema or the description. The description does not compensate for the 0% schema coverage, leaving the meaning and requirements of each parameter unclear.

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 '新增 UV 层' clearly identifies the action as adding a UV layer/map and distinguishes it from related operations such as remove_uv_map and list_uv_maps. It is concise and understandable, though it uses 'layer' instead of the more precise term 'UV map'.

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

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

There is no guidance on when to use this tool versus alternatives like list_uv_maps, unwrap_uv, or remove_uv_map. The description provides no context for selecting this 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?

No annotations are provided, and the description does not disclose side effects (e.g., whether new objects are created, whether the operation is destructive, or how the 'link' parameter affects behavior). It only states the basic action without detailing consequences.

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

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

The description is a single, concise sentence that immediately conveys the core functionality. There is no redundant wording 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?

For a tool with four parameters, the description is highly incomplete. It omits any information about required inputs, the meaning of the 'link' flag, or the outcome of the operation, leaving the agent to guess how to invoke it correctly.

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

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

None of the four parameters (path, datablock, name, link) are explained in the description or schema. The description gives no hints about expected values, formats, or how the parameters interact.

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

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

The description clearly states the action (append/link) and the resource (data block from a .blend file), and lists common data block types. It distinguishes from sibling tools like import_file by focusing on appending/linking specific data blocks, though it could be more explicit about the target scene context.

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

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

There is no guidance on when to use this tool versus alternatives such as import_file, import_local_asset, or search_local_assets. The description does not mention any conditions or recommended usage scenarios.

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

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

The description does not disclose the destructive nature of applying a modifier (it permanently alters the mesh). No annotations are present to compensate. The lack of any behavioral detail leaves the agent unaware of the irreversible side effects.

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

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

The description is extremely brief and front-loaded, which is efficient. However, the brevity sacrifices essential detail, making it borderline too terse. Still, it is not verbose, so it earns a decent score for conciseness.

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

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

Given the large number of sibling modifier tools, this description lacks almost all necessary context: it does not clarify the precise operation, prerequisites (e.g., a modifier must already exist), or consequences. A user or agent cannot confidently choose this tool based solely on the provided information.

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 (object and modifier) are only typed as strings with no description. The schema provides no additional information (0% coverage). The description does not explain how to specify the object (by name? reference?) or what identifier is expected for the modifier. This is a significant 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 clear action ('apply modifier to mesh'), but it does not specify what 'apply' means in Blender (i.e., permanently baking the modifier's effect), nor does it differentiate from sibling tools like add_modifier, set_modifier, or remove_modifier. The action is understandable but ambiguous without domain knowledge.

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

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

There is no guidance on when to use this tool versus alternatives. For example, it does not mention that it should be used only when a modifier is meant to be permanently applied, or that set_modifier might be more appropriate for adjusting settings. No usage context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'apply transforms' without stating that it modifies object data and resets transform values, nor does it mention potential destructive or irreversible effects. The description is too sparse to be transparent about the operation's side effects.

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

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

The description is a single short sentence with no wasted words, and the core action is front-loaded. It is appropriately concise, though it sacrifices necessary detail for brevity.

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 four parameters, one required, and no annotations, the description is incomplete. It does not explain the effect of each boolean, the expected format of 'objects', or any return value (though an output schema exists, it is not shown). It also does not help the agent decide when to use this tool among many related siblings.

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 by explaining parameters. It does not mention that 'scale', 'location', and 'rotation' are toggles controlling which transforms to apply, nor what the 'objects' parameter expects. The parameter names are self-explanatory, but the description adds no semantic value beyond them.

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

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

The description states a specific verb ('apply') and resource ('transforms to mesh data'), which is clear enough to distinguish from sibling tools like apply_modifier or set_transform. However, it does not explicitly say that applying resets the object's transform values to zero while baking them into the mesh, which is a key nuance. It is concise and unambiguous at a high level.

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

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

There is no guidance on when to use this tool versus alternatives such as set_transform or apply_modifier. The description does not mention any conditions, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description bears the full burden. It mentions the 'create new' behavior but does not disclose side effects, reversibility, permissions, or what happens to existing actions. This is minimal and insufficient.

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

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

The description is a single concise sentence with no fluff. It front-loads the main verb and the special case. However, it lacks structure and elaboration.

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 2 parameters, no output schema, and no annotations, this description is severely under-specified. It leaves essential details about what an 'action' is, how it is represented, and expected outcomes entirely unexplained.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only implies that omitting 'action' creates a new one; it does not explain the format or constraints for 'object' or 'action', nor the semantics of 'omit'.

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 ('assign') and resource ('object'), and hints at a special case (omit to create new). However, the term 'action' is ambiguous without context, and it does not differentiate from sibling tools like assign_material or assign_*.

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. It does not specify prerequisites, context, or scenarios where a different tool would be more appropriate.

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 disclosing behavior. It does mention that the slot is created if it does not exist, but it does not state whether an existing material in that slot is overwritten, whether the object must exist, or any other side effects. For a mutation tool, this is insufficient behavioral 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 a single concise sentence that front-loads the core purpose and includes the key behavioral detail about slot creation. There is no wasted wording, and it is appropriately sized for the tool's simplicity.

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 incomplete for a mutation tool without annotations or an output schema. It does not clarify behavior when the slot already has a material, whether the material must pre-exist, possible errors, or any return value. An agent cannot fully predict the tool's outcome from this description alone.

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

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

Schema description coverage is 0%, so the description must compensate. It adds semantics for the slot parameter (default 0, create if missing), which is beyond the schema's default null. However, it provides no additional meaning for object and material parameters, though their names are self-explanatory from the tool name and Blender context. The description partially compensates but does not fully clarify expected formats or 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 states a specific action: assign a material to an object's slot, with a default slot of 0 and creation of the slot if missing. This clearly distinguishes it from sibling tools like create_material (which creates materials) and batch_apply_material (which applies to multiple objects). The verb and resource are explicit.

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 no guidance on when to use this tool versus alternatives. It does not mention conditions like 'use this when the material already exists' or 'use batch_apply_material for multiple objects.' It only states what it does, not when to choose it over other material-related 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 transparency, but it does not disclose side effects such as whether existing keyframes are overwritten, whether constraints are cleared (despite a clear_constraints parameter existing), or how the baking process affects the object's animation data. The description is too minimal to inform the agent of the tool's behavior beyond the basic 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 concise and directly to the point, with no superfluous words. The single sentence is front-loaded with the core purpose. While it could be more structured (e.g., explaining default behavior), the text itself is appropriately sized for a high-level summary, avoiding verbosity.

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

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

Given the tool's complexity (6 parameters, including nullable frame boundaries and boolean flags) and the lack of schema descriptions and annotations, the description is far too brief. It does not explain the baking process, the meaning of the parameters, or the outcome, leaving the agent with insufficient context to use the tool correctly. The description must compensates for the missing structured info, but it does not.

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 provides no descriptions for any of the 6 parameters, and the description does not elaborate on their meanings. Parameters like 'step', 'frame_start', and 'clear_constraints' are left entirely to inference. Since schema coverage is 0%, the description must compensate, but it fails to add any meaningful parameter details.

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 function: baking motion from constraints, parenting, and NLA into per-frame keyframes. It uses a specific verb ('bake') and a specific resource ('motion of constraints/parent/NLA'), making its purpose unambiguous. This also distinguishes it from sibling tools like insert_keyframe or set_frame_range.

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 on when to use this tool versus alternatives. There is no mention of typical use cases, prerequisites, or scenarios where other animation tools would be more appropriate. The description is purely functional with no contextual usage advice.

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 burden but only partially discloses behavior. It mentions auto smart projection and PNG output, but omits side effects like UV modification, image creation, file overwriting, or whether the object is modified permanently.

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 very brief and to the point, with no redundant wording. It packs key information into two short sentences.

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

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

Given the tool's complexity and 9 parameters, the description is incomplete. It lacks information about prerequisites, parameter interactions, return values, or failure modes, making it insufficient for a robust agent 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 has 9 parameters with zero descriptions. The description only explains bake_type values and output_path behavior, leaving size, margin, samples, image, cage_extrusion, and selected_to_active 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?

Description clearly states the tool bakes textures using Cycles and lists common bake types, distinguishing it from render/save tools. It could be slightly more explicit about the end result but is generally specific.

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 some usage context, such as automatic smart UV projection when no UVs exist and output as PNG. However, it does not mention when to choose this over alternatives or prerequisites like selecting objects or enabling Cycles.

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. The only behavioral hint is the word 'batch', but nothing explains whether existing modifiers are replaced, whether the operation is destructive, what the 'settings' parameter affects, or what the return value is. For a mutating batch operation with zero annotation coverage, this is a significant gap.

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

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

While the text is short, this is under-specification rather than genuine conciseness. A one-sentence description that merely echoes the tool name does not earn its place; it provides no structural value in front-loading critical decisions.

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?

Completely inadequate for a batch mutation tool with 3 parameters, no output schema, and no annotations. Missing critical information: valid modifier type values, object selection semantics, settings structure, and any behavioral caveats. An agent cannot reliably construct a correct call from this definition alone.

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

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

Schema description coverage is 0% and there are three undocumented parameters. The description does not explain what 'type' refers to (which modifier types are valid), what 'objects' can be (array, object, or string), or how 'settings' should be structured. The description fails to compensate for the schema's complete lack of parameter documentation.

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 '批量加修改器' (batch add modifiers) simply restates the tool's name. It identifies the action (add) and resource (modifiers) but adds no specification about what kinds of modifiers, what objects, or how it differs from single-add or apply operations. It borders on tautology since the name already conveys the same information.

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 whatsoever about when to use this tool versus its siblings like add_modifier (single add), apply_modifier, set_modifier, or the other batch_* operations. An agent has no way to know whether to reach for batch_add_modifier or add_modifier for a given task.

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 and a minimal description, there is no disclosure of side effects, whether existing materials are replaced, or how the operation behaves on multiple objects. The description provides no behavioral insight.

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 short, which makes it concise, but it lacks structure and essential information. It is more of a label than a functional description, so it is not effectively front-loaded with useful 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?

Given the tool has two required parameters and no output schema, the description should clarify how to invoke it correctly. It does not address parameter formats, prerequisites, or typical use cases, leaving the agent under-informed 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 parameters 'objects' and 'material' are named but not explained. The 'objects' field has a complex union type (array, object, string) with no clarification of accepted forms, and 'material' is ambiguous (name, ID, or path). The description adds no semantic value.

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

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

The description '批量赋材质' conveys the core action of batch-assigning materials, but it is a bare phrase without context. It does not specify scope or differentiate from the sibling tool 'assign_material', leaving the purpose only partially 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 guidance on when to use this tool versus alternatives like 'assign_material' or 'create_material'. The description offers no situational context or selection criteria.

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

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

No annotations or description disclose side effects, irreversibility, or whether undo is supported. Batch delete is inherently destructive, but this is not communicated, making the tool behavior opaque.

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

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

The description is extremely concise, consisting of only two characters, but it lacks any structured explanation. It is a bare phrase without context or elaboration, which is insufficient for effective use.

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 tool is incomplete in context: it does not describe return values, error handling, or the meaning of the 'objects' parameter. While sibling tools hint at batch operations, the description alone does not provide enough information for an agent to use 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?

The 'objects' parameter is a union of array, object, and string, but the description provides no explanation of what values should be passed or how they are interpreted. This ambiguity is critical for a delete 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 'Batch delete' clearly indicates a verb ('delete') and a resource ('batch'), but does not specify what is being deleted. In the context of sibling batch tools, it likely refers to objects, but the description alone lacks that specificity.

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 on when to use this tool versus alternatives like delete_object or other batch operations. There is no mention of scenarios or prerequisites, leaving the agent without clear direction.

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 transparency burden. It lists rename modes but does not disclose effects such as name overwrites, sequence ordering for numbering, or that find/replace requires both parameters to work together. Behavioral outcomes are only partially 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?

The entire description is one short sentence that front-loads the purpose ('批量重命名') and then lists the four modes after a colon. There is no filler or redundancy, making it maximally 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 six parameters, one required, no output schema, and no annotations, the tool is moderately complex, but the description only provides the high-level purpose and mode list. It omits operational details the agent needs to invoke correctly, such as mode interactions, find/replace pairing requirements, and the target `objects` format. This leaves the description thin for reliable 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 coverage is 0% since no property descriptions exist, so the description must map parameters to meaning. It does map prefix→前缀, suffix→后缀, find/replace→查找替换, and numbering→编号, giving functional roles. However, it does not clarify the `objects` parameter's accepted forms (array/object/string), the required pairing of find and replace, or how modes combine.

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 the verb '批量重命名' (batch rename) and enumerates its modes—prefix, suffix, find/replace, numbering—making the action and capabilities clear. The 'batch' wording distinguishes it from the singular rename_object sibling. The target resource (objects) is implied rather than named explicitly, which is a minor gap.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives such as the singular rename_object or the other batch_* siblings. The 'batch' prefix implies multi-object use, but nothing states the selection criteria or excludes single-object scenarios. This leaves the agent to infer the boundary.

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

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

With no annotations provided, the description carries full responsibility for disclosing side effects. It does not mention that the tool modifies the specified properties on each object in the 'objects' list, potential error behaviors for invalid paths, or any other consequences. The description is a bare statement of intent without behavioral details.

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

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

The description is extremely concise—a single sentence with illustrative examples. It is efficiently structured and contains no superfluous 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?

Given the tool's simplicity, the description is minimal but lacks essential context such as return value (no output schema), expected input format for 'objects', and any interaction with Blender's selection state. The absence of usage guidance and parameter explanations makes the description incomplete for confident 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?

The description only clarifies the 'data_path' parameter via examples. It does not explain the expected format or meaning of the 'objects' parameter (e.g., object names, references) nor the accepted types or semantics of the 'value' parameter. Since schema coverage is 0%, the description leaves the majority of parameter meanings ambiguous.

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: batch-setting arbitrary property paths with concrete examples. It is specific about the action (batch set) and the target (arbitrary property paths). However, it lacks explicit differentiation from similar tools like set_custom_property, though the term 'arbitrary property' implies broader scope.

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

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

The description provides no guidance on when to use this tool versus alternatives such as set_custom_property or other per-object setters. It does not mention scenarios where batch_set_property is preferred, nor any prerequisites or context for its 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that the operation is 'incremental' by default, but does not clarify what incremental means relative to the 'relative' parameter, whether the operation is destructive or reversible, or what happens to existing transform values. For a mutation tool with zero annotation coverage, this is a critical 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 a single short phrase, but this is under-specification rather than conciseness. While it is front-loaded and free of filler, it earns no credit because there is essentially no substantive content to be concise about.

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 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. An agent cannot determine required inputs, expected behavior, or return values from this definition alone.

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

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

Schema description coverage is 0%, so the description must compensate for the five undocumented parameters (scale, objects, location, relative, rotation). It adds no meaning to any of them - an agent has no idea what values these accept or how they interact (e.g., that 'relative' likely toggles between incremental and absolute transforms).

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 '批量变换（默认增量）' is essentially a translation of the tool name 'batch_transform' plus a vague parenthetical about incremental behavior. It does not state what is transformed (position, scale, rotation), what objects are affected, or how this differs from siblings like set_transform, apply_transforms, randomize_transform, or batch_set_property. This borders on tautology.

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

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

There is no guidance on when to use this tool versus the many transformation siblings (set_transform, apply_transforms, randomize_transform, distribute_objects). The '默认增量' (default incremental) note hints at behavior but provides no decision criteria, no prerequisites, and no exclusion 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?

The description mentions the all-at-once nature but does not disclose side effects such as whether existing nodes are cleared, how the clear parameter works, or whether the operation replaces or appends. There are no annotations to provide this information.

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 very brief and to the point, but it lacks any structure such as bullet points or parameter explanations. It is concise but not particularly well-organized for a tool with four parameters.

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

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

The tool is complex (building a geometry node tree), yet the description provides almost no context about input formats, expected behavior, return values, or error conditions. Without annotations or an output schema, an agent would be left 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?

The schema lists parameters with no descriptions, and the description merely says 'format same as build_node_tree', which does not clarify the roles of clear, links, nodes, or node_group. The description adds no meaning beyond the types.

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

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

The description clearly states it builds a geometry node tree in one shot and references the format of build_node_tree, which distinguishes it from incremental node editing tools. The verb 'build' and resource 'geometry node tree' are specific.

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

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

No explicit guidance on when to use this tool versus alternatives. The phrase 'in one go' implies a batch operation, but it does not explain when this is preferable to using build_node_tree or add_geometry_node.

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 explains the data structures but says nothing about side effects such as whether the existing node tree is cleared, whether 'clear' is destructive, or how the required 'material' is applied.

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 compact line with the main action front-loaded. It has no filler, though its terseness borders on cryptic.

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 tool with 4 parameters, no annotations, and no output schema, the description is too incomplete. It does not explain the required material parameter, the clear behavior, or the relationship to an existing node tree.

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

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

Schema coverage is 0%, and the description does partially compensate by defining the node fields (type, name, location, inputs, properties) and link fields. However, it completely omits the required 'material' parameter and the 'clear' boolean, leaving two of four parameters unexplained.

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

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

The description states a specific action ('一次性建树' – build tree in one pass) and gives the input shape for nodes and links. However, it does not distinguish itself from the sibling tool build_geometry_node_tree, which sounds similar.

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

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

There is no guidance on when to use this tool versus alternatives like build_geometry_node_tree, link_nodes, or set_node_input. The description only provides input formats, not contextual usage or 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 must disclose side effects and return behavior, but it does neither. It does not state whether this is a read-only check, what output it produces, or whether it modifies the armature.

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 brief but reads as a list of keywords rather than a coherent sentence. It is concise but lacks structural flow, making it less informative than a well-formed 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?

The description omits essential context such as what the check returns (e.g., errors, warnings, a report), how results are presented, and whether the check has side effects. Given the tool's purpose, this is a significant gap.

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

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

The only parameter 'armature' has no description in the schema or the tool description. Since schema description coverage is 0%, the agent receives no explanation of what the parameter expects (e.g., object name, ID, or path).

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

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

The description names the resource (armature) and the action (check hierarchy), and specifies key aspects like orphan bones and maximum depth. It is distinct from similar tools like check_rig or check_bone_naming, making its purpose reasonably clear, though it is a phrase rather than a full sentence.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or relationships to other checking tools, leaving the agent to infer the appropriate context.

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 the tool checks for missing mirrors and non-standard naming but does not disclose what the tool does with the results (e.g., returns a list of issues, modifies anything), whether it is read-only, or any side effects. This is a significant gap for a validation 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 concise sentence that gets straight to the point. It is well-structured with the action and scope clearly stated, but it sacrifices necessary context for brevity. It earns credit for being compact, though it could be slightly longer to include key usage 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?

Given the tool has two parameters, no output schema, and no annotations, the description is inadequate. It does not explain the convention parameter, what constitutes 'non-standard naming', what the tool returns, or any prerequisites (e.g., armature must be selected). The agent cannot confidently invoke it correctly based on this description alone.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning, but it does not. It never mentions 'armature' or 'convention' or how they influence the check. The convention parameter (default BLENDER) is entirely unexplained, leaving the agent without any guidance on valid values or impact.

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 function: checking .L/.R symmetric naming in bones, specifically looking for missing mirrors and non-standard naming. It uses a specific verb (check) and resource (bone naming), and it is distinct from sibling tools like check_rig or check_bone_hierarchy, which focus on other aspects of rigs.

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 check_bone_hierarchy or check_rig. It does not mention scenarios where this tool is preferred or excluded, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It lists what it checks but does not disclose whether it modifies anything, what it returns (report, log, etc.), or any side effects. The term '体检' implies a read-only diagnostic, but this is not explicit.

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 very concise, listing checks in a single line, which is efficient. However, it lacks any structure for parameter or usage information, and the flat list format doesn't help an agent parse the tool's interface.

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

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

For a tool with a required parameter and no output schema or annotations, the description is severely incomplete. It doesn't explain the parameter, the return value, or the usage context. An agent would have to guess the meaning of 'name' and the expected result.

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

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

The single required parameter 'name' is not described at all. Schema description coverage is 0%, and the description does not explain what 'name' refers to (object name? mesh name?). An agent cannot reliably know what to pass.

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 checks mesh attributes: vertices/edges/faces, triangle/quad/ngon, non-manifold edges, loose points, duplicate vertices. It uses a specific verb (check) and resource (mesh), and the listed checks distinguish it from siblings like mesh_cleanup which would fix issues. However, it doesn't explicitly state the output 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?

No guidance on when to use this tool versus alternatives like mesh_cleanup. It's implied that it's for diagnosing mesh issues before cleanup, but this is not stated. The description lacks any mention of recommended usage context or 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 provided, the description carries the full burden of disclosing behavior. It lists checks but does not state whether the tool is read-only, whether it modifies the armature, what it returns (e.g., a report, a list, a boolean), or any prerequisites (e.g., selection state). A 'check' tool is typically non-destructive, but this is not explicit, and the absence of any behavioral detail is a significant gap.

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

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

The description is a single, concise sentence that front-loads the purpose ('骨架综合体检' = comprehensive skeleton check) and then lists the specific checks. It is efficient and avoids fluff, but the structure is a run-on list that could benefit from clearer grouping or formatting. Still, it earns points for being compact and information-dense.

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

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

The tool has no output schema, no annotations, and a single parameter with zero schema description coverage. The description fails to explain the output format, any side effects, prerequisites, or how to interpret results. For a diagnostic tool that checks multiple rig issues, an agent needs to know what the return value looks like and whether any action is required. The description is fundamentally incomplete for safe and 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 a single required parameter 'armature' (string), but the description never mentions it. Schema description coverage is 0%, so the description must compensate by explaining what 'armature' refers to (e.g., object name, path, or selection), but it does not. The agent receives no guidance on how to supply the parameter or what valid values are.

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 function: a comprehensive rig health check, listing specific issues it detects (zero-length bones, multiple roots, etc.). It uses a specific verb-resource pair ('check_rig') and enumerates concrete checks, which gives the agent a precise sense of what it does. It doesn't explicitly differentiate itself from sibling check tools like check_bone_hierarchy or find_unweighted_vertices, but the list itself implies a broader scope.

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

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

The description provides no guidance on when to use this tool versus the many sibling diagnostic tools (check_bone_hierarchy, check_bone_naming, find_unweighted_vertices, list_constraint_issues, etc.). It doesn't state whether this is a first-pass diagnostic, whether it should be used before specific checks, or when to prefer individual tools. The agent is left to infer usage context from the tool name alone.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only states the input format. It does not mention side effects like creating a new object in the scene, whether existing armatures are affected, error handling, or any prerequisites. This is a significant 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 extremely concise, with two short sentences that front-load the core purpose and the key parameter format. It wastes no words, though it sacrifices completeness for brevity.

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 that creates an armature with a bone chain, the description covers only the bones parameter partially. It omits the 'location' parameter semantics, any return value (though no output schema exists), and does not specify what happens in the scene (e.g., object creation, naming conventions). The description is insufficient for an agent to call this correctly without further assumptions.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'bones' parameter structure with optional fields, which is helpful, but it does not elaborate on the meaning of 'head', 'tail', or the 'location' parameter. The description adds value for bones but leaves other parameters under-documented.

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

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

The description clearly states the tool's purpose: '新建骨架' (create armature) and provides the exact bone format for building a bone chain at once. This distinguishes it from sibling tools like add_bone which operate on existing armatures, and from other creation tools like create_primitive.

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 this tool is for creating a new armature with a bone chain in one go, which hints at when to use it versus add_bone for incremental bone addition. However, it does not explicitly state when not to use it or mention alternatives, leaving usage context 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, and the description does not disclose side effects (e.g., whether the camera becomes active, affects scene state, or requires existing objects). It also omits return values or error behavior.

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

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

The description is extremely brief and to the point, consisting of two short sentences. It avoids redundancy and directly states the action and key parameter hints, though it could be improved with a structured breakdown of parameters.

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

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

With nine parameters and no output schema, the description is highly incomplete. It does not explain the overall workflow, how the tool integrates with other camera operations, or what the agent should expect after calling it. The minimal text fails to cover the tool's complexity.

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

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

The description clarifies that 'type' accepts PERSP/ORTHO and that 'lens' is focal length in mm, but it leaves the other seven parameters (location, rotation, clip_start, clip_end, sensor_width, set_active, name) unexplained. Given the schema has no descriptions, this is insufficient coverage.

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 explicitly states '新建相机' (Create camera) with a specific verb and resource, and it clearly distinguishes this tool from siblings like list_cameras and set_camera. The added note on type (PERSP/ORTHO) and lens units further clarifies the purpose.

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 such as set_camera or point_camera_at. There is no mention of typical use cases, prerequisites, or conditions favoring 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?

The description discloses the main side effect of creating both a modifier and a node group with a direct Group Input to Output connection. However, it does not mention default naming behavior, potential conflicts, or what happens if optional parameters are omitted.

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

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

The description is a single concise sentence with no redundant information. It efficiently conveys the core action and the included direct connection.

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 too sparse for full context. It does not mention default values, return behavior, error conditions, or how this tool fits with the broader set of geometry node and modifier tools.

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 provides no parameter descriptions, and the description only gives a minimal implication that 'object' is the target. 'group_name' and 'modifier_name' are inferable from naming conventions but are not explicitly 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 tool creates a new geometry node modifier and node group on an object, including a Group Input to Output direct connection. This distinguishes it from related tools like add_geometry_node or 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 description explains what the tool does but provides no guidance on when to use it versus alternatives such as add_geometry_node, build_geometry_node_tree, or add_modifier. No explicit usage context or exclusions are given.

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

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

No annotations are provided, and the description does not disclose side effects, whether it creates a Blender datablock or an external file, or how default parameters like alpha, color, and float_buffer behave.

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

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

The description is a single concise sentence with no redundant words. However, it is so sparse that it omits important context, making it efficient but not fully appropriately sized for the tool's complexity.

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

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

Given six parameters, zero schema description coverage, and no output schema, the description is completely inadequate. It fails to explain what parameters do, what defaults mean, or how the returned image object is used.

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?

None of the six parameters (name, alpha, color, width, height, float_buffer) are explained. The schema contains no descriptions and the one-line description adds no parameter-level meaning.

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

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

The description clearly states the tool creates a new blank image, using a specific verb and resource. It is distinguishable from nearby operations like saving images or adding textures, even without explicitly naming 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?

There is no guidance on when to use this tool versus alternatives such as list_images, save_image, add_image_texture, or create_pbr_material. It only states the action without any contextual direction.

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. The description indicates creation (a mutating operation) and provides some parameter semantics, but does not disclose whether this creates a new object, what the default values are, whether it requires an active object/context, or what the return/result is. For a creation tool with zero annotation coverage, this is a meaningful 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 compact sentence front-loads the essential parameter semantics with units and meanings. Zero filler, every clause earns its place. Very efficient for an 11-parameter tool.

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

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

The tool is a creation operation with 11 parameters, no annotations, no output schema, and 0% schema coverage. The description covers the core parameters and their units, which is the most critical information. However, it omits spot_blend, doesn't describe the return value (no output schema), and doesn't state behavioral defaults. For a complex creation tool, this 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?

Schema description coverage is 0%, so the description must compensate. It adds real semantics: type values (POINT/SUN/SPOT/AREA), units for energy (watts), radius meaning (soft shadow), size meaning (area light dimensions), spot_size in radians, and target semantics (point object or coordinates). It covers 6 of 11 parameters well. It misses spot_blend entirely, and doesn't clarify color array format, but the covered parameters are genuinely useful beyond the bare 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 ('新建' / create) with the resource (灯光 / light), and enumerates the light types (POINT/SUN/SPOT/AREA). It differentiates from siblings like set_light (modify existing) and point_light_at (orient only) by implying this tool creates a new light. However, it doesn't explicitly name the sibling alternative or state 'use set_light to modify existing lights'.

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 (create a new light with specified parameters) but provides no explicit when-to-use guidance or exclusions. It doesn't state that set_light should be used for modifying existing lights, or that point_light_at handles targeting separately. The context is clear enough for an agent to infer this is the creation entry point, but the when/not alternatives are left implicit.

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

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

没有注释，描述承担了行为披露的全部责任。它揭示了alpha<1时自动切换为BLENDED的关键行为，但未提及权限要求、是否破坏性、返回值或其他副作用。对于创建材质这类非破坏性操作，缺失的信息不多，但描述仍不够全面。

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?

描述仅有三句话，用分号分隔，简洁且重点突出。信息密度高，没有冗余，但可能因过于精简而遗漏了其他参数信息。结构合理，关键行为放在前面。

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?

工具涉及9个参数，但描述仅覆盖其中两个，也没有说明输出或返回值。尽管输出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?

描述仅说明了alpha和assign_to两个参数的行为，其余参数如ior、metallic、roughness、base_color等均未提及。参数schema描述覆盖率为0%，描述未能补偿，用户只能靠参数名猜测含义，缺乏必要的语义解释。

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?

描述明确了“新建 Principled BSDF 材质”，动词+资源具体，且通过alpha和assign_to的行为进一步区分了与其他材质创建工具的差异。与兄弟工具如create_pbr_material相比，它明确指出了BSDF类型，目的清晰。

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?

描述没有明确说明何时使用此工具而非其他材质创建工具，也没有提及替代方案或排除条件。alpha和assign_to的行为隐含了使用场景，但缺少明确的“当需要…时使用”或“当…时不用”的指导。

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the material is assigned to an object (despite the assign_to parameter), whether it overwrites an existing material, or what happens with missing texture maps. As a mutation tool, this lack of behavioral detail is a significant gap.

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

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

The description is a single concise sentence, which is efficient, but it under-specifies essential information. It front-loads the main purpose but omits parameter details and behavior, making it more under-specified than concisely complete.

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, and no annotations, this description is severely incomplete. An agent cannot infer parameter semantics, side effects, or return values, making it nearly impossible to use correctly without additional documentation.

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, but it only mentions 'a set of texture paths' generically. It fails to explain that each parameter (base_color, normal, etc.) is a file path and what assign_to controls. This is inadequate for 8 parameters.

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

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

The description states a clear verb ('create') and resource ('PBR material'), and implies the key input (texture paths). It distinguishes itself from siblings like create_material (which may create generic materials) and set_principled_inputs (which modifies existing), though it could be more explicit about the specific maps it handles.

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 create_material, assign_material, or material_from_texture_folder. It doesn't state prerequisites (e.g., having texture files ready) or mention scenarios where a different tool would be more appropriate.

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 of behavioral disclosure. It does provide useful context about which parameters apply to which primitive types (e.g., size for cube/plane/monkey, radius for spheres), which is beyond the schema. However, it does not disclose typical creation behaviors like adding the object to the scene, default naming, return values, or any side effects. This is a moderate gap given the lack of annotations.

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

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

The description is a single, efficient sentence that front-loads the purpose and immediately provides the list of types and parameter mappings. Every part contributes to the agent's understanding, with 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?

With 11 parameters, no output schema, and no annotations, the description is insufficiently complete. It omits explanations for several parameters (name, scale, location, rotation, collection, text) and does not describe expected behavior on success, return values, or potential side effects. The description covers the core primitive types but leaves critical operational details unaddressed, making it hard for an agent to use the tool correctly without additional assumptions.

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 (approximately 45% – only type, size, radius, depth, and segments are mentioned). The description compensates by explaining which parameter applies to which primitive type, adding value beyond the schema. However, many parameters (name, text, scale, location, rotation, collection) are not described at all, leaving significant ambiguity. The description partially compensates but does not fully cover the 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 clear verb ('新建' = create) and resource ('基础物体' = basic object), and enumerates the specific primitive types supported (cube, plane, sphere, etc.). This distinguishes it from sibling tools like create_light, create_camera, and create_material, which create different resources. 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 implies its use for creating any listed primitive, which is clear from the tool name and content. However, it does not explicitly state when not to use it or mention alternatives (e.g., 'for lights use create_light'). The context is sufficient for an agent to infer the appropriate scenario, but explicit exclusions are absent.

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

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

The description does not disclose any behavioral aspects such as whether the operation is destructive, whether it can fail silently, or whether it affects only the specified frame. With no annotations, this information is entirely 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 a single concise sentence that is front-loaded with the primary action. There is no fluff or unnecessary wording.

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 extremely sparse. It fails to cover critical context such as what 'data_path' refers to, how the 'index' parameter is used, whether a keyframe is required to exist, or any error conditions. The tool cannot be used correctly based solely on this description.

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 provides zero descriptions for the four parameters (object, data_path, frame, index). The description also does not explain any of them, especially the optional 'index' parameter, which is ambiguous without further context.

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

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

The description clearly states the action (delete a keyframe), but lacks context about the target (object, data_path) or when to use it relative to similar tools like insert_keyframe or list_keyframes. It is understandable but not fully 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 is provided on when to use this tool versus alternatives. There is no mention of prerequisites, such as whether a keyframe must exist, or how it interacts with other keyframe operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates deletion and unlinking, but does not disclose side effects such as whether the material data block is permanently removed, whether the operation is reversible, or how it affects other objects using the same material. For a mutation tool, this is a significant gap.

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

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

The description is a single, compact sentence that front-loads the main action. It is appropriately sized for the tool's simplicity, though it could include a bit more detail 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 deletion/unlink tool with two parameters and no output schema or annotations, the description is incomplete. It does not explain the behavioral difference between unlink_only true and false in terms of consequences, nor does it mention what happens to the material data block. An agent needs this context to call the tool correctly and avoid unintended data loss.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. The unlink_only parameter is partially explained by the phrase 'or just unlink from object', which adds meaning. The name parameter is self-explanatory from its name and required status, but the description does not explicitly clarify it. Overall, it adds some value but not comprehensive 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?

The description clearly states the primary action is deleting a material, and clarifies an optional unlink-only behavior. It distinguishes between full deletion and unlinking, which helps an agent understand the core functionality. However, it does not explicitly specify the scope (e.g., from the entire file vs. from an object), and it doesn't reference sibling tools to aid 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 description implies usage by stating the action, but it provides no explicit guidance on when to choose this tool over alternatives like assign_material or unlink_nodes. It mentions the unlink_only option, which hints at a use case (removing from object without deleting), but does not state when to prefer this over other material operations.

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

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

No annotations are provided, so the description bears full responsibility. It mentions deletion and optional child deletion but does not disclose potential side effects like irreversibility, impact on references, or confirmation requirements.

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

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

The description is a single, concise sentence that leads with the action and includes all essential information without 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?

The description is sufficient for a simple delete operation, covering the main actions and parameter semantics. However, it does not mention return values, error handling, or effects on related objects, which would enhance 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?

The description adds significant meaning to the 'objects' parameter by clarifying it can be a name list or filter, and explains 'delete_children' as deleting child objects. This fully covers the schema's vague parameter 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 that the tool deletes objects by name list or filter, with optional child deletion. It is specific and distinguishes from siblings like batch_delete or delete_material.

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

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

The description implies usage for deleting objects but does not explicitly compare to similar tools like batch_delete or provide conditions for when to use this tool instead. No guidance on filter syntax is given.

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

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

No annotations are provided, and the description does not mention side effects, whether it modifies object transforms directly, or if it operates on selected objects or the provided 'objects' list. It lacks transparency about the mutation nature of the tool, which is important for agents.

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, compact sentence that efficiently conveys the tool's functionality and mode-specific behaviors. It is well-structured and avoids unnecessary detail, 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?

The description provides sufficient context for the tool's modes and main parameters, making its operation clear for typical use cases. However, it does not mention the return value or any preconditions (e.g., whether objects must be selected), and it omits the 'spacing' parameter. Overall, it is fairly complete but lacks a few operational details.

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

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

The description explains the meaning of key parameters: axis (with defaults), mode (LINE, GRID, CIRCLE), radius, and columns. However, it does not mention the 'objects' parameter or the 'spacing' parameter, which are present in the schema. It covers the most critical parameters but not all, so it adds meaningful context but leaves 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 clearly states the tool's purpose: distributing objects in LINE, GRID, or CIRCLE patterns. It specifies the behavior for each mode (equal spacing along axis, grid layout with columns, circular placement with radius) and mentions default axes. This distinguishes it from other transformation tools like set_transform or randomize_transform.

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

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

The description explains how the tool works but does not explicitly state when to use it instead of alternatives. It implies usage for arranging objects in specific patterns, but lacks guidance on contexts (e.g., selecting objects, prerequisites) or comparisons with sibling tools. Adequate 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?

With no annotations, the description must carry the burden of behavioral disclosure. It mentions that linked=true shares mesh data and offset is a position offset, but it doesn't explain what happens to other properties (modifiers, materials), whether the operation is reversible, or what the tool returns. This is minimal 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?

The description is a single, tightly packed sentence that front-loads the action and key options. It is concise and structured with semicolons, though it sacrifices detail for brevity. It earns its place for the info it provides.

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 lack of output schema and annotations, the description is incomplete. It doesn't state what the tool returns, how to reference the new object, or whether it copies modifiers/materials. For a duplication operation, this is insufficient for an agent to use it correctly.

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

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

Schema coverage is 0%, so the description must explain all parameters. It explains linked and offset, but not the required 'name' parameter or 'new_name'. It adds meaning for two parameters but leaves two undocumented, which is a significant 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 clear action, 'duplicate object', and briefly mentions linked and offset, which gives a hint of its scope. It distinguishes it from other object operations like delete_object or set_transform, though it doesn't explicitly name 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 provided on when to use this tool versus alternatives. It doesn't mention scenarios or conditions for using linked mode or offset. The description is purely descriptive, not prescriptive.

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 states that it executes arbitrary Python and returns stdout/return_var, but it does not disclose that execution can have arbitrary side effects on the Blender scene, that changes may be irreversible, or that it could be unsafe. A powerful tool like this needs explicit caution about side effects and potential for irreversible modifications.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and return behavior. It wastes no words and is easy to scan. However, it omits critical details that could be added without losing conciseness, such as a cautionary note or 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 tool that executes arbitrary code, the description is severely incomplete. It lacks error-handling behavior, examples of usage, implications for scene state, and safety warnings. With no output schema and no annotations, an agent has no guidance on how to construct valid code, interpret return values, or avoid unintended consequences. This is a high-complexity tool that demands much richer documentation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It explains 'return_var' as specifying the variable to retrieve, but it does not explain how the 'code' parameter should be formatted, whether it is a raw string, how to access preloaded modules, or what happens if the variable does not exist. The description provides minimal added meaning beyond the schema's 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 verb 'execute' and the resource 'arbitrary Python in Blender' with preloaded modules (bpy/bmesh/mathutils/Vector/math). It also mentions the return behavior, distinguishing it from sibling tools that perform specific operations. The purpose is unambiguous and unique among 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?

No guidance is given on when to use this tool versus the many specific sibling tools. It does not state that it should be used as a fallback for operations not covered by other tools, nor does it caution against using it when a specialized tool exists. The description leaves the usage context entirely to inference.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It mentions the object-omission behavior but omits any details about file creation, overwriting, side effects, or required permissions for a write operation.

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

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

The description is extremely short, but it is under-specified rather than effectively concise. The 'same format as above' reference is unhelpful without preceding 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 tool with 4 parameters, no annotations, and no output schema, this description is completely inadequate. It lacks essential details about format handling, path requirements, and export scope beyond the single objects hint.

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

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

Schema coverage is 0%, so the description must compensate for all parameters. It explains the 'objects' parameter's behavior but says nothing about 'path', 'format', or 'options', leaving those 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 verb+resource (export to file) but is vague about what is exported and the 'same format as above' reference is cryptic without context. It does not differentiate from sibling tools like export_for_game, save_blend, or save_image.

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

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

There is no guidance on when to use this tool versus alternatives. The only hint about omitting objects exporting everything is a parameter behavior, not a usage directive.

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 key behaviors: copying the object, applying modifiers, triangulating, scaling, and exporting while leaving the original untouched. However, it does not clarify whether the copy is temporary or persists, whether it affects scene state, or what happens after export (e.g., cleanup), so some side effects remain opaque.

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

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

The description is a single sentence that efficiently packs the entire workflow into a concise list of steps. It is not overly verbose and includes essential differentiators (original untouched, supported formats). Slight improvement could be made by adding a sentence on parameter usage, but as-is it is appropriately compact.

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 complexity of the operation (multiple steps, transformations, and export formats) and the lack of an output schema or parameter descriptions, the description is insufficient. It does not explain the meaning of 'up' and 'forward' axes, the default behavior of triangulate/apply_modifiers, or any side effects on the Blender scene. This leaves gaps that an agent would need to infer or test.

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

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

The schema has zero description coverage, and the tool description adds no explanation for any of the eight parameters. While names like 'objects', 'path', 'format', and 'scale' are self-explanatory, parameters such as 'up', 'forward', and the exact role of 'triangulate' and 'apply_modifiers' are not elaborated. The description fails to compensate for the missing schema-level documentation.

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 ('export') and resource ('game assets'), and outlines the exact processing pipeline (copy → apply modifiers → triangulate → scale → export). It also distinguishes itself by noting the original object is untouched, which differentiates it from generic export_file 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 explains what the tool does but provides no explicit guidance on when to use it versus alternatives like export_file or import_file. There is no mention of scenarios where this specialized pipeline is beneficial or necessary, leaving the agent to infer usage from the name and description alone.

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

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

The description implies a read-only operation by using 'find', but it does not explicitly state side effects or lack thereof. Without annotations, this leaves some ambiguity about whether it modifies data.

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, clear sentence that is appropriately brief for the tool's simplicity.

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

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

While the core function is clear, the description omits key context such as parameter explanations, expected output, and usage scenarios. This leaves the tool incomplete for effective 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?

The input schema defines 'object' and 'threshold' but the description does not explain their meaning or purpose. The threshold likely represents a weight cutoff but this is not stated.

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 function: to find vertices without bone weights. It identifies the specific action and resource. It is distinct from sibling tools that modify weights or check meshes.

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 on when to use this tool versus alternatives. It simply states the action without any contextual information about prerequisites or competing 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?

No annotations are provided, and the description only states the primary action. It does not disclose potential side effects, such as whether the camera transform is permanently modified, whether it affects other objects, or if it is reversible. This leaves behavioral details ambiguous.

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

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

The description is a single, concise sentence that front-loads the core action. It avoids unnecessary detail or repetition, making it easy to parse.

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 lack of parameter explanations and annotation coverage, the description is not fully complete. It does not specify return values, whether it operates on the active camera or the named camera, or any constraints (e.g., objects must be visible). This leaves gaps for an agent trying to invoke 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?

The input schema defines three parameters (camera, margin, objects) with no descriptions, and the tool description does not explain their meaning or expected format. The agent is left to guess what 'margin' represents, what kind of value 'objects' expects (list, string, object), and how these interact with the framing logic.

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: moving the camera backward along its current orientation to frame the specified objects and aim at them. It is distinct from sibling tools like point_camera_at and set_camera, which focus on positioning or aiming without framing logic.

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 point_camera_at or set_camera. It does not mention typical scenarios, prerequisites, or exclusion criteria, leaving the agent to infer its use from the action alone.

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

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

No annotations exist, so the description must bear the full transparency burden. It does not disclose whether the metarig is modified, if the operation is destructive, or any side effects, leaving the behavior opaque.

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

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

The description is a single, concise sentence with no unnecessary words or repetition. It is well-structured and immediately readable.

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

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

The description explains the core purpose but lacks context about the metarig's required state, the output format, or potential side effects. Given the complexity of Rigify rigs and the presence of many sibling tools, this is insufficient for a user to fully understand the tool's role.

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

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

The single parameter 'metarig' is a string with no schema description. The tool description does not clarify what the string represents (e.g., object name, path), leaving the parameter semantics ambiguous.

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 (generate) and the resource (Rigify control rig from a metarig), making the purpose unambiguous. It is specific enough to distinguish from related tools like add_rigify_metarig.

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 compared to alternative rig-related tools, nor does it mention any prerequisites or conditions for invocation.

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 explains the return contents (frame range, fps, actions, etc.) and the optional object's effect, but does not explicitly state that it is read-only or mention any side effects, permissions, or performance implications. The 'get' verb suggests read-only, but it is not explicit.

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, using a semicolon to separate the base behavior from the optional-object extension. The main purpose is front-loaded, and every part adds value without redundancy. It could be slightly more explicit about usage, but it is 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?

Since there is no output schema, the description lists the key return items (frame range, fps, action list, and per-object extras), which covers the essential information. It does not specify the exact structure or formatting, but for a getter tool this is adequate. The optional parameter's effect is also clarified.

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

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

The schema has only one parameter 'object' with no description, and schema description coverage is 0%. The description compensates by explaining that providing an object adds action, fcurve summary, NLA tracks, and shape keys to the result. This gives the parameter meaning beyond its type and default.

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

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

The description states a specific verb+resource: it retrieves animation info (frame range, fps, action list) and optionally object-specific details (action, fcurve summary, NLA tracks, shape keys). This clearly distinguishes it from siblings like get_scene_info or get_object_info, which cover different scopes.

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

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

The description implies usage for animation data but does not explicitly compare with alternatives or state when not to use it. It lacks exclusion conditions or references to sibling tools, leaving the agent to infer the context from the name and description alone.

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

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

The term 'query' implies read-only behavior with no side effects, but this is not explicit. Since no annotations are provided, the description carries the full burden and could be clearer about non-modification.

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

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

The description is extremely concise, with exactly two sentences that convey the core purpose and parameter usage without any redundant 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?

The description is complete for the tool's simple function: it states what it does and how to provide the input. No output schema is given, but that is acceptable for a documentation query 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?

The schema only defines 'path' as a required string with no description, but the description adds meaning by giving examples of acceptable paths. This helps the agent understand the parameter's purpose and format.

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

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

The description clearly states the tool queries bpy API documentation locally, using a specific verb ('query') and resource ('bpy API documentation'). It distinguishes itself from sibling tools which are all scene/object manipulation commands.

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 concrete examples of valid path formats (e.g., bpy.types.Object) which guide usage. However, it does not explicitly state when to use this tool versus alternatives, though siblings are unrelated to documentation.

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 not explicitly state that the tool is read-only, whether it makes network calls (e.g., to check Sketchfab token status), or what 'server status' means. The lack of clarity on side effects and network behavior is a significant gap.

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

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

The description is a single concise line listing the data items. It is efficient and front-loaded with the tool's name implied. However, it lacks a leading verb phrase like 'Gets' to clarify the action, though the list is still understandable.

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 tool is a simple getter with no parameters and no output schema. The description lists the data items but does not specify the return format (e.g., a JSON object with keys) or clarify ambiguous terms like 'server 状态'. It is adequate for a basic query but leaves some ambiguity about how results are delivered.

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, and the schema confirms this (100% coverage). With no parameters to describe, the description adds no parameter semantics, but the baseline for 0-parameter tools is 4, which is appropriate here since nothing is missing.

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

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

The description clearly enumerates the specific data items the tool retrieves (Blender version, Python, current file, enabled plugins, server status, Sketchfab token configuration), making its purpose unambiguous. This distinguishes it from sibling getters like get_scene_info and get_object_info, which target scene or object data rather than global Blender environment state.

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. It does not mention that this is for checking Blender environment status, nor does it contrast with similar query tools. Given the extensive sibling list, an agent would not know when to prefer this over other getters.

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

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

No annotations are provided, so the description carries the full burden. It discloses the query nature implicitly but does not explicitly state that it is a read-only operation, that it has no side effects, or how it behaves for invalid vertex indices or objects without vertex groups. It also does not describe the output structure despite having an output schema; the description itself adds no behavioral context beyond the basic purpose.

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

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

The description is a single, compact sentence with no filler. It front-loads the essential information (what the tool returns) and avoids redundancy. It is appropriately concise for a simple query tool, though this brevity comes at the cost of missing critical details captured in other dimensions.

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

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

The tool has an output schema, so return format is covered, but the description still lacks critical context: it does not explain the parameters, any prerequisites, or error behavior. With zero annotation coverage and zero parameter descriptions, a two-parameter query tool needs more than a single clause to be complete. The description is minimal and leaves the agent uncertain about how to construct valid calls.

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

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

Schema description coverage is 0%, so the description must explain the parameters. The description mentions '某顶点' (a vertex) but does not clarify that 'object' refers to a mesh object name or that 'vertex_index' is an integer index into that object's geometry. The parameter names are somewhat self-explanatory, but the description adds no additional context, leaving the agent to guess the exact requirements (e.g., object naming conventions, index base).

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 function: it reports which vertex groups/bones influence a given vertex and their weights. The verb '受...影响及权重' (which influence and weights) is specific, and it distinguishes from sibling tools like set_vertex_group_weights or normalize_weights. It names the resource (a vertex) and the information returned, leaving no ambiguity about its core purpose.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., that the object must be a mesh or have an armature modifier), and no exclusions. It does not mention that this is a read-only query for inspecting weights before editing, nor does it contrast with tools like find_unweighted_vertices. The agent must infer usage from the tool name and description alone.

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

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

No annotations are provided, and the description does not disclose whether this is a read-only operation, whether it modifies the scene, or any side effects. It is likely a query, but nothing in the description confirms this.

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 short and contains no redundant words, but it lacks structure and detail. It is not well-organized to convey the tool's purpose or usage effectively.

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 incomplete. It does not mention the output format, the behavior with multiple objects, the effect of the world parameter, or any error conditions. The tool's context is insufficient for an agent to use 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?

The schema defines 'world' and 'objects' with types, but the description gives no meaning to them. The 'objects' parameter accepts string, array, or object, which is confusing and unexplained. Without semantics, an agent cannot correctly construct the input.

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 '合并包围盒：min/max/center/size' is vague. It mentions merging bounding boxes but does not clarify whether it computes the combined bounding box of multiple objects or returns the components for a single object. The list of min/max/center/size suggests a query, but the verb 'merge' is ambiguous without context.

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

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

No guidance is provided on when to use this tool versus alternatives like measure_distance or other geometry queries. There is no mention of when the world parameter matters or how objects should be specified.

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