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

No annotations are provided, so the description must fully convey behavioral traits. It only states the action (adding cloth simulation) but does not disclose side effects, such as whether the mesh is modified in-place, whether previous cloth simulations are removed, or any permissions or destructive nature. This leaves significant uncertainty.

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

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

Description is very concise with two short sentences. No fluff, but could be slightly more structured by separating the parameter explanations. It earns its space.

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

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

Given no output schema and low schema coverage, the description should provide more context about the tool's behavior, prerequisites, and possible errors. It lacks information about what happens after adding cloth, any return value, or how to undo the operation. Incomplete for a simulation 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 add meaning. It explains that 'quality' controls simulation accuracy (1-10) and 'mass' is in kg, which adds useful context beyond the schema. However, the 'name' parameter is not explained, and the coverage is incomplete.

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 'Add cloth simulation to a mesh object', which is specific. However, it fails to differentiate from the sibling tool 'physics_add_cloth', which appears to perform a similar function. Without distinction, an AI may be uncertain which tool to use.

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

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

No guidance is provided on when to use this tool versus alternatives. Description does not mention prerequisites, such as whether the mesh object must be selected or if a specific mode is required. There is a sibling 'physics_add_cloth' that likely overlaps, creating ambiguity.

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

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

With no annotations, the description carries the full burden. It only mentions common types and that properties set attributes, but fails to disclose side effects, prerequisites, error handling, or limitations (e.g., what happens if target_name is invalid).

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 (3 sentences) and front-loaded with the purpose. However, the list of types could be better structured or referenced to an external resource. Information density is acceptable.

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

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

Given no output schema and no annotations, the description lacks completeness. It does not describe return values, error conditions, or behavior when constraints exceed limits. It is insufficient for an agent to fully understand the tool's capabilities.

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 'constraint_type' by listing common types, but does not explain 'name' (object name?), 'target_name', or 'properties' in detail. The mention of 'Properties dict' is vague.

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 'Add a constraint to an object' which is a specific verb+resource. It also lists common constraint types, making the purpose distinct from sibling tools like 'armature_add_constraint' which is armature-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?

The description provides no explicit guidance on when to use this tool versus alternatives such as 'armature_add_constraint' or 'remove_constraint'. It lacks when-not usage and alternative recommendations.

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 explains parameter-specific behavior like rotation controlling direction for SPOT/AREA and size for shadow softness, but does not disclose broader behavioral traits such as side effects, limits, or prerequisites. Since no annotations exist, the description carries the full burden, which it partially meets.

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 (three sentences), front-loaded with the primary action, and presents details in a structured list. 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?

Given 7 parameters, no output schema, and no annotations, the description is moderately complete. It covers key parameters but misses 'name' and 'location', and does not mention return values or prerequisites. Could be more thorough.

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

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

With 0% schema description coverage, the description must compensate. It explains type, energy, color, size, and rotation, but omits 'name' and 'location'. This adds value over the schema but is incomplete for all 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 tool adds a light to the scene and lists the light types. However, it does not differentiate itself from the sibling tool 'light_add', which likely performs a similar function, leaving ambiguity.

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 'light_add' or 'light_setup_studio'. The agent receives no context for selecting this tool over siblings.

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

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

With no annotations, the description fails to disclose important behavioral traits such as error handling, reversibility, or prerequisites. It only states the action and gives a properties example, leaving many aspects 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 concise with two sentences, front-loading the purpose and then providing a list of types and a properties example. It avoids unnecessary 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 complexity of 4 parameters, no output schema, and no annotations, the description is insufficient. It omits details on return values, parameter relationships, and edge cases, leaving the agent underinformed.

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 semantic value for the 'properties' parameter with an example and for 'modifier_type' by listing common values. However, it does not explain the 'name' and 'modifier_name' parameters, and the schema has 0% 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 'Add a modifier to an object' and lists common modifier types, making the tool's purpose specific. However, it does not differentiate from the sibling tool 'modifier_add', which appears to have similar functionality.

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 'modifier_add' or 'modifier_batch_add'. The description only implies usage by listing common modifier types but lacks explicit 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?

No annotations are provided, so the description must fully convey behavior. It explains parameters but omits side effects (e.g., whether it replaces existing particle systems), return values, or required object context.

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

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

The description is very concise, consisting of two sentences that front-load the purpose and then list key parameter meanings 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?

Given the complexity of particle systems and the lack of output schema or annotations, the description covers core functionality but omits details about object selection (implied by required 'name' parameter), scope, and potential constraints.

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

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

With 0% schema description coverage, the description adds meaning to parameters: explains type options (EMITTER, HAIR), count, lifetime, and velocity. However, it does not cover the 'size' parameter, leaving a gap.

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

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

The description clearly states the verb (add) and resource (particle system to an object), distinguishes from siblings like add_cloth or add_light by specifying particle-specific parameters and types.

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

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

The description provides context on parameter meanings but does not explicitly guide when to use this tool versus alternatives, such as the sibling 'physics_add_particle_system'. No exclusions or prerequisites are mentioned.

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

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

Discloses that ACTIVE is affected by gravity and PASSIVE is a static collider, and notes that MESH collision shape is exact but slow. This adds behavioral context beyond the input schema.

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

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

Two concise sentences that front-load the core purpose and then expand on key parameters. No unnecessary words.

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

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

The description covers type and collision_shape but omits details on mass, friction, restitution, and does not mention any return value or outcome. For a tool with 6 parameters and no output schema, this is insufficient.

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?

Adds meaning for 'type' and 'collision_shape' by listing valid values and their behavior, but does not explain 'mass', 'friction', 'restitution', or 'name'. With 0% schema coverage, more could be done.

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 'Add rigid body physics to an object' and provides details about types and collision shapes. However, it does not differentiate from the sibling tool 'physics_add_rigid_body'.

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 cloth or soft body physics. The description explains types and collision shapes but lacks context about prerequisites or when not to 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 must cover behavioral traits. It explains the axis and align_to options but does not disclose side effects (e.g., whether it modifies object origins, transforms, or requires specific modes). It offers minimal insight beyond the basic 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 concise, using two sentences with no wasted words. It front-loads the core action and then lists the options 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?

Despite the tool's simplicity, the description lacks information about what exactly gets aligned (position, rotation, scale?) and the result. With no output schema and no annotations, the description is adequate but not fully complete for a confident 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?

