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 effectively describes key behaviors: it's a write operation (creates/updates files and attaches components), explains idempotent mode ('preserve an existing UUID on overwrite'), mentions potential errors ('silently-broken component'), and details the return structure. However, it doesn't cover permissions, rate limits, or error handling beyond the UUID issue.

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 and appropriately sized. It front-loads the core purpose, provides context about the problem it solves, details parameters in a clear section, and shows the return format. While comprehensive, every sentence earns its place by adding necessary information. The only minor improvement would be slightly tighter formatting of the parameter explanations.

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 (7 parameters, no annotations, no output schema), the description provides complete context. It explains the tool's purpose, when to use it, detailed parameter semantics, behavioral characteristics, and the exact return structure. For a mutation tool with rich functionality and no structured metadata, this description adequately compensates with thorough textual documentation.

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

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

With 0% schema description coverage for 7 parameters, the description fully compensates by providing detailed semantic explanations for all parameters. It explains what each parameter does (e.g., 'rel_path follows cocos_add_script's prefix rules'), provides usage examples ('Use {"__id__": N} for node/component refs'), and clarifies optional behavior ('Omit to let the underlying add_script preserve an existing UUID'). This adds substantial value 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 clearly states the tool's purpose: 'Write a TS script file + attach it as a component in ONE call.' It specifies the exact action (write and attach), the resource (TS script file), and distinguishes it from sibling tools by explaining it replaces the problematic 3-call sequence involving 'cocos_add_script' and 'cocos_compress_uuid'.

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 usage guidelines by explaining when to use this tool ('Replaces the 3-call sequence agents ran dozens of times per session') and when not to use alternatives (avoiding the 'two same-named cocos_add_script tools' that cause friction). It names specific sibling tools ('cocos_add_script', 'cocos_compress_uuid') and describes the problems they cause, giving clear context for tool selection.

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

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

No annotations are provided, so the description carries the full burden. It states 'Attach cc.Animation', implying a mutation (adding/attaching a component), but doesn't disclose behavioral traits such as whether this requires specific permissions, if it modifies existing animations, error handling, or what the output looks like. The mention of clip_uuids adds minimal context, but overall, it lacks critical details 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 two short sentences, front-loading the main action ('Attach cc.Animation.') and adding a detail about clip_uuids. There's no unnecessary fluff, but it might be overly terse given the tool's complexity. Every sentence serves a purpose, though more structure could improve clarity.

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, mutation operation, no annotations, but has output schema), the description is incomplete. It lacks details on behavior, parameter meanings beyond clip_uuids, and usage context. The output schema exists, so return values needn't be explained, but the description doesn't provide enough guidance for effective tool selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'clip_uuids is a list of AnimationClip asset UUIDs', which covers one of five parameters. It doesn't explain scene_path, node_id, default_clip_uuid, or play_on_load, leaving most parameters undocumented. This adds minimal value beyond the schema, failing to address the coverage gap.

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

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

The description 'Attach cc.Animation. clip_uuids is a list of AnimationClip asset UUIDs.' states the action (attach) and resource (cc.Animation), but is vague about the full scope. It mentions clip_uuids but doesn't explain what 'attach' entails or how it relates to other parameters like scene_path and node_id. It doesn't clearly distinguish from siblings like 'cocos_add_component' or 'cocos_create_animation_clip', which might handle similar animation-related tasks.

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 doesn't mention prerequisites (e.g., needing an existing node or scene), exclusions, or compare to siblings like 'cocos_add_component' for general components or 'cocos_create_animation_clip' for creating clips. Usage is implied only through parameter names, but no explicit context is given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions copying and writing meta, implying a write operation, and notes the return format, but fails to detail permissions, error handling, or side effects like file overwriting. This leaves significant gaps in understanding the tool's behavior beyond basic functionality.

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

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

The description is brief and front-loaded, with three sentences that efficiently convey core functionality and return values without unnecessary elaboration. Each sentence adds value, making it appropriately sized for the tool's complexity.

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

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

Given the tool's moderate complexity (4 parameters, no annotations, no output schema), the description is incomplete. It covers basic purpose and return format but misses parameter explanations, usage context, and behavioral details like error conditions or dependencies, leaving the agent with insufficient information for reliable use.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not explain any of the 4 parameters (project_path, src_path, rel_path, uuid), such as their purposes, formats, or relationships. This lack of semantic detail hinders effective tool 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 action ('Copy an audio file into assets/resources/ + write meta') and resource ('audio file (mp3/wav/ogg)'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'cocos_add_audio_source' or 'cocos_add_resource_file', which might handle similar resources or operations, leaving some ambiguity about uniqueness.

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 minimal guidance, mentioning that the file is placed under resources/ for runtime loading via resources.load(), but it lacks explicit when-to-use instructions, prerequisites, or alternatives compared to siblings. No exclusions or clear context for choosing this tool over others are stated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only mentions what the tool does (attaching an audio source) and one parameter detail, but doesn't describe what happens when invoked (e.g., whether it modifies scene state, requires specific permissions, has side effects, or what the output contains). For a tool with 6 parameters and no annotation coverage, this is inadequate.

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

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

The description is extremely concise - a single sentence that gets straight to the point with no wasted words. It's appropriately sized for what it does cover, though it could benefit from additional context given the complexity of the tool.

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

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

For a tool with 6 parameters, no annotations, and complex sibling relationships (multiple audio-related tools), the description is insufficient. While an output schema exists, the description doesn't provide enough context about the tool's purpose, usage scenarios, parameter meanings, or behavioral characteristics to guide an AI agent effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It only provides semantic context for one parameter (clip_uuid), leaving the other 5 parameters (scene_path, node_id, play_on_awake, loop, volume) completely unexplained. The description doesn't clarify what these parameters mean or how they affect the audio source 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 action ('Attach') and the resource ('cc.AudioSource'), and provides specific technical detail about the clip_uuid parameter referencing an audio-clip asset. However, it doesn't explicitly differentiate from sibling tools like 'cocos_add_audio_file' or explain what makes this audio source component unique.

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

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

No guidance is provided about when to use this tool versus alternatives like 'cocos_add_audio_file' or other audio-related tools. The description doesn't mention prerequisites, typical use cases, or any context for selecting this specific audio component over others.

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 states the tool attaches a component and describes its functional effect (blocking input), but lacks critical behavioral details such as whether this is a mutation (likely yes), permission requirements, error conditions, or how it interacts with existing components. The description is minimal and doesn't compensate for the absence of annotations.

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

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