The schema has no parameter descriptions (0% coverage), so the description must add meaning. It explains the 'axis' and 'align_to' parameters with their options, but it does not explain the 'names' parameter (only that it is required). This partial coverage earns a mid 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 the tool's action ('Align multiple objects along an axis') and lists the axis and alignment options. It is specific and distinguishes it from similar tools like center_objects or distribute_objects, though it doesn't explicitly contrast them.

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

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

The description provides no guidance on when to use this tool vs alternatives, no prerequisites, and no context about when alignment is appropriate. It simply states what it does.

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 burden. It lists return values (statistics and issues) but does not disclose potential side effects, performance implications for large scenes, or scope limitations (e.g., hidden objects). The read-only nature is inferred but not stated.

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

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

The description is concise (two sentences) and front-loads the purpose. However, the list of returned items could be more structured (e.g., bullet points) but is still clear and efficient.

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

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

Given no output schema, the description adequately lists return values. However, it lacks details on scope (e.g., whether it considers hidden objects, modifiers, or only active collections) and does not mention performance considerations for complex scenes.

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

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

No input parameters exist, so the description cannot add parameter semantics. Baseline 4 applies as no additional param info is needed.

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

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

The description uses a specific verb ('Analyze') and resource ('the entire scene') and lists specific returned statistics (vertex counts, object types, issues). It clearly distinguishes from sibling tools like 'scene_stats' or 'mesh_quality_check' by offering comprehensive analysis.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., 'scene_stats', 'get_scene_info', 'mesh_quality_check'). The description implies comprehensive analysis but does not state when simpler tools are sufficient or when this is preferred.

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 mentions the bouncing effect but does not state whether it modifies existing animation, creates keyframes, or is reversible. The term 'preset' is ambiguous about actual 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 concise and front-loaded with the main purpose. The Args list is clear and well-structured. No redundant information, though slight improvement could be made by integrating args description more directly.

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, the description adequately covers the main functionality and parameter meanings. However, it lacks information about prerequisites (e.g., object must exist) and the exact nature of the 'preset' created.

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 provides brief but clear explanations for all 4 parameters (e.g., 'height: Initial bounce height'), adding value beyond schema titles. However, the explanations could be more detail-rich.

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 bouncing animation preset with specific behavior (decreasing amplitude). This distinguishes it from siblings like anim_orbit or anim_set_interpolation, which serve different purposes.

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 vs alternatives. There are many animation-related tools among siblings, but the description does not offer any context about when bouncing is appropriate or what prerequisites exist.

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?

Although no annotations are provided, the description lacks detail about the operation's irreversibility, effects on other object data, or required permissions. For a destructive operation, more transparency is needed.

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

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

The description is a single concise sentence, appropriately brief. It is well-structured and front-loaded with the verb. However, it could be slightly expanded with usage context without losing 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 no output schema and no annotations, the description fails to cover basic behavioral information such as whether the operation can be undone or if it affects animations on child objects. Minimal completeness for a simple 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 description does not explain the 'object_name' parameter beyond its name. With 0% schema description coverage, the description adds no semantic meaning, making it hard for the agent to know what value to provide.

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

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

The description uses a specific verb 'Remove' with the resource 'all animation data' from an object, clearly distinguishing it from sibling tools like 'anim_delete_keyframe' which targets specific frames.

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 'anim_delete_keyframe' or 'clear_animation'. No prerequisites or context 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 full burden but only states 'Delete a keyframe' without disclosing side effects, prerequisites (e.g., existence of keyframe), or failure modes, making it insufficient for a destructive operation.

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

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

The description is extremely concise with a single main sentence and a parameter list, front-loading the action and containing no 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?

Despite having 4 parameters and no annotations or output schema, the description omits return behavior, error conditions, and how to format parameters like data_path. It does not leverage sibling context to differentiate from similar tools, leaving gaps for reliable agent usage.

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 parameter names with brief explanations (e.g., 'Target object name', 'Frame number to delete'), adding some meaning beyond the schema's bare types and names. However, given 0% schema coverage, more detailed semantics (e.g., data_path format) would improve clarity.

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 from an object property' with a specific verb and resource, effectively distinguishing it from sibling tools like anim_insert_keyframe and anim_clear_all.

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 anim_clear_all or anim_insert_keyframe, leaving the agent without context for proper selection.

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

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

No annotations provided, and description does not disclose whether the operation is read-only, what happens on missing animation data, or potential 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?

Concise at two sentences plus parameter info, front-loaded with purpose, but parameter explanation could be more structured.

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 low complexity and no output schema, description covers purpose and parameter but lacks return value information and error handling 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 parameter description adds meaning beyond the schema by explaining that empty object_name yields a scene-wide summary, which is not in the schema.

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

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

The description clearly states it retrieves animation info (keyframe counts, frame range, actions) and distinguishes itself from siblings which are mostly modification 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, but the purpose is clear enough for a read-only info tool among many anim-modifying 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?

No annotations provided, so the description carries full burden. It does not disclose behavioral traits such as permissions required, side effects (e.g., overwriting existing keyframes), or error conditions.

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

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

The description is compact, front-loaded with the main action, and uses a clear docstring format. No 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?

Given the tool's complexity (5 parameters, no output schema, no annotations), the description is insufficient. It lacks usage examples, error handling, return value information, and edge case behavior.

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

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

All 5 parameters are briefly described in the docstring, adding meaning beyond the schema (e.g., 'Channel index (-1 = all channels, 0=X, 1=Y, 2=Z)'). However, the 'value' parameter is only described as 'Optional value to set before keying' without further detail.

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 'Insert a keyframe on an object property' and lists specific parameters. It distinguishes itself from siblings like anim_delete_keyframe and anim_insert_keyframes_batch by specifying the action on a single keyframe.

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 (e.g., anim_insert_keyframes_batch) or any prerequisites. The description lacks context about appropriate use cases.

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

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

No annotations provided, so description must cover behavioral traits. Fails to disclose error handling, overwrite behavior, channel indexing details, or side effects beyond structure of keyframes.

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

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

Description is well-structured with purpose first, then argument details, then example. Each sentence adds value, no redundancy or fluff.

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?

Missing behavioral details like return values, error conditions, and confirmation of insertion. Given complexity and lack of output schema, description is incomplete for an agent to fully predict behavior.

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

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

Schema coverage is 0%, so description fully defines parameters: 'object_name' as target, 'keyframes' as list of dicts with required fields and optional index. Example demonstrates structure and usage, adding essential 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?