The description is extremely concise with two short sentences that directly state the action and effect. It is front-loaded and wastes no words, 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 has 2 parameters with 0% schema coverage, no annotations, and an output schema (which might help but isn't described), the description is incomplete. It covers the basic purpose but misses parameter semantics, usage context, and behavioral transparency needed for a mutation tool in a complex environment like Cocos.

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 schema provides no parameter details. The description adds no information about the two required parameters (scene_path and node_id), failing to explain what they represent, their format, or how they identify the target node. This leaves parameters completely undocumented beyond their names and types.

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

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

The description clearly states the verb ('Attach') and resource ('cc.BlockInputEvents'), with a specific effect ('Blocks touch/mouse from passing through this node'). It distinguishes from siblings by focusing on input blocking rather than adding components like animations or scripts, though it doesn't explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives. The description mentions the functional effect but doesn't specify prerequisites, context (e.g., for UI elements), or when not to use it, leaving the agent to infer usage from the tool name and 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 provided, the description carries the full burden. It discloses that the tool creates an animation (implied mutation) and returns specific identifiers ({clip_uuid, clip_path, anim_component_id}), which is useful behavioral context. However, it doesn't cover error conditions, side effects (e.g., if it modifies existing animations), or performance implications, leaving gaps 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 efficiently structured in three focused sentences: first states the purpose, second provides tuning guidelines, third specifies return values. Each sentence adds value without redundancy, and it's front-loaded with the core functionality.

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 6 parameters with 0% schema coverage and no output schema, the description partially compensates by explaining two key parameters and the return format. However, as a mutation tool with no annotations, it lacks details on error handling, side effects, and the semantics of undocumented parameters, making it incomplete for safe agent invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for 'overshoot' (tuning range 1.05-1.3, effects of values) and 'duration' (default 0.5s, adjustment for UI vs. games), covering 2 of 6 parameters well. However, it doesn't explain 'scene_path', 'node_id', 'delay', or 'rel_dir', leaving half the parameters undocumented.

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

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

The description clearly states the tool adds a 'spring-like overshoot' entrance animation (specific verb+resource), distinguishing it from siblings like 'cocos_add_fade_in' or 'cocos_add_scale_in'. However, it doesn't explicitly contrast with all sibling animation tools, leaving some ambiguity about when to choose bounce over other entrance effects.

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 implied usage guidance by suggesting default values (0.5s duration for UI, halve for games) and tuning ranges for 'overshoot', which helps inform when to adjust parameters. However, it lacks explicit when-to-use vs. alternatives (e.g., compared to 'cocos_add_pulse' or other animation siblings) and doesn't mention prerequisites like required scene or node setup.

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. It discloses key behavioral traits: the controller handles 'ground snapping, slope limits, step-up automatically' which reveals automation capabilities. However, it doesn't mention permission requirements, error conditions, or mutation effects (e.g., whether this modifies existing components).

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 perfectly front-loaded with the core purpose in the first sentence, followed by usage guidance and key capabilities. Every sentence earns its place with no wasted words, making it highly efficient for an agent to parse.

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

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

Given 13 parameters with 0% schema coverage and no annotations, the description is incomplete despite having an output schema. It explains the 'what' and 'when' well but leaves the 'how' (parameter usage) entirely undocumented. For a complex tool with many numeric parameters, more guidance on parameter relationships would be helpful.

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% (13 parameters with no descriptions in schema). The description adds no parameter information beyond what's implied by the tool name. It doesn't explain what parameters like 'scene_path', 'node_id', or the various dimension/extent parameters actually mean or how they relate to the character controller.

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 ('Attach cc.BoxCharacterController') and resource ('AABB-shaped kinematic character'), distinguishing it from sibling tools like 'cocos_add_capsule_character_controller' by specifying the shape type. It provides a precise technical purpose beyond just the tool name.

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

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

The description explicitly states when to use this tool ('Use this INSTEAD of RigidBody + Collider for player movement') and provides a clear alternative scenario to avoid. This gives the agent specific guidance on tool selection versus other physics components.

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 states 'Attach', implying a mutation operation, but fails to disclose critical behavioral traits such as whether this requires specific permissions, if it overwrites existing colliders, error conditions, or side effects. The description adds minimal context beyond the basic action.

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

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

The description is a single, efficient sentence with no wasted words, front-loading the core action and key attributes. It is appropriately sized for the tool's complexity, 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 has an output schema (which handles return values), no annotations, and 11 parameters with 0% schema coverage, the description is incomplete. It covers the basic purpose but lacks usage guidelines, detailed parameter semantics, and behavioral transparency, making it minimally adequate but with significant gaps for a mutation tool in a complex environment.

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 schema provides no parameter descriptions. The description mentions 'size, offset, and physics material', which loosely maps to some parameters (e.g., width/height for size, offset_x/offset_y for offset, density/friction/restitution for physics material), but it does not explain the semantics of the 11 parameters, such as 'scene_path', 'node_id', 'is_sensor', or 'tag', leaving most undocumented.

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

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

The description clearly states the verb ('Attach') and resource ('cc.BoxCollider2D') with specific attributes ('given size, offset, and physics material'), making the purpose explicit. However, it does not differentiate from sibling tools like 'cocos_add_circle_collider2d' or 'cocos_add_box_collider_3d', which are similar collider-adding tools, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as other collider types (e.g., circle, polygon) or 3D variants. It also omits prerequisites, like needing a valid scene and node, leaving the agent to infer usage from the required parameters alone.

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

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

The description provides minimal behavioral information. With no annotations, it doesn't disclose whether this is a read or write operation (though 'Attach' implies mutation), what permissions are needed, whether it modifies existing components, or what the output contains. It lacks details on side effects, error conditions, or performance characteristics that would help the agent use it correctly.

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to scan. Every word earns its place by specifying the component type and dimensionality.

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 (9 parameters, no annotations, 0% schema coverage) and the presence of an output schema, the description is insufficient. It doesn't compensate for the lack of parameter documentation or behavioral context. While the output schema may describe return values, the description fails to explain how to use the tool effectively, leaving the agent poorly equipped to invoke it correctly.

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

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

Schema description coverage is 0%, meaning parameter titles provide no semantic context. The description doesn't explain any parameters, their relationships, or what values are appropriate. For 9 parameters (2 required), this leaves critical gaps—for example, what 'scene_path' and 'node_id' refer to, or how size/center coordinates are interpreted.

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 ('Attach') and resource ('cc.BoxCollider (3D AABB shape)'), making the purpose specific and understandable. It distinguishes from 2D siblings like 'cocos_add_box_collider2d' by specifying '3D', but doesn't differentiate from other 3D collider tools (e.g., sphere, capsule) beyond the shape type.

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. The description doesn't mention prerequisites, when to choose this over other collider types, or what context it's appropriate for. The agent must infer usage from the tool name and parameters alone.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool attaches a button component (implying mutation/creation), explains color preset behavior and auto-derivation logic, and shows click event binding. However, it doesn't mention permissions, error conditions, rate limits, or what happens if the node already has a button component.

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 efficiently structured with key information front-loaded: purpose, transition types, color_preset behavior, and click_events usage. The example is helpful and well-placed. Some sentences could be slightly more concise, but overall it's appropriately sized for the tool's complexity.

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

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

Given the complex 22-parameter schema with 0% description coverage and no annotations, the description does a good job covering the most important aspects: transition types, color system, and click events. The presence of an output schema reduces the need to explain return values. However, for such a complex tool, more complete parameter coverage would be ideal.

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 and 22 parameters, the description adds significant value beyond the schema. It explains the meaning of 'transition' values (0-3), clarifies color_preset behavior and its relationship to RGBA parameters, and provides usage context for click_events. However, it doesn't cover all 22 parameters - notably missing scene_path and node_id semantics.

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

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

The description clearly states the tool's purpose: 'Attach cc.Button' with specific details about transition types. It distinguishes from sibling 'cocos_add_button_with_label' by focusing on button attachment without label functionality. However, it doesn't explicitly contrast with other UI component tools like 'cocos_add_toggle' or 'cocos_add_slider'.

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

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

The description provides clear context about when to use color_preset versus explicit RGBA values, and includes a concrete example showing how to use click_events with cocos_make_click_event. However, it doesn't explicitly state when NOT to use this tool versus alternatives like 'cocos_add_button_with_label' or other UI components.

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 effectively describes the tool's behavior: it creates a composite UI element, handles design-token presets through the project's UI theme, forwards click events verbatim from 'cocos_make_click_event', and specifies the return structure. However, it lacks details on error handling, permissions, or rate limits, which are minor gaps given the 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 well-structured and front-loaded with the main purpose, followed by detailed context, examples, and return values. Every sentence adds value: the first states the core function, the second explains the common use case, the third lists the folded calls, the fourth shows the structure, the fifth covers design tokens, the sixth explains click events, and the seventh specifies returns. No waste, highly 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 the complexity (16 parameters, no annotations, no output schema), the description is remarkably complete. It covers purpose, usage, behavioral traits, parameter semantics, and return values in detail. The lack of output schema is mitigated by explicitly stating the return structure. For a tool with high parameter count and zero schema coverage, this description provides all necessary context for effective use.

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

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

The schema description coverage is 0%, so the description must compensate fully. It adds significant meaning beyond the schema: it explains that parameters like 'label_color_preset', 'label_size_preset', and 'bg_color_preset' resolve through the project's UI theme, clarifies that 'click_events' are forwarded from 'cocos_make_click_event', and implies default behaviors for optional parameters (e.g., sprite is optional). This provides essential context 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 the tool creates a button node with a child label in one call, specifying the exact structure produced (Btn with UITransform, optional Sprite, Button, and child Label with UITransform and Label). It distinguishes from siblings like 'cocos_add_button' and 'cocos_add_label' by emphasizing it folds seven separate calls into one, making the purpose specific and differentiated.

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

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

The description explicitly states when to use this tool: for the 'most common UI primitive' where menus typically have 2-4 buttons, and it folds seven separate calls into one. It implies alternatives by listing the individual sibling tools (e.g., cocos_create_node, cocos_add_uitransform, cocos_add_button, cocos_add_label) that would otherwise be needed, providing clear context for usage versus those 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 carries the full burden of behavioral disclosure. It mentions the projection types (ORTHO/PERSPECTIVE) and a use case, but fails to describe critical behaviors such as whether this is a read or write operation, permission requirements, side effects (e.g., if it modifies existing nodes), or error handling. For a tool with 11 parameters and no annotation coverage, this is a significant gap.

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

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

The description is extremely concise with two sentences that directly convey key information: the tool's action and a parameter explanation with a use-case hint. Every word serves a purpose, and it is front-loaded with the main function, making it efficient and easy to parse.

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

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

Given the tool's complexity (11 parameters, no annotations, but with an output schema), the description is incomplete. It lacks details on behavioral traits, most parameter semantics, and overall context needed for effective use. While the output schema may cover return values, the description does not provide sufficient guidance for a tool of this scope, especially with zero schema description coverage.

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

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

Schema description coverage is 0%, so the description must compensate for all parameters. It only explains the 'projection' parameter (0=ORTHO, 1=PERSPECTIVE) and hints at usage, leaving the other 10 parameters (e.g., scene_path, node_id, priority, ortho_height) undocumented. This adds minimal value beyond the schema, failing to adequately clarify parameter meanings or interactions.

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 ('Attach') and resource ('cc.Camera'), making the purpose specific and understandable. It distinguishes this tool from siblings by focusing on camera attachment rather than other components like scripts, animations, or colliders, though it doesn't explicitly compare to alternatives.

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

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

The description provides implied usage context with 'For minimap/split-screen,' suggesting when this tool might be applicable. However, it lacks explicit guidance on when to use it versus alternatives, prerequisites, or any 'when-not' scenarios, leaving the agent to infer from the limited hint.

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 describes the component's shape and kinematic nature, but lacks critical behavioral details: it doesn't specify if this is a destructive operation (attaching likely modifies the node), what permissions are needed, whether it can be undone, or how it interacts with other components. The height clarification is useful but 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 extremely concise and well-structured: the first sentence states the core purpose, the second provides comparative context, and the third clarifies a critical parameter detail. Every sentence earns its place with no wasted words.

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

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

Given the tool's complexity (12 parameters, mutation operation) and the presence of an output schema (which reduces need to describe returns), the description is partially complete. It covers the purpose and one parameter nuance well, but lacks behavioral transparency for a mutation tool and leaves most parameters unexplained. The output schema existence helps but doesn't compensate for the missing behavioral 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?

With 0% schema description coverage for 12 parameters, the description adds significant value by clarifying the 'height' parameter semantics ('distance between the two sphere centers' vs 'total capsule height'). However, it doesn't explain the other 11 parameters (like 'scene_path', 'node_id', or physics-related settings), leaving most parameter meanings undocumented.

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

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

The description clearly states the specific action ('Attach'), the exact component ('cc.CapsuleCharacterController'), and its nature ('capsule-shaped kinematic character'). It distinguishes from the sibling 'cocos_add_box_character_controller' by noting that capsules are 'more common than box for humanoid characters' and provide 'smoother wall sliding'.

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

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

The description provides clear context for when to use this tool by comparing it to the box alternative and explaining its advantages for humanoid characters. However, it does not explicitly state when NOT to use it or mention any prerequisites beyond the required parameters, which are documented in the schema.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool attaches a collider and specifies direction mapping, but fails to describe key behavioral traits: whether this is a mutation (likely yes, but not stated), what happens if a collider already exists (replacement or error), permissions needed, or side effects. The description adds minimal context beyond the basic action.

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

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

The description is extremely concise—a single sentence that directly states the action and provides key parameter info. It's front-loaded with the main purpose and wastes no words, making it easy to parse quickly. Every part earns its place by delivering essential information 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 (9 parameters, no annotations, but has an output schema), the description is incomplete. It lacks context on when to use the tool, behavioral details, and semantics for most parameters. While the output schema may cover return values, the description doesn't address mutation risks, prerequisites, or integration with sibling tools, leaving significant gaps for an agent to operate effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains the 'direction' parameter (mapping 0,1,2 to X,Y,Z), leaving 8 other parameters undocumented. While it adds meaning for one parameter, it fails to cover the majority, including critical ones like 'scene_path' and 'node_id'. This insufficiently compensates for the low schema 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 'Attach cc.CapsuleCollider' clearly states the verb ('Attach') and resource ('cc.CapsuleCollider'), but it's vague about the exact action—it doesn't specify if this creates a new collider or attaches an existing one. It distinguishes from siblings like 'cocos_add_box_collider_3d' by specifying 'Capsule', but lacks detail on the broader purpose (e.g., for physics simulation).

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

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

No explicit guidance is provided on when to use this tool versus alternatives. The description mentions direction mapping (0=X, 1=Y, 2=Z), which hints at orientation but doesn't explain when to choose this over other collider types (e.g., box or sphere) or prerequisites like scene/node setup. Without usage context, the agent must infer from parameters alone.

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

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

With no annotations provided, the description carries full burden and does well by describing key behaviors: whole card acts as button, automatic text color contrast based on variant, extras wrap to new rows, and return structure. It doesn't mention permissions, rate limits, or mutation effects, but covers core UI behavior adequately.

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 efficiently structured with clear sections: purpose, card structure, behavior, return values, and click wiring. Every sentence adds value, though the technical formatting (:: and # comments) slightly reduces readability.

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

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

For a 7-parameter tool with no annotations and no output schema, the description provides substantial context: purpose, parameter semantics, behavior, and return structure. It could mention error conditions or performance considerations but covers the essentials well given the complexity.

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

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

With 0% schema description coverage and 7 parameters, the description compensates excellently by explaining the 'cards' array structure in detail (title, subtitle, icon, variant, click_events) and mentioning layout behavior (wrapping when count > columns). It adds crucial meaning beyond the bare schema property 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 clearly states the tool creates a 'Grid of tappable cards' with specific use cases (level select, shop, character picker). It distinguishes from sibling tools by focusing on card grid creation rather than other UI components like buttons, labels, or dialogs listed in the sibling tools.

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

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

The description implies usage through example contexts (level select, shop, character picker) but doesn't explicitly state when to use this tool versus alternatives like 'cocos_add_button' or 'cocos_add_main_menu'. No explicit exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions attaching a collider with physics material, implying a mutation operation, but does not cover critical aspects like whether it modifies existing colliders, requires specific permissions, has side effects (e.g., affecting gameplay), or error conditions. This leaves significant gaps for a tool that likely alters scene state.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the key action and components, making it easy to scan and understand the core purpose immediately.

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

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

Given the complexity (10 parameters, mutation tool), lack of annotations, and 0% schema coverage, the description is inadequate. It does not explain parameter meanings, behavioral traits, or usage context. While an output schema exists, the description fails to provide necessary context for safe and effective use, especially for a tool that likely modifies physics properties.

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 mentions 'radius and physics material', hinting at parameters like radius, density, friction, and restitution, but does not explain the 10 parameters (e.g., scene_path, node_id, offset_x/y, is_sensor, tag) or their purposes. This adds minimal value beyond the schema titles.

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

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

The description clearly states the verb ('Attach') and resource ('cc.CircleCollider2D'), specifying the component type and key parameters (radius, physics material). It distinguishes from siblings like 'cocos_add_box_collider2d' by indicating a circle shape, but does not explicitly differentiate from other collider types beyond the name.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., other collider types like box or polygon), prerequisites (e.g., needing a node with a physics body), or exclusions. The description only states what it does, not when or why 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 full burden. It implies a mutation ('Attach'), but doesn't disclose permissions, side effects, error handling, or what the output schema contains. The auto-wrapping note is useful but insufficient for a mutation tool with no annotation coverage.

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

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

Three sentences with zero waste: first states purpose with example, second explains auto-wrapping, third gives resource ref syntax. It's front-loaded and efficiently 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?

For a mutation tool with 4 parameters, 0% schema coverage, no annotations, but an output schema exists, the description does well on parameters but lacks behavioral context (e.g., side effects, permissions). The output schema means return values needn't be explained, but other gaps remain.

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 adds significant value: it explains 'type_name' format (full type name with example), clarifies 'props' auto-wrapping behavior (list[3]->Vec3, int->__id__ ref), and specifies resource ref syntax ({"__uuid__": "<uuid>"}). This compensates well for the schema gap, though it doesn't detail 'scene_path' or 'node_id'.

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

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

The description clearly states the verb ('Attach') and resource ('any cc component'), with a specific example ('cc.RigidBody2D'). It distinguishes from many sibling tools that add specific components (like 'cocos_add_rigidbody2d') by being generic, though it doesn't explicitly contrast with the generic 'cocos_add_script' or 'cocos_add_animation'.

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

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

No guidance on when to use this tool versus the many specific sibling tools (e.g., 'cocos_add_rigidbody2d' vs. using this with 'cc.RigidBody2D'). It mentions auto-wrapping for 'props', but doesn't clarify prerequisites, error conditions, or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to describe any behavioral traits: it doesn't indicate whether this is a mutation (likely yes, as it 'Attaches'), what permissions or scene state are required, if it has side effects, or the response format. The description is minimal and adds no behavioral context beyond the basic action.

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

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

The description is extremely concise with a single sentence, 'Attach cc.ConeCollider.', which is front-loaded and wastes no words. While under-specified, it earns a high score for brevity and clarity within its limited scope, as every word serves a 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 complexity (9 parameters, no annotations, 0% schema coverage) and the presence of an output schema (which might help but isn't described), the description is severely incomplete. It fails to explain the tool's purpose in context, parameter meanings, usage scenarios, or behavioral aspects, making it inadequate for effective agent use.

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

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

Schema description coverage is 0%, meaning none of the 9 parameters are documented in the schema. The description provides no information about parameters—it doesn't explain what 'scene_path', 'node_id', or the geometric properties (radius, height, etc.) mean, their units, or how they affect the collider. This leaves critical input semantics undefined.

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 'Attach cc.ConeCollider' states a verb ('Attach') and resource ('cc.ConeCollider'), but is vague about what it actually does—it doesn't specify that this adds a 3D cone-shaped collision component to a node in a Cocos Creator scene. While it distinguishes from siblings by naming 'ConeCollider', it lacks the specificity needed for clear understanding, making it borderline tautological with the tool name.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., needing a valid scene and node), exclusions, or comparisons to sibling tools like other collider types (e.g., box_collider_3d, sphere_collider_3d). This leaves the agent without context for proper tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to describe any behavioral traits: it does not state whether this is a mutation (likely yes, given 'add'), what permissions are needed, if it modifies the scene permanently, or what the output schema contains. The description is too minimal to inform the agent about the tool's behavior beyond the basic action implied by the name.

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 phrase 'Attach cc.CylinderCollider', which is overly concise to the point of under-specification. While it avoids verbosity, it fails to provide necessary context or structure, making it inefficient for guiding tool selection. Every word should earn its place, but here the minimalism sacrifices clarity.

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 (9 parameters, no annotations, but an output schema exists), the description is incomplete. It does not explain the tool's purpose beyond the name, lacks usage guidelines, omits behavioral context, and provides no parameter semantics. Although an output schema exists, the description fails to cover basic aspects needed for effective tool use, such as when and how to apply it in a Cocos Creator context.

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

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

The schema description coverage is 0%, meaning parameter titles (e.g., 'Scene Path', 'Node Id') are the only documentation. The description adds no semantic information about parameters, such as explaining what 'direction' (an integer) controls, what units 'radius' and 'height' use, or how 'center_x', 'center_y', 'center_z' relate to the node. With 9 parameters, this lack of detail is inadequate.

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 'Attach cc.CylinderCollider' restates the tool name 'cocos_add_cylinder_collider_3d' without adding specificity. It uses a vague verb 'Attach' instead of clarifying what 'add' means in this context (e.g., creating and configuring a collider component). No differentiation from sibling tools like 'cocos_add_box_collider_3d' is provided, making it a tautological restatement of the name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., requiring a 3D node), context (e.g., for physics simulations), or exclusions (e.g., not for 2D scenes). With many sibling tools for adding colliders and components, the lack of any usage context is a significant gap.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behaviors: it creates UI elements (implies mutation), returns IDs for later modification, inherits colors from theme, and provides default button behavior. It doesn't mention permissions, error handling, or rate limits, but covers the essential creation and return mechanics.

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 efficiently structured with three paragraphs: purpose and efficiency gain, theme inheritance and button details, and return value. Every sentence adds value without redundancy, and key information is front-loaded.

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

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

For a complex UI creation tool with 8 parameters, 0% schema coverage, no annotations, and no output schema, the description does well by explaining the tool's purpose, parameter semantics, and return value. It could improve by mentioning error cases or prerequisites, but it covers the essential context for correct 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?

With 0% schema description coverage and 8 parameters, the description adds significant value beyond the schema. It explains the 'buttons' parameter structure in detail (including variants like 'primary', 'secondary', 'danger', 'ghost'), mentions default values for buttons and body, and clarifies that colors inherit from theme, which helps interpret parameters like scene_path and parent_node_id in context.

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

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

The description clearly states the tool builds a centered modal dialog with specific components (backdrop, panel, title, body, buttons) and distinguishes it from siblings by noting it replaces 15+ primitive calls. It provides a specific verb ('Build') and resource ('centered modal dialog').

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

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

The description provides clear context for when to use this tool (to create modal dialogs efficiently) and mentions inheritance from UI theme set via another tool, but does not explicitly state when not to use it or name specific alternatives among the many sibling tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It explains some behavioral aspects like default illuminance values and shadow PCF mapping, but doesn't cover important behavioral traits like whether this operation is destructive/reversible, permission requirements, rate limits, or what the output contains. The description adds value but 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 perfectly concise with three focused sentences that each earn their place: first states the core purpose, second explains key parameter semantics, third provides usage context. No wasted words, front-loaded with the most important information, and well-structured for quick comprehension.

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

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

Given the tool's complexity (13 parameters, no annotations) but presence of an output schema, the description does well by covering purpose, key parameter semantics, and usage context. However, for a mutation tool with many parameters and no annotations, it could benefit from more behavioral context about what the tool actually does (creates/modifies/attaches) and potential side effects.

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 and 13 parameters, the description compensates excellently by explaining the semantics of key parameters: 'illuminance' units (lux) with a real-world reference (65000 ≈ midday sun), and 'shadow_pcf' enumeration mapping (0=HARD, 1=SOFT, etc.). This adds crucial meaning beyond what the bare schema provides for the most important 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 specific action ('Attach cc.DirectionalLight') and resource ('sun/moon parallel light'), distinguishing it from sibling tools like 'cocos_add_sphere_light' or 'cocos_add_spot_light' by specifying it's for directional lighting. It provides concrete technical context about what type of light component is being added.

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

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

The description provides clear context about when to use this tool ('A scene typically has exactly one directional light'), which helps the agent understand its appropriate application. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the many sibling tools, preventing a perfect score.

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 offers minimal behavioral insight. It implies a creation/mutation action ('Attach') but doesn't disclose side effects (e.g., modifies scene state), permissions, error conditions, or response format. The presence of an output schema helps, but the description itself lacks critical behavioral context for a 12-parameter 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 extremely concise—a single sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence contributes directly to the tool's 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 complexity (12 parameters, mutation tool, no annotations) and the presence of an output schema, the description is incomplete. It lacks parameter explanations, usage context, behavioral details, and doesn't leverage the output schema to clarify returns. For a physics joint tool with many parameters, this minimal description 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?

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain what parameters like 'scene_path', 'node_id', or 'distance' mean, their units, constraints, or relationships. With 12 parameters entirely undocumented in both schema and description, this is a severe gap.

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

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

The description clearly states the action ('Attach') and the specific resource ('cc.DistanceJoint2D'), with a brief functional explanation ('keeps two bodies a fixed distance apart'). It distinguishes from sibling tools by specifying the exact joint type, but doesn't explicitly contrast with other joint tools like 'cocos_add_fixed_joint_2d' or 'cocos_add_spring_joint2d'.

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. The description doesn't mention prerequisites (e.g., requiring physics bodies), context (e.g., for 2D physics simulations), or exclusions. It's a standalone statement with no 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?

No annotations are provided, so the description carries full burden. It implies a mutation ('Attach') but doesn't disclose behavioral traits such as permissions required, whether it modifies existing components, error conditions, or what the output schema contains. The prerequisite hint is useful but 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 extremely concise with two short sentences that are front-loaded and waste no words. Every part ('Attach dragonBones.ArmatureDisplay' and the prerequisite note) earns its place without redundancy.

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

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

Given the complexity (8 parameters, mutation tool), lack of annotations, 0% schema coverage, and presence of an output schema, the description is incomplete. It doesn't explain parameter meanings, behavioral implications, or what the output contains, leaving significant gaps for an AI agent to understand and invoke the tool correctly.

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

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

Schema description coverage is 0%, meaning none of the 8 parameters have descriptions in the schema. The tool description adds no information about what parameters like 'scene_path', 'node_id', or 'dragon_asset_uuid' mean or how to use them, failing to compensate for the lack of schema documentation.

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

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

The description clearly states the action ('Attach') and the resource ('dragonBones.ArmatureDisplay'), providing a specific purpose. It distinguishes from sibling 'cocos_add_dragonbones_data' by referencing it as a prerequisite, though it doesn't explicitly differentiate from other 'add' tools in the list.

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

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

The description provides explicit guidance to 'use cocos_add_dragonbones_data first', indicating a prerequisite and sequence. However, it doesn't specify when to use this tool versus alternatives like 'cocos_add_spine' or other animation-related siblings, nor does it mention 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 full burden. It mentions the return structure ({dragon_asset_uuid, dragon_atlas_uuid, textures, dir}), which is helpful, but doesn't disclose critical behavioral traits: whether this is a read or write operation (likely a write/mutation), what permissions are needed, whether it overwrites existing assets, error conditions, or side effects. For an import tool with zero annotation coverage, this leaves significant 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 appropriately concise with two sentences: one stating the purpose and one detailing the return structure. It's front-loaded with the core action. However, the second sentence could be integrated more smoothly, and there's room to add brief 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 the complexity (5 parameters, 0% schema coverage, no annotations, no output schema), the description is incomplete. It lacks explanations of parameter semantics, behavioral details like mutation effects or error handling, and doesn't clarify how this tool fits within the broader Cocos workflow. The return structure hint is helpful but insufficient for full understanding.

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

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

Schema description coverage is 0%, so the description must compensate for all 5 parameters. It only implicitly references parameters through the asset types mentioned (_ske.json, _tex.json, _tex.png), but doesn't explain what each parameter does, their relationships, or provide examples. The description adds minimal value beyond what the schema titles already indicate.

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 ('Import DragonBones assets') and specifies the resource types (_ske.json + _tex.json + _tex.png). It distinguishes from siblings like 'cocos_add_dragonbones' by focusing on data import rather than general DragonBones addition. However, it doesn't explicitly contrast with 'cocos_add_spine_data' which serves a similar purpose for different asset 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when not to use it, or how it relates to similar tools like 'cocos_add_spine_data' for Spine assets. The agent must infer usage from the tool name and description alone.

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

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

No annotations are provided, so the description carries full burden. It mentions input_mode values and max_length behavior, but doesn't disclose critical behavioral traits like whether this is a read/write operation, permission requirements, side effects, or error handling. For a tool that likely modifies a scene, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core action. Every part earns its place by explaining key parameters. It could be slightly more structured but avoids 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?

Given 6 parameters with 0% schema coverage and no annotations, the description partially compensates by explaining two parameters. An output schema exists, so return values needn't be explained. However, for a tool that likely modifies a Cocos scene, more context on behavior and usage is needed.

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

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

Schema description coverage is 0%, so the description must compensate. It explains input_mode values (0=ANY, 6=SINGLE_LINE) and max_length (-1=unlimited), adding meaningful semantics beyond the schema's titles. However, it doesn't cover other parameters like scene_path, node_id, placeholder, or return_type.

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

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

The description states the tool attaches a cc.EditBox component, which is a specific verb+resource combination. However, it doesn't distinguish this from sibling tools like cocos_add_button or cocos_add_label, which also attach UI components. The purpose is clear but lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or comparisons with other UI component tools in the sibling list. Usage is implied only through parameter explanations.

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 key behavioral traits: it generates a '.anim' clip in a default directory (with override option), attaches specific components ('cc.UIOpacity' and 'cc.Animation'), sets initial opacity to 0 to prevent flashing, and enables play_on_load. It also explains the effect of the 'delay' parameter. However, it does not cover error handling, permissions, or side effects like file overwrites, leaving some 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by implementation details and a return value summary. Every sentence adds value—explaining file generation, component attachment, parameter effects, and outputs—with zero waste. It is structured for quick comprehension.

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

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

Given the tool's complexity (5 parameters, no annotations, no output schema), the description is largely complete. It explains what the tool does, how it behaves, parameter roles, and return values. However, it lacks explicit error cases, prerequisites (e.g., node existence), or output schema details, which could be helpful for an agent. The return value description is provided, mitigating the absence of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It adds significant meaning: 'rel_dir' overrides the default 'assets/animations/' directory, 'delay' holds at 0 opacity before the ramp for staggering fades, and the tool implicitly uses 'scene_path' and 'node_id' to target a node. It also mentions 'duration' as part of the fade ramp. This clarifies all 5 parameters beyond their schema titles, fully compensating for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Fade a node from transparent → opaque at scene start.' It specifies the verb ('Fade'), resource ('a node'), and scope ('at scene start'), distinguishing it from siblings like 'cocos_add_scale_in' or 'cocos_add_slide_in' by focusing on opacity animation. This 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 provides clear context for usage: 'at scene start' and 'useful for staggering sibling fades.' It implies when to use it (for fade-in effects) but does not explicitly state when not to use it or name alternatives among the many sibling tools. The guidance is helpful but not exhaustive regarding 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 carries the full burden. It describes the tool's function but lacks critical behavioral details: it doesn't mention if this is a read-only or destructive operation, what permissions are needed, how errors are handled, or what the output looks like. The description adds minimal context beyond the basic action.

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

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

The description is extremely concise and front-loaded: the first sentence states the purpose, and subsequent lines provide essential parameter details. Every sentence earns its place with no wasted words, making it easy to scan and understand quickly.

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

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

Given the tool's complexity (12 parameters, no annotations, schema coverage 0%), the description is incomplete. It explains only 2 parameters and lacks behavioral context, prerequisites, or error handling. While an output schema exists, the description doesn't address the tool's overall role or integration, leaving significant gaps for an AI agent to infer 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?

Schema description coverage is 0%, so the description must compensate. It explains two parameters ('fill_type' and 'fill_range') with clear semantics and examples, covering 2 out of 12 parameters. This adds meaningful value beyond the schema, though it leaves most parameters undocumented. The baseline would be lower without this, so it scores above average for effort.

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 ('Attach cc.Sprite with type=FILLED') and the resource (a sprite component), with specific examples of use cases ('cooldown timer, radial progress'). It distinguishes itself from generic sprite tools by specifying the FILLED type, though it doesn't explicitly differentiate from sibling tools like 'cocos_add_sprite' or 'cocos_add_progress_bar'.

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 mentions example use cases but does not specify prerequisites, dependencies, or when to choose this over other sprite or UI tools in the sibling list, such as 'cocos_add_progress_bar' or 'cocos_add_sprite'.

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 for behavioral disclosure. It mentions the joint creates 'breakable structures' (implying some durability characteristic) and provides historical context about Box2D naming and deprecated tools. However, it doesn't describe what happens when the joint is attached (e.g., whether it modifies existing nodes, requires specific physics bodies, has performance implications, or what the output contains). For a physics tool with 11 parameters, this is insufficient 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 appropriately concise with three sentences that each add value: the core functionality, the Box2D naming context, and the historical replacement note. There's no wasted verbiage, and the information is front-loaded with the primary purpose. It could be slightly improved with clearer structure, but it's efficient overall.

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 (physics joint tool with 11 parameters), no annotations, and an output schema (which means return values are documented elsewhere), the description is incomplete. It explains what the tool does at a high level but provides no guidance on usage, no parameter semantics, and minimal behavioral context. For a tool that presumably modifies scene physics, this leaves significant gaps in understanding how to use it effectively.

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 none of the 11 parameters have descriptions in the schema. The tool description provides no information about any parameters—it doesn't explain what 'scene_path', 'node_id', 'anchor_x', 'frequency', or any other parameters mean or how they affect the joint creation. With 11 parameters (9 with defaults) and zero coverage, the description fails to compensate for the schema's deficiencies.

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: 'Attach cc.FixedJoint2D — rigidly fuses two bodies (breakable structures).' It provides a specific verb ('Attach') and resource ('cc.FixedJoint2D'), and explains the effect ('rigidly fuses two bodies'). However, it doesn't explicitly distinguish this joint type from other joint tools in the sibling list (e.g., distance_joint2d, hinge_joint2d, mouse_joint2d), which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions that it 'replaces the prior cocos_add_weld_joint2d', but this is historical context rather than practical usage advice. There's no indication of prerequisites, when this joint type is appropriate, or how it differs from other joint tools available in the system.

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 states this is for 'runtime vector drawing' which hints at a dynamic, non-destructive operation, but doesn't disclose permissions needed, side effects, error conditions, or what the output schema might contain. This is inadequate for a tool with mutation implications.

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

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

The description is a single, efficient sentence that front-loads the core purpose and includes a clarifying parenthetical. Every word earns its place with 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?

Given the tool has an output schema (which reduces need to describe returns) but zero annotation coverage and low schema description coverage, the description is minimally adequate. It covers the basic purpose but lacks details on parameters, behavioral traits, and usage context that would be needed for full understanding.

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 mentions 'node' and 'cc.Graphics' but doesn't explain what 'scene_path' or 'node_id' mean, their formats, or how they relate to the attachment process. The description adds minimal value beyond the schema's property 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 clearly states the action ('Attach') and resource ('a cc.Graphics to a node'), with additional context about its use ('for runtime vector drawing'). It distinguishes from siblings by specifying the graphics component, but doesn't explicitly differentiate from similar attachment tools like 'cocos_add_component'.

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 is provided. The description mentions 'runtime vector drawing' which implies a context, but doesn't specify prerequisites, alternatives, or exclusions compared to the many 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?

No annotations are provided, so the description carries full burden. It mentions 'Attach' which implies a mutation operation, but doesn't disclose critical behavioral traits like whether this requires specific permissions, if it's destructive to existing components, error conditions, or what the output contains. The description adds minimal context beyond the basic action.

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

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

The description is extremely concise (one sentence) and front-loaded with the core action. Every word earns its place by specifying the component type and providing illustrative examples without unnecessary elaboration.

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

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

Given the tool's complexity (14 parameters, physics joint creation), absence of annotations, and 0% schema coverage, the description is inadequate. While an output schema exists (which helps with return values), the description doesn't address the numerous parameters, behavioral implications, or usage context needed for effective tool 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?

With 0% schema description coverage and 14 parameters (only 2 required), the description provides no information about any parameters. It doesn't explain what 'scene_path', 'node_id', or any other parameters mean, their units, or how they interact. The description fails to compensate for the complete lack of schema documentation.

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

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

The description clearly states the verb ('Attach') and resource ('cc.HingeJoint2D'), and provides concrete examples of use cases ('door, wheel, pendulum'). It distinguishes itself from sibling tools by specifying a particular joint type (HingeJoint2D), though it doesn't explicitly contrast with other joint tools like 'cocos_add_distance_joint2d' or 'cocos_add_wheel_joint2d'.

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, prerequisites, or constraints. While the examples imply typical applications, there's no explicit mention of when this joint type is appropriate compared to other joint types available 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 provided, the description carries full burden. It describes what the tool creates (a HUD bar) and its positioning behavior (pinned to top/bottom), but doesn't disclose important behavioral traits like whether this is a read-only or mutating operation, what permissions are needed, error conditions, or how it interacts with the scene. The mention of default configuration adds some context, but key behavioral aspects remain undocumented.

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 efficiently structured with clear sections: purpose statement, items parameter details, default configuration, and side parameter explanation. Every sentence adds value with no wasted words. The technical details are presented in a readable format with appropriate line breaks and code formatting for the items structure.

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 annotations, no output schema), the description provides good coverage of the items parameter but leaves other parameters unexplained. It doesn't describe what the tool returns or how errors are handled. For a tool that presumably creates UI elements in a game engine context, more information about integration with the scene system would be helpful.

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 provides excellent semantic information for the 'items' parameter (detailing the structure of label and spacer objects with their properties) and explains the 'side' parameter options. However, it doesn't explain the purpose of 'scene_path', 'parent_node_id', or 'height' parameters, leaving 3 of 5 parameters without semantic clarification in the description.

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

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