Description clearly states 'Insert multiple keyframes at once', specifying verb and resource. Differentiates from sibling 'anim_insert_keyframe' which handles single keyframe insertion.

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

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

No explicit guidance on when to use this tool vs alternatives like 'anim_insert_keyframe'. Does not provide when-not scenarios or 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?

Without annotations, the description carries full burden for behavioral disclosure. It states the tool 'creates' an animation but does not explain side effects (e.g., whether existing animation is overwritten, if keyframes are added, or if object must be selected). No details on error conditions or post-conditions.

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

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

The description is concise: one sentence followed by a clean argument list. No redundant text. Every line adds value. Ideal structure for quick comprehension.

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

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

The tool has no output schema and 5 parameters. The description adequately covers the parameters and basic purpose but lacks details on return value, error handling, or post-condition effects. For a simple animation tool, this is minimally adequate 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?

Schema coverage is 0%, so the description compensates by listing all 5 parameters with brief explanations. For example, 'center: Center point [x, y, z]' and 'frames: Frames for one complete orbit' add meaning beyond the schema. However, some details are missing (e.g., default center behavior).

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

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

The description clearly states the tool's purpose: 'Create an orbital/circular motion animation.' It uses a specific verb ('Create') and resource ('orbital/circular motion animation'), distinguishing it from siblings like anim_bounce (bounce animation) and other animation tools.

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

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

No guidance on when to use this tool versus alternatives (e.g., anim_bounce, keyframe tools). No when-not or prerequisite information provided. The agent must infer usage solely from the name and 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?

No annotations exist, so description must fully cover behavior. It only states the action without mentioning side effects, safety, or constraints (e.g., what happens if start > end, whether existing keyframes are cleared, or if FPS change affects playback). Minimal 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?

Very concise: one-line summary plus arg list. No wasted words. However, a bit more structure (e.g., clarifying defaults and behavior) could be added without much bloat.

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

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

Despite having only 3 simple parameters and no output schema, the description lacks important context like return value, error handling, and relation to animation pipeline. Incomplete for a tool that modifies scene state.

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 no descriptions (0% coverage). The description adds brief meaning: start and end are frame numbers, fps with 0 meaning 'don't change'. This is helpful but still leaves ambiguity (e.g., valid ranges, order validation). Adequate but not comprehensive.

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

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

The verb 'set' and resource 'scene frame range and optionally FPS' clearly describes the tool's function. It is distinct from siblings like set_frame (current frame) and set_animation_range (possibly similar but not differentiated). The name indicates it belongs to animation tools, so purpose is clear.

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

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

No guidance on when to use this tool versus alternatives. For example, it does not explain why one would use this instead of set_animation_range or other animation tools. Lacks when-to-use and when-not-to-use 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?

No annotations provided; description does not disclose behavioral traits beyond purpose. E.g., no mention of whether changes are permanent, if they affect all animation tracks, or if undo is supported.

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

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

Description is concise (two sentences plus Args list) and front-loaded with purpose. No wasted text, but could be slightly more structured for readability.

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

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

Given animation context, description lacks completeness. No mention of return values, prerequisites, or examples. Agent may not know when animation data exists or how the tool handles errors.

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 0%; description lists parameters with examples (interpolation types, easing) but provides only minimal explanation. Adds some meaning beyond schema but insufficient to fully understand each parameter's effect.

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 'Set interpolation type for all keyframes on an object' with a specific verb and resource. Distinguishes from sibling animation tools like anim_insert_keyframe or anim_bounce.

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

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

No explicit guidance on when to use this tool vs alternatives. Does not mention prerequisites (e.g., object must have keyframes) or scenarios where another tool would be better.

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 that the effect is permanent and modifies geometry, implying irreversibility. However, with no annotations, it misses details like undo behavior or required permissions. Basic transparency, not comprehensive.

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

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

The description is a single sentence with 11 words, very concise. It front-loads the core action. However, it sacrifices necessary details for brevity in the context of missing annotations.

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 annotations, output schema, and parameter descriptions, the description is too minimal to fully inform the agent. It covers the action but omits parameter semantics and usage context, leaving significant gaps.

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

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

No parameter descriptions are provided in the schema (0% coverage) and the description does not explain what 'name' or 'modifier_name' refer to. The agent must infer meanings from context, which is insufficient.

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 (apply a modifier) and the effect (permanently bake into mesh geometry). It distinguishes from adding a modifier, but does not differentiate from the sibling tool 'modifier_apply', which likely has similar 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?

No guidance on when to use this tool versus alternatives like 'modifier_apply' or 'modifier_apply_all'. The description does not mention prerequisites or context for use.

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

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

With no annotations provided, the description carries the full burden. It states the transform reset action but does not disclose potential side effects (e.g., whether it is destructive or reversible), required permissions, or behavior on locked/protected objects. The description is adequate but lacks depth.

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

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

The description is extremely concise: two sentences with no fluff. The first sentence defines the action, the second provides context. Every word adds value, making it easy to parse quickly.

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

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

Given the tool's simplicity (4 params, only 1 required), the description covers the purpose and usage context. However, it falls short by not addressing parameter meanings or behavioral edge cases (e.g., what if the object has constraints?). Completeness is adequate but not thorough.

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 mentions nothing about the 'name' parameter or the boolean flags (scale, location, rotation). The agent is left to infer from parameter names and defaults, which is insufficient for correct invocation.

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

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

The description clearly states the tool's action: 'Apply (freeze) the object's transforms, resetting them to identity.' It distinguishes from sibling tools like 'apply_modifier' by specifying it operates on transforms, not modifiers. The context of when it's essential (before export, after non-uniform scaling) further clarifies its unique role.

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 explicit use cases: 'Essential before export or after non-uniform scaling.' This guides the agent on appropriate contexts. However, it does not specify when not to use the tool or mention alternative tools, which would be helpful for differentiation.

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 fully disclose behavioral traits. It only describes parameters, omitting side effects (e.g., irreversible modification, selection changes), permissions, mode requirements, or return behavior. This is insufficient for a mutation tool.

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

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

The description is concise with a clear, structured list of parameters. It front-loads the purpose and uses a single sentence per parameter. Every sentence adds value.

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

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

Given the simplicity of the tool (adding a bone), the description covers basic usage and parameters. However, it lacks details on return values, error handling, or prerequisites (e.g., armature in edit mode). Without output schema, these gaps are noticeable but not critical.

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 meaning beyond the input schema by explaining each parameter's purpose (e.g., head/tail positions, parent_bone, connected). Schema coverage is 0%, so the burden is fully on the description. It partially compensates but could specify formats (e.g., head/tail as [x,y,z] floats).

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 specific action 'Add a bone to an existing armature.' The verb 'add' and resource 'bone' are precise. This distinguishes it from sibling tools like 'armature_create' (creating a new armature) and 'armature_add_bones_chain' (adding a chain of bones).

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 'armature_add_bones_chain' or 'armature_create'. It lacks explicit when-to-use/when-not-to-use context, prerequisites like requiring edit mode, or error conditions.

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

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

No annotations are provided, so the description must fully disclose behavior. It notes the requirement for at least 2 joints to form 1 bone, but does not explain side effects (e.g., where bones are added relative to existing bones), permissions, or error handling. The description lacks depth on mutability and safety.

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

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

The description is concise with a single introductory line and a clear Args list. No unnecessary words. Each sentence is informative and earns its place.

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

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

For a tool with 4 parameters and no output schema, the description covers parameter usage but lacks details on prerequisites (e.g., armature must exist), return behavior, or error cases. It is adequate but not exhaustive.

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

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

Schema description coverage is 0%, so the description must add meaning. It explains each parameter: armature_name (target), chain_name (base name with .001 suffix), joints (list of positions, minimum 2 points), parent_bone (parent for first bone). This adds significant context beyond the raw schema.

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

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

The description clearly states the tool adds a chain of connected bones, with examples like spine, arm, finger. It distinguishes from siblings such as armature_add_bone (single bone) and armature_create (create armature). The verb 'add' and noun 'chain of connected bones' 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?

The description provides examples of when to use (spine, arm, finger) but does not explicitly state when not to use or name alternatives (e.g., armature_add_bone for single bones). Usage is implied but no exclusions or comparative 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, and the description only states the action without disclosing behavioral traits like whether constraints are appended or replaced, required armature mode (e.g., pose mode), or error conditions.

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

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

The description is a compact list of arguments, each line conveying essential information. It is well-structured and concise, though slightly verbose with Python-style args formatting.

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 6 parameters, 3 required, no output schema, and no annotations, the description lacks return value info, success/failure signals, and prerequisites (e.g., armature must be in pose mode). It is incomplete for safe 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?

Despite 0% schema description coverage, the description lists parameters with types and explains constraint_type options (e.g., COPY_LOCATION), target armature/bone usage, and the params dict. This adds significant meaning 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 'Add a constraint to a pose bone,' which is a specific verb and resource. It clearly distinguishes from sibling tools like 'add_cloth' or 'add_modifier' by targeting pose bone constraints.

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 provide any guidance on when to use this tool versus alternatives (e.g., 'add_constraint', 'remove_constraint'), nor does it specify prerequisites or restrictions.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states the core action but fails to mention side effects (e.g., whether existing vertex groups are cleared), prerequisites (e.g., armature must have bones), or failure conditions. The agent is left uncertain about the tool's operational context.

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

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

The description is exceptionally concise: two succinct sentences plus a parameter list. Every word earns its place, with the key action front-loaded. No filler or redundancy.

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

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

Given no output schema, no annotations, and two simple params, the description covers the basic purpose but lacks essential behavioral details like error handling, state changes, or prerequisites. It is minimally viable but leaves gaps for a tool with this 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 schema has 0% description coverage (no parameter descriptions in the schema itself), so the description must compensate. It adds relational context: 'Armature to parent to' and 'Mesh to skin' clarify the direction of parenting beyond the schema titles 'Armature Name' and 'Mesh Name'. This reduces ambiguity for the agent.

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

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

The description clearly states the action ('Parent mesh to armature with automatic weights') and identifies it as the standard skinning method. This distinguishes it from sibling tools like armature_add_bone or vrc_auto_weight by specifying the automatic weighting approach.

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

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

The description says 'This is the standard way to skin a mesh to a skeleton,' which implies use for automatic weight skinning. However, it does not mention when to avoid this tool or suggest alternatives (e.g., manual weight painting, other armature parenting methods). Guidance is implicit 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 disclose behavior. It only states what is created ('single root bone') but not side effects (e.g., selection, active object), state requirements, or whether it operates in object mode. This leaves transparency gaps.

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

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

The description is short (three sentences) and front-loaded with the core purpose. The parameter listing is efficient, though it slightly overlaps with schema information. 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?

Given no output schema and no annotations, the description could be more complete. It lacks information about return value (e.g., created object name), error cases, or relation to sibling tool create_armature. Adequate for a simple creation tool but not 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 adds meaning beyond the schema: it clarifies that location is a 3-element [x, y, z] array. Schema coverage is 0%, so the description carries the full burden. While it doesn't detail defaults or optionality, it provides essential format info, making it helpful.

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 (create) and resource (armature object with a single root bone). It distinguishes from sibling tools like armature_add_bone and armature_add_bones_chain which operate on existing armatures. The specification of 'single root bone' adds precision.

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, context (e.g., object mode required), or when not to use it. Given many sibling tools like create_armature and armature_add_bone, explicit differentiation is needed.

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

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

No annotations are provided, so the description carries full burden. It indicates it is a read operation ('List') and includes 'hierarchy info', but does not explicitly state it is non-destructive or describe side effects. For a simple query tool, this is adequate but not complete.

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

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

The description is a single sentence that conveys the essential information with no wasted words. It is front-loaded and efficient.

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

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

For a simple listing tool with no output schema, the description provides core behavior but lacks details on return format (e.g., list of names, tree structure). It is minimally complete but could be more precise.

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 no parameter descriptions in schema. The tool description does not elaborate on the only parameter, 'armature_name' (e.g., how to specify it, validation). This leaves agents without guidance on parameter usage.

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 'List' and the resource 'bones in an armature', and specifies that it provides 'hierarchy info'. This distinguishes it from sibling tools like armature_add_bone or armature_set_pose.

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

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

No explicit guidance on when to use this tool vs alternatives, such as armature_set_pose or armature_add_bone. However, the name and description imply it is for querying bone structure, so usage is somewhat implied.

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

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

No annotations are provided, so the description carries full burden. It discloses rotation units (degrees) and provides an example, but does not indicate whether poses are added or overwritten, if armature must be in pose mode, or any side effects. This leaves significant behavioral gaps.

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

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