The description clearly states the tool builds a horizontal HUD bar pinned to top or bottom, specifying the resource (HUD bar) and action (build). It distinguishes from siblings by focusing on HUD bar creation rather than other UI elements like buttons or labels. However, it doesn't explicitly contrast with similar layout tools like 'cocos_add_layout' or 'cocos_add_widget'.

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 creating HUD bars in games, mentioning 'good for endless-runner style games' as a default configuration. It provides some context about when the default configuration is appropriate but doesn't explicitly state when to use this tool versus alternatives like 'cocos_add_layout' or 'cocos_add_widget' for similar UI positioning tasks.

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 tool performs file copying and metadata writing (mutating operations), mentions the return value structure, and specifies the default directory and resource placement behavior. However, it doesn't address permissions, error conditions, or side effects 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 efficiently structured in three sentences: purpose statement, parameter guidance, and return value. Every sentence adds essential information with zero wasted words. It's appropriately sized for the tool's complexity.

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

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

For a mutation tool with no annotations and no output schema, the description does well by explaining the operation, parameter effects, and return structure. It covers the key aspects needed to use the tool correctly, though doesn't address potential errors or edge cases. The return value documentation partially compensates for the missing output schema.

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

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

With 0% schema description coverage for 4 parameters, the description compensates well by explaining the 'as_resource' parameter's purpose and effect (placement under assets/resources/ for runtime loading). It also implies 'rel_path' usage through the default path mention, though doesn't fully document all parameters like 'project_path' and 'src_png' semantics.

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

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