The description is concise, using one sentence and a brief args section. It is front-loaded with the verb. However, the args section uses a docstring format that could be slightly streamlined, but overall 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?

Given no output schema and no annotations, the description covers the main purpose and parameter format, but lacks return value description, error handling, and prerequisites (e.g., armature must exist). It is adequate but not fully complete.

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

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

Schema coverage is 0%, but the description adds substantial meaning: it documents the structure of bone_poses as a list of dicts with 'bone', 'rotation', 'location', and includes an example. It compensates well for the schema's lack of parameter descriptions.

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

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

The description clearly states the tool sets bone poses (rotation/location) on an armature, using specific verbs and resources. It distinguishes well from siblings like armature_add_bone or armature_list_bones.

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 posing bones, but lacks explicit guidance on when to use this tool versus alternatives (e.g., when to use armature_add_bone vs this). No when-not-to-use or prerequisite information is provided.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention whether the tool is destructive, requires UVs, or side effects like overwriting files. The term 'simplified' is vague without concrete behavior 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 with two sentences plus a parameter list, all front-loaded with the main purpose. Every sentence adds value with no waste.

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

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

Despite conciseness, the description lacks essential context: prerequisites (e.g., UV unwrapping), output details (file format, location), and whether the tool is safe to re-run. For a baking tool, this information is crucial for correct invocation.

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

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

Schema description coverage is 0%, but the description provides brief explanations for all 4 parameters, adding meaning beyond defaults and types. For example, 'samples: Render samples (higher = cleaner)' clarifies the parameter's effect, and output_path behavior is noted.

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 bakes an ambient occlusion map for a mesh, using specific verb and resource. It distinguishes from sibling tools like bake_normal_map or bake_textures by specifying 'ambient occlusion' and 'simplified single-map bake.'

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

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

The description does not explicitly state when to use this tool versus alternatives like bake_normal_map. The phrase 'simplified single-map bake' implies a simpler workflow but lacks clear guidance on prerequisites or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It mentions combining materials and repacking UVs, but does not disclose whether the operation is destructive, if it modifies original materials, or what output is generated (e.g., saved file, added nodes).

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

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

The description is concise, with a clear main sentence and parameter explanations in a structured Args list. No 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?

Despite having 3 parameters and no output schema, the description does not specify the output format, how the atlas is saved, or potential side effects. It also does not differentiate from similar sibling tools like vrc_bake_atlas in this 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 Args section adds meaning beyond the schema: mesh_names is described as a JSON array, atlas_size as resolution, output_path as custom path. With 0% schema description coverage, this provides necessary context, though descriptions are brief.

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 specific action: baking multiple meshes' diffuse colors to a single texture atlas, and mentions combining materials and repacking UVs. This distinguishes it from other baking tools like bake_ao or bake_normal_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?

No explicit guidance on when to use this tool versus alternatives such as bake_textures or vrc_bake_atlas. The description implies it's for combining diffuse colors of multiple meshes, but lacks when-not-to-use or alternative references.

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

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

No annotations provided, so description carries full burden. It explains each parameter and hints at output_path auto-generation, but does not disclose side effects (e.g., file creation, overwriting) or requirements like UV maps.

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

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

Concise one-paragraph description with bullet-style parameter list. Front-loaded purpose, no wasted words, each sentence adds value.

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

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

Covers all parameters with usage hints, but lacks information about output (format, location), error cases, or prerequisites (UV maps, mesh topology). For a tool with 6 parameters and no output schema, more details are needed for completeness.

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

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

Schema has 0% description coverage, so description compensates by explaining each parameter: high_poly, low_poly, resolution (with recommendation), cage_extrusion (with gap hint), samples, output_path. Adds meaningful context beyond names/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?

Description clearly states 'Bake a normal map from high-poly to low-poly mesh', specifying verb, resource, and process, distinguishing it from sibling bake tools like bake_ao or bake_textures.

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 other bake tools (e.g., bake_ao, bake_textures). The purpose is implied, but with multiple sibling bake tools, more explicit context is needed.

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

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

No annotations are provided, so the description must carry the full burden. It mentions 'bake to cache' but does not explain behavioral implications like whether it is destructive, requires pre-setup, or modifies existing simulations.

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 at two sentences, with no wasted words. While it could include more detail, it is efficiently front-loaded with essential purpose and 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?

Given no output schema, minimal description, and no parameter explanation, the tool definition is incomplete for an agent to use effectively. Important aspects like parameter ranges and behavior are missing.

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

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

The description provides no information about the two parameters (start and end) from the input schema. With 0% schema description coverage, the agent gains no additional meaning beyond the schema defaults.

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 bakes all physics simulations to cache, with a specific verb 'bake' and resource 'physics simulations'. However, it does not differentiate from sibling tools like 'physics_bake' which may have overlapping functionality.

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 includes a usage hint ('Must be baked before rendering physics simulations'), indicating when to use the tool. Yet it lacks explicit guidance on when not to use or clear alternatives.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention whether the tool is destructive, requires specific permissions, or affects the scene beyond creating files. The behavioral implications are unclear.

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 reasonably concise with a summary and Args list, but the Args section largely duplicates the schema's parameter names and defaults, making it somewhat redundant. Could be more streamlined.

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 (7 parameters, no output schema), the description covers the main purpose and parameter details but misses high-level behavior like output format, potential side effects, or prerequisites. Moderately complete but with gaps.

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

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

Schema coverage is 0%, but the description adds meaning for parameters like 'bake_types' (JSON array), 'output_dir' (Blender path format), and 'high_poly' (optional high-poly mesh). However, it does not explain defaults or valid ranges for enums.

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 'Bake texture maps from a mesh (or high-poly to low-poly)', specifying the action (bake) and resource (mesh), and differentiates from more specific sibling tools like 'bake_ao' or 'bake_normal_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?

No guidance on when to use this general baking tool versus specific alternatives (e.g., bake_ao, bake_normal_map). The description lacks exclusions or context for selection.

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

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

No annotations provided, so the description carries the transparency burden. It discloses that using color creates a new material, but does not explain side effects like overwriting existing materials or what happens if material_name is invalid. The information is moderately helpful but incomplete.

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

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

Two sentences, no filler, front-loaded with the primary action. Every word adds value.

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

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

The description is adequate for a simple batch operation but lacks context on error handling, return values, and differentiation from sibling tools like material_assign. Given the presence of many sibling tools, more contextual guidance would be beneficial.

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 meaning of 'color' (new material with RGB) and 'material_name' (use existing), but does not describe the 'names' parameter (the objects). This leaves some ambiguity.

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 'Assign', the resource 'material', and the scope 'to multiple objects at once'. It also distinguishes two modes (color for new, material_name for existing), which is specific and actionable.

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 when to use color versus material_name, which is helpful. However, it lacks explicit guidance on when not to use this tool (e.g., for single object or per-object material assignment) and does not name alternative tools like material_assign.

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 bears full responsibility for behavioral disclosure. It only states a delete operation, which implies destructiveness, but fails to mention any side effects, error handling, or permissions needed. The description adds little beyond the obvious.

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. It efficiently conveys the core function.

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

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

For a simple parameter set, the description is minimally adequate but incomplete. It does not mention return values (no output schema), error handling, or whether the operation is reversible. The agent may need to infer behavior from the name.

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 sole parameter 'names' is an array of strings. Schema description coverage is 0%, so the description must compensate. However, it merely says 'by their names', which is already evident from the parameter name. It does not clarify expected format, object types, or behavior for invalid names.

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

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

The description 'Delete multiple objects at once by their names' clearly states the action (delete), resource (objects), and scope (multiple at once, by names). It distinguishes from the sibling 'delete_object' which likely handles single deletion, though it does not explicitly contrast with it.

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 'delete_object' or other removal tools. There is no mention of prerequisites, context, or when not to use batch deletion.

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

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

No annotations are provided, so the description must disclose behavior. It explains the vector format for translate, rotate, scale and the relative flag. However, it does not specify whether transforms are applied absolutely or additively (beyond the relative flag), whether the operation is destructive, or what result to expect (e.g., modifies objects in place).

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

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

The description is three sentences, front-loaded with the primary purpose. Every sentence provides necessary information without redundancy or fluff.

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 a batch transform operation with multiple parameters and no output schema, the description covers the essential functionality but lacks details on error handling, return values, prerequisites, or behavior when parameters are omitted.

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 add meaning. It describes the format of transform vectors and the relative flag, which adds some value. However, it does not explain the 'names' parameter (required) or provide further details on defaults or constraints.

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 specifies 'Apply the same transform to multiple objects at once,' which clearly indicates the verb (apply), resource (transform), and scope (multiple objects). This distinguishes it from single-object transform tools like rotate_object or scale_object.

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 implicitly suggests use when applying identical transforms to multiple objects, but does not explicitly state when not to use it (e.g., for different transforms) or mention alternatives. Sibling tools include single-object transforms, so the context is clear.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states it bevels all edges but does not mention whether it is destructive, modifies the mesh in place, or requires a specific selection mode. The impact on mesh geometry is implied but not detailed.

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

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

The description consists of two clear, concise sentences with no fluff. It front-loads the main action ('Bevel all edges of a mesh') and then describes the parameters efficiently.

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

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

Given the complexity of mesh operations and lack of output schema/annotations, the description is incomplete. It does not explain return values, preconditions (e.g., object must be a mesh), or postconditions. More context is needed for safe 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%, so the description must add meaning. It explains that 'width controls bevel size' and 'segments controls smoothness', which adds value. However, the required 'name' parameter is not 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 bevels all edges of a mesh, with specific parameters (width, segments) for control. It uses a specific verb and resource, distinguishing it from sibling tools like 'add_modifier' or 'bridge_edge_loops'.

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 beveling mesh edges but provides no explicit guidance on when to use this tool versus other bevel methods (e.g., modifier) or prerequisites. No exclusion or alternative tools are mentioned.

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

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

With no annotations provided, the description carries the full burden. It discloses that the addon is automatically installed, enabled, and the TCP server started, with connection verified before returning. This provides good behavioral context.

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

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

The description is concise and well-structured: main purpose in the first line, then parameter details, then additional setup steps. Every sentence adds value with no redundancy.

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

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

The description covers launch behavior, parameter roles, and verification step. While no output schema is provided in the input, the description hints at return behavior. For a launch tool with many siblings, it is sufficiently complete.

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

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

The input schema has 0% description coverage, meaning the schema provides no parameter descriptions. The tool description compensates by explaining each parameter: file_path (.blend file), port (default 9876), blender_path (override). This adds significant value beyond the schema.

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

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

The description clearly states the tool launches Blender with Copilot addon auto-started, using specific verbs and resources. It distinguishes itself from sibling tools like blender_new_file or blender_open_file by focusing on launching the application itself.

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 launching Blender but does not explicitly state when to use this tool versus alternatives like blender_new_file or blender_quit. There is no guidance on prerequisites or when not to use it.

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

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

With no annotations provided, the description carries the full burden. It discloses a critical behavioral trait: 'Discards unsaved changes'. This informs the agent of destructive behavior. Could be enhanced by explaining if the current file is auto-saved or closed, but sufficient for a simple 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?

Two short sentences, directly stating purpose and critical side effect. No fluff. Front-loaded with the action.

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

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

For a tool with no parameters and no output schema, the description covers the essential purpose and behavioral consequence. It is complete for the agent to understand what it does.

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

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

No parameters exist, so schema coverage is 100%. The description adds no parameter info, which is appropriate. Baseline for zero parameters is 4.

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

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

The description uses a specific verb ('Create') and resource ('new blank Blender file'). It clearly distinguishes from siblings like blender_open_file (which opens existing files) and blender_save (which saves current file).

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

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

The description implies usage when starting fresh, but does not explicitly contrast with alternatives like blender_open_file or blender_save. It mentions discarding unsaved changes, which is a caution, but no explicit 'when to use' vs. 'when not to use' guidance.

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

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

With no annotations, the description discloses the key behavioral trait: it replaces the current scene. Also specifies 'in the running Blender instance', adding context beyond the 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?

Two sentences, front-loaded with action and key warning. No unnecessary words.

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

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

Adequate for a simple tool with one parameter and no output schema. Covers the core behavior and side effect. Could mention that the Blender instance must already be running, but that is implied by 'in the running Blender instance'.

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% (no description in schema), yet the description adds no meaning to the file_path parameter. Does not specify expected format, path type, or restrictions.

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

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

Clearly states the tool opens a .blend file. Distinguishes from siblings like blender_new_file and io_import_file by noting it replaces the current scene.

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

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

Provides explicit guidance: 'save first if needed' because it replaces the scene. Does not mention when to use alternatives, but context is clear enough.

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

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