The description clearly states the specific action ('Copy a PNG into the project and write a complete sprite-frame meta'), identifies the resource (PNG file), and distinguishes from siblings by focusing on image/sprite-frame creation rather than scripts, animations, audio, or other asset types. It provides concrete details about the operation.

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

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

The description provides clear context about when to use the 'as_resource' parameter (for runtime loading via resources.load()), but doesn't explicitly state when to use this tool versus alternatives like 'cocos_add_sprite' or 'cocos_add_filled_sprite'. It gives practical guidance about the default behavior and the resource placement option.

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 some behavioral traits: it explains overflow modes (CLAMP truncates, SHRINK auto-shrinks font) and cache modes, and mentions theme dependency. However, it doesn't cover important aspects like whether this is a creation/mutation operation, what permissions might be needed, error conditions, or what the output contains.

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

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

The description is appropriately sized and front-loaded with the core functionality. The first sentence establishes the purpose, followed by parameter explanations and theme context. While dense with information, every sentence serves a clear purpose in explaining tool behavior and usage.

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 (19 parameters, 0% schema coverage) and the presence of an output schema (which handles return values), the description does a good job covering key aspects. It explains parameter semantics thoroughly and provides important context about theme dependencies. The main gap is lack of behavioral transparency about the operation's nature (creation vs. modification) and potential side effects.

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 for 19 parameters, the description compensates exceptionally well. It explains the semantics of 'overflow' and 'cache_mode' parameters with their numeric codes and behaviors, and provides detailed information about the three preset parameters (color_preset, size_preset, outline_color_preset) including examples and valid values. This adds substantial 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 starts with a specific verb ('Attach') and resource ('cc.Label'), clearly stating what the tool does. It distinguishes from siblings by focusing specifically on label creation/attachment, unlike other tools that add different UI components (buttons, sprites, etc.) or perform different operations (building, previewing).

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

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