No annotations are provided, so the description bears the full burden. It discloses the key behavioral trait: quitting with optional save. It explains that setting save=True saves before quitting, implying that save=False quits without saving. It does not elaborate on graceful behavior, but the description is sufficient for this simple tool.

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

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

The description is exceptionally concise: one sentence that immediately states the action and the key parameter usage. Every word earns its place, and there is zero waste. It is front-loaded with the primary purpose.

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

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

Given the tool's simplicity (one parameter, no required fields, no nested objects), the description covers the essential information: what it does and how to use the parameter. It does not mention return values, but since an output schema exists, that is acceptable. It is slightly lacking in mentioning prerequisites or consequences of unclean shutdown, but for a quit tool, the description is adequate.

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 boolean parameter 'save' with default false and no description (0% coverage). The description adds critical meaning: 'Set save=True to save before quitting.' This clearly explains the parameter's effect, adding value beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Quit Blender gracefully.' It uses a specific verb ('Quit') and resource ('Blender'), which distinguishes it from sibling tools like blender_launch, blender_save, and blender_new_file.

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

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

The description provides a usage guideline: 'Set save=True to save before quitting.' This tells the agent when to use the parameter. However, it does not explicitly state when to use this tool versus alternatives (e.g., using system commands) or when not to use it. Since the tool is simple, the implicit usage context is clear enough.

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

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

Discloses error when file never saved and no path. However, does not mention overwriting behavior on success, nor confirmation or side effects. 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?

Two succinct sentences that convey essential information without redundancy 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?

Covers key scenarios: save and save-as. Lacks detail on return value or explicit behavior for normal save (overwrite). But adequate for a simple 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?

Adds meaning to the single parameter file_path by explaining its effect (Save As vs normal save). Compensates for 0% schema description 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?

Clearly states the action: 'Save the current Blender file'. Distinguishes between save and save-as modes, and mentions error case. Distinct from siblings like blender_open_file.

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?

Explains two usage scenarios (with file_path for Save As, without for normal save) and error case. Implicitly guides when to use, but no explicit 'when not to use' or alternative tool references.

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

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

No annotations are provided, so the description carries full burden. It describes a read-only operation but does not disclose behavioral traits such as whether Blender must be running, latency of connection check, or side effects (none expected). The description is insufficiently transparent for a tool with no 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 sentence, front-loaded with the main action. It is concise with no extraneous text. However, it lacks any structural elements like bullet points or additional sentences that might improve clarity for the parameter.

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

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

Given the simplicity of the tool and the presence of an output schema, the description is adequate in scope but lacking in detail. It mentions three pieces of info (connection status, path, scene summary) but does not differentiate from similar tools like get_scene_info or scene_stats. The output schema likely covers return values, so completeness is moderate.

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

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