The description provides clear context about when to use design-token presets versus explicit arguments, and mentions the prerequisite of setting a theme via 'cocos_set_ui_theme'. However, it doesn't explicitly state when NOT to use this tool or name specific alternatives among the many sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool attaches a layout but doesn't describe what that entails—whether it modifies existing nodes, requires specific permissions, has side effects, or how it interacts with the scene. For a mutation tool with 12 parameters, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose and provides key enum values for layout_type. It's front-loaded with the main action and avoids unnecessary words, though it could be slightly more structured (e.g., separating the enum explanation).

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 (12 parameters, mutation tool, no annotations, schema coverage 0%), the description is inadequate. It lacks details on parameter meanings, behavioral traits, output (though an output schema exists, the description doesn't hint at it), and usage context. For a tool with many parameters and no annotation support, more comprehensive guidance is needed.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description only explains 'layout_type' with enum values (0=NONE, etc.), adding minimal semantics for 1 of 12 parameters. It doesn't clarify the purpose of other parameters like spacing, padding, resize_mode, or directions, leaving most undocumented.

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

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

The description clearly states the action ('Attach') and resource ('cc.Layout'), specifying it attaches a layout component. It distinguishes from siblings by focusing on layout attachment rather than other component types like scripts or animations. However, it doesn't explicitly differentiate from other layout-related tools (none appear in the sibling list).

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or comparisons with other layout or UI tools. It only defines the tool's function without usage context.

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

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

With no annotations provided, the description carries the full burden. It effectively describes the tool's behavior: it creates a centered spinner with rotation animation, explains the rotation period meaning, and specifies the return value structure. It doesn't mention side effects, permissions, or rate limits, but provides substantial behavioral context for a UI creation tool.

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

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

The description is perfectly structured: first sentence states the core purpose, subsequent sentences explain key parameters, then provides a practical tip, and ends with return values. Every sentence adds value with zero waste, making it easy to scan and understand.

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

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

For a 6-parameter tool with no annotations and no output schema, the description provides excellent context about parameters, behavior, and return values. The main gap is lack of explicit error conditions or prerequisites, but it covers the essential usage scenario thoroughly.

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 for 6 parameters, the description compensates excellently. It explains sprite_frame_uuid's purpose (for rotation animation vs None for text-only), clarifies rotation_period meaning (full 360° revolution time), provides default context for text ('Loading...'), and gives practical guidance on generating the sprite asset.

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: it adds a centered rotating icon with optional caption (loading spinner). It distinguishes from siblings by specifying this is specifically for loading indicators, unlike general UI components like buttons or labels in the sibling list.

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

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

The description provides clear context on when to use this tool (for loading indicators) and includes a helpful tip on how to generate the required sprite asset. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many 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?

No annotations are provided, so the description carries the full burden. It describes the tool's behavior by detailing the menu structure (full-screen, vertical, with background, title, and buttons) and default button configuration, but lacks information on permissions, error handling, or side effects like scene modification impacts. The example flow adds practical context but does not fully cover behavioral traits.

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

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

The description is front-loaded with the core purpose, followed by specific details and a practical example. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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 UI-building tool with 6 parameters, no annotations, and no output schema, the description is fairly complete: it explains the tool's purpose, provides usage guidelines with an example, and covers parameter semantics partially. However, it lacks details on return values or error conditions, which would enhance completeness for this type of 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?

With 0% schema description coverage and 6 parameters, the description compensates by explaining key parameters: it mentions 'title' and 'buttons' in the example, implies 'scene_path' and 'parent_node_id' through the flow, and references button dimensions via 'button_width' and 'button_height' defaults. However, it does not detail all parameters (e.g., exact usage of 'scene_path'), leaving some gaps.

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

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

The description clearly states the tool's purpose: 'Build a full-screen vertical main menu: bg + title + stacked buttons.' It specifies the verb ('Build'), resource ('main menu'), and key components, distinguishing it from sibling tools like 'cocos_add_dialog_modal' by referencing it for button shape but focusing on a full-screen menu structure.

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

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

The description provides clear context for usage with a 'Typical flow' example, showing how to integrate it into a scene creation process and referencing sibling tools like 'cocos_create_scene' and 'cocos_set_ui_theme'. However, it does not explicitly state when not to use this tool or mention alternatives, such as other UI components from 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?

No annotations are provided, so the description carries the full burden. It mentions 'Attach cc.Mask' but doesn't disclose behavioral traits like whether this modifies an existing node, requires specific permissions, has side effects, or how it interacts with other components. The mask_type values add some context, but critical details like error handling or performance impacts are missing.

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

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

The description is brief and front-loaded with the main action, but it could be more structured. The single sentence efficiently states the tool's function and mask_type details, with no wasted words. However, it lacks separation of purpose from parameter info, slightly reducing clarity.

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 5 parameters with 0% schema coverage, no annotations, and an output schema (which isn't described), the description is incomplete. It doesn't explain the tool's role in the Cocos ecosystem, expected inputs beyond mask_type, or what the output might be. For a tool that likely modifies scene nodes, this leaves significant gaps for an AI agent.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains 'mask_type' with numeric codes (0-3), leaving 'scene_path', 'node_id', 'inverted', and 'segments' undocumented. The description adds minimal value beyond the schema, failing to clarify parameter meanings or usage, such as what 'segments' does for ellipse masks.

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

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

The description states the action ('Attach cc.Mask') and resource (mask), but is vague about the context—it doesn't specify what is being masked (e.g., a node in a scene) or how this differs from sibling tools like 'cocos_add_graphics' or 'cocos_add_sprite'. It provides mask_type values, but lacks a clear overall purpose statement.

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

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

No guidance is given on when to use this tool versus alternatives. The description lists mask_type options but doesn't explain their use cases or prerequisites. With many sibling tools for adding components, there's no indication of when masking is appropriate, such as for UI effects or visual clipping.

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 critical behavioral traits: the convex parameter requirement based on rigid body dynamics and backend limitations. However, it lacks details on permissions, error conditions, or what happens on attachment (e.g., overwriting existing colliders). The information is useful but incomplete 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 front-loaded with the core purpose, followed by important usage notes. It uses two concise sentences with no fluff, though the formatting with backticks and dashes could be slightly cleaner. Every sentence adds value, making it efficient.

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

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

Given 8 parameters with 0% schema coverage, no annotations, and an output schema (which alleviates need to describe returns), the description is incomplete. It covers the convex parameter well and provides critical physics context, but misses semantics for other parameters and broader behavioral details like error handling or side effects, leaving gaps for a complex tool.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains the 'convex' parameter's semantics and implications, ignoring the other 7 parameters (scene_path, node_id, mesh_uuid, center_x/y/z, is_trigger). This leaves most parameters undocumented, failing to adequately address the low schema coverage.

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

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

The description clearly states the action ('Attach cc.MeshCollider') and identifies the specific resource (a mesh collider component). It distinguishes from siblings like 'cocos_add_box_collider_3d' by specifying mesh-based collision. However, it doesn't explicitly contrast with all sibling collider tools, keeping it from a perfect score.

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

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

The description provides explicit usage guidance with 'IMPORTANT' notes on when to set convex=True (for DYNAMIC rigid bodies) vs convex=False (for static ground geometry). It directly addresses physics backend constraints (PhysX/Bullet) and differentiates based on body type, offering clear when-to-use criteria.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation ('Attach'), suggesting this modifies a scene node, but doesn't disclose behavioral traits like whether it requires specific permissions, if it's idempotent, what happens on failure, or the output format. The mention of default values for shadow_casting and shadow_receiving adds some context, but overall behavioral disclosure is minimal.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by parameter details. There's minimal waste, though the parameter explanations could be slightly more structured (e.g., bullet points). Every sentence adds value, making it efficient for an agent to parse.

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

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

Given 8 parameters with 0% schema coverage and no annotations, the description partially compensates by detailing 4 parameters. An output schema exists, so return values needn't be explained. However, as a mutation tool with many parameters, the description should ideally cover all parameters or at least the required ones (scene_path, node_id), and provide more behavioral context. It's minimally adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaningful semantics for 4 parameters (material_uuids, shadow_casting, shadow_receiving, reflection_probe_type), explaining their purposes, formats, and default values. However, it omits details for the other 4 parameters (scene_path, node_id, mesh_uuid, enable_morph), leaving them undocumented. The value added for the covered parameters is significant, but incomplete coverage prevents a perfect 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 purpose: 'Attach cc.MeshRenderer — renders a 3D mesh.' It specifies the verb ('attach'), resource ('cc.MeshRenderer'), and outcome ('renders a 3D mesh'). However, it doesn't explicitly differentiate from sibling tools like 'cocos_add_skinned_mesh_renderer', which appears to serve a similar purpose for skinned meshes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions a workaround for material_uuids ('Pass None to wire later via cocos_set_uuid_property'), but doesn't explain when to choose this tool over other rendering or component-adding tools in the sibling list. No prerequisites, exclusions, or contextual usage hints are given.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'Attach', implying a mutation that adds an effect to a node, but fails to disclose critical behavioral traits such as permissions needed, whether the effect is reversible, performance impact, or how it interacts with existing components. The example hints at visual behavior but lacks operational 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—just one sentence with an example—and front-loaded with the core action. Every word earns its place by stating the tool's purpose and providing illustrative context without any fluff or redundancy.

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

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

Given the complexity (8 parameters, mutation tool), lack of annotations, and 0% schema coverage, the description is incomplete. It doesn't explain parameters, behavioral implications, or output (though an output schema exists, reducing some burden). For a tool that likely modifies scene state, more detail on effects and usage is needed.

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

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

Schema description coverage is 0%, meaning none of the 8 parameters are documented in the schema. The description adds no information about parameters like 'scene_path', 'node_id', or the color/fade settings, leaving their purposes and formats completely unexplained. This fails to compensate for the schema gap, resulting in poor parameter understanding.

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

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

The description clearly states the action ('Attach') and the specific resource ('cc.MotionStreak'), with an illustrative example ('trail effect. For sword trails, shooting stars.') that helps visualize its use. However, it doesn't explicitly differentiate from sibling tools like 'cocos_add_animation' or 'cocos_add_particle_system_2d', which might also create visual effects, leaving some ambiguity in sibling distinction.

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

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

The description provides a general context ('trail effect') and examples ('sword trails, shooting stars'), which implies usage for dynamic visual trails. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., other visual effect tools in the sibling list), prerequisites, or any 'when-not-to-use' scenarios, resulting in minimal actionable guidance.

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