Schema description coverage is 0%, and the description does not mention the port parameter at all. The agent is not told what the port is for (e.g., Blender server port). The description adds zero meaning beyond the schema for this parameter, which is unacceptable given the low 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 verb 'Check' and the resources 'Blender connection status, executable path, and scene summary'. It is specific and distinguishes from sibling tools like get_scene_info by focusing on connection and executable path.

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 state prerequisites (e.g., Blender must be launched) nor exclusions. The implied usage is checking before other operations, but this is not explicit.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions 'precision' and 'without operator overhead' but omits important details: whether the tool modifies the mesh in-place, error conditions (e.g., if mesh_name doesn't exist), permission/context requirements, or side effects. The operation descriptions partially cover behavior (e.g., remove_doubles merges vertices) but are insufficient for a mutation tool.

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

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

The description is well-structured with a clear introduction, then a bulleted list of operations. The listing is necessary due to the many variants, but it is somewhat long. It front-loads the main purpose. Minor redundancy: 'quads_to_tris — same as triangulate' could be omitted or merged. Overall efficient for the 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 the tool's complexity (16+ operations) and the presence of an output schema (reducing need to describe returns), the description covers most required aspects: parameters, operations, and their effects. It lacks prerequisites (e.g., mesh must exist, object selection) and error handling, but overall is sufficiently complete for an experienced user.

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 0% description coverage, making the description the sole source of parameter meaning. The description provides detailed explanations for the 'operation' parameter (list of enums with effects and optional params) and specifies the format for 'params' (JSON). mesh_name is self-explanatory. This adds substantial value beyond the schema.

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

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

Purpose is clearly stated: 'Execute precision BMesh operations on a mesh'. It specifies the verb (execute), resource (mesh), and context (BMesh direct manipulation without operator overhead). The distinct nature of low-level mesh editing is implicit, distinguishing it from sibling tools like boolean_operation or bevel_edges which are higher-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?

The description provides a comprehensive list of specific operations with brief explanations, which guides usage. However, it lacks explicit when-to-use vs alternatives (e.g., merge_by_distance vs remove_doubles). The context is clear but could improve by directly comparing with similar tools in the sibling list.

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

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

With no annotations, description must disclose behavior. It details the cleanup pipeline (EXACT solver, dissolve degenerate, etc.) but does not reveal whether the tool is destructive, modifies in place, or any side effects on the mesh.

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

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

Extremely concise: a single line for purpose, then bulleted parameter list. No filler. Informative yet 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 an output schema present, return values are covered. The description fully documents all four parameters and their behavior. Could mention side effects like whether it modifies the mesh in-place, but overall complete for the tool's complexity.

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

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

Schema description coverage is 0%, so description must compensate. It does so by clearly explaining each parameter: mesh_name as target, cutter_name with special empty behavior, operation with enums and default, auto_cleanup with function. Adds significant meaning beyond 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?

Clearly describes a boolean operation with an automatic cleanup pipeline, distinguishing it from the simpler sibling tool 'boolean_operation'. The verb 'operation' combined with 'cleanup' makes the purpose 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?

Implies usage for boolean operations needing cleanup, but does not explicitly state when to prefer this over sister tools or alternative approaches. No exclusions or context 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?

The description discloses that apply=True applies the modifier and removes the cutter, but does not mention destructive nature, mesh requirements, or behavior when apply=False. Given no annotations, the transparency is moderate.

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, consisting of three short sentences. It is front-loaded with the core purpose, but could be better structured with bullet points for operations.

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

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

Given the tool has 4 parameters, no output schema, and no annotations, the description provides a basic understanding but lacks details on return values, prerequisites, and the full workflow. It is minimally sufficient.

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

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

With 0% schema description coverage, the description explains the 'operation' and 'apply' parameters, but 'target' and 'cutter' are only implied as 'two mesh objects'. This adds some meaning but not complete coverage for all four 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 tool performs a boolean operation on mesh objects, lists the three operation types, and explains the apply behavior. It is specific and unambiguous, distinguishing it from sibling tools like 'boolean_cleanup'.

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 such as 'bmesh_operation' or 'boolean_cleanup'. The description implies usage for boolean operations but does not specify prerequisites 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 behavioral disclosure. It implies a geometry modification (creating faces) but does not clarify if the operation is destructive, what happens to the original edge loops, or how to undo it. For a simple operation, basic transparency is achieved, but there is room for more detail.

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

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

The description is extremely concise: two sentences that cover the action and the essential prerequisite. Every sentence is meaningful and adds value. 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?

Despite the tool's simplicity, the description lacks information about return values or success/failure feedback. Combined with an undocumented parameter, the agent has incomplete context to use the tool effectively. Output schema is absent, so the description should at least hint at what the tool returns.

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

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

The input schema has one required parameter 'name' with no description, and the tool description does not explain its purpose. Schema description coverage is 0%, so the description must compensate but fails to do so. The agent cannot infer what 'name' refers to (e.g., object name, mesh name).

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

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

The description clearly states the action ('Bridge'), the resource ('two selected edge loops'), and the result ('create connecting faces'). It effectively distinguishes from sibling tools like 'extrude_faces' or 'bevel_edges' by specifying the exact mesh topology 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 a clear prerequisite: the object must have exactly two edge loops selected in edit mode. This tells the agent when to use the tool. However, it does not explicitly mention when not to use it or suggest alternative tools for different selection scenarios, which would be helpful.

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 fully disclose behavioral traits. It explains the tool creates materials with node connections and lists presets, but does not mention potential side effects (e.g., overwriting existing materials) or prerequisites (e.g., active object).

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 (approx. 80 words) and well-structured with labeled parameter sections. Every sentence is informative; no fluff. Slightly verbose in the presets list but acceptable.

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 an output schema (not shown), the description need not explain return values. It adequately covers all parameters and provides practical context (e.g., preset types, texture keys). Missing details like default behavior for missing textures are minor.

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 beyond the input schema, which has no parameter descriptions. It explains material_name, presets with concrete examples, textures as a JSON map with expected keys, and notes custom_nodes as advanced. This compensates for the schema's 0% 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 that the tool builds complex shader node trees programmatically, creating materials with proper node connections. It distinguishes itself from simple color assignment tools (e.g., set_material_color) by emphasizing its advanced capabilities.

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 provide explicit guidance on when to use this tool vs. alternatives like material_create_pbr or material_create_preset. It implies it's for complex setups but lacks formal when/when-not criteria or direct references to sibling tools.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that the tool generates a bpy script, executes it in headless Blender, and lists supported JSON fields. This gives good behavioral insight, though it does not cover error handling or potential 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 well-structured with bullet points and a concrete example, making it easy to parse. It is slightly long due to the example, but every section adds value; no redundant 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 no output schema and no annotations, the description covers the tool's core operation (execution method, JSON structure). It lacks details on output parameters ('blend_output', 'render_output') and the scene handling (append vs clear), but is otherwise 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 elaborates extensively on 'scene_json' with a detailed example and field breakdown, compensating for the 0% schema coverage. However, 'blend_output' and 'render_output' are not explained, leaving ambiguity about their 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 'Build a complete Blender scene from a JSON description', with a specific verb and resource. It distinguishes from siblings like 'generate_scene_script' by describing direct scene building rather than script generation.

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

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

Usage is implied ('Build a complete Blender scene from a JSON description') but no explicit when-to-use vs alternatives like 'generate_scene_script' or 'io_import_file'. The mention of 'CLI-Anything' origins provides context but not comparative guidance.

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

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

With no annotations, the description bears full responsibility. It describes the effect (moving objects to center) but does not disclose whether the operation is destructive or reversible, nor does it mention any side effects like changes to object scale or rotation.

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

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

Two sentences with no fluff. The first sentence communicates the primary action, and the second covers the parameter's default behavior. Perfectly front-loaded.

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

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

For a tool with one optional parameter and no output schema, the description is sufficiently complete. It explains the core functionality and parameter usage. Minor gap: no mention of return value, but contextually unnecessary.

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

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

Despite 0% schema description coverage, the description explains the 'names' parameter's effect: if omitted, all objects are centered. This adds meaningful context beyond the bare schema type definition.

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

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

The description uses a specific verb ('Move objects') and clearly states the result ('collective center at world origin'). It distinguishes from siblings like 'align_objects' and 'origin_set' by focusing on group center rather than individual transforms.

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 includes when to use (centering objects) and the behavior when no names are given (centers all objects in the scene). However, it does not explicitly mention when not to use or suggest alternative tools like 'origin_set' for individual objects.

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

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

No annotations exist, so the description carries the full burden. It states a destructive mutation (removal) but does not disclose reversibility, impact on drivers or constraints, or behavior when object has no animation 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?

Single sentence with no redundancy. Efficiently conveys the core action.

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

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

For a one-parameter tool with no output schema, the description is minimally adequate but lacks distinction from numerous sibling animation tools and does not describe return behavior.

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

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

Schema coverage is 0%; the description does not explain the 'name' parameter beyond what the schema provides (string). It fails to add meaning such as that it must be an object name or that the animation data is removed from that specific object.

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 action (Remove) and target (animation data from an object). However, it does not distinguish from sibling tool 'anim_clear_all' which likely clears all animations in the scene, leading to potential confusion.

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 'anim_clear_all' or 'anim_delete_keyframe'. No prerequisites or context are 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?

The description explains that with keep_transform=True the object stays in place, which is useful. However, with no annotations, it does not disclose prerequisites (e.g., object must have a parent) or side effects (e.g., world transform preservation 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 a single concise sentence that includes the core action and a key parameter behavior. No extraneous 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 (2 params, no output schema), the description covers the main behavior. It lacks prerequisites and return value details, but for a straightforward operation it is reasonably complete.

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

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

Schema coverage is 0%, so the description is the sole source of parameter meaning. It clarifies the 'keep_transform' parameter's effect but does not explain the 'name' parameter beyond its name. This adds some value but not comprehensive.

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