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

With no annotations, the description carries the full burden. It explicitly states '只读，不写 Spine JSON' (read-only, does not write), which is a key behavioral trait for a tool that might be mistaken as a write operation. However, it does not mention error conditions or permissions.

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

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

The description is a single sentence that efficiently conveys purpose and key behavioral note. No unnecessary words.

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

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

Given the simple parameter (one optional enum) and no output schema, the description covers the key aspects: what is read, that it's read-only. It is sufficient for an agent to understand the tool's function.

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

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

Schema coverage is 100% with one optional enum parameter. The description does not add any meaning beyond the schema's description of 'clientType', so baseline of 3 is appropriate.

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

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

The description clearly states what the tool does: reads agent connection status, handshake, project rule detection, and configuration snippets. It explicitly says it is read-only and does not write Spine JSON, which distinguishes it from writing tools. The verb '读取' (reads) is specific.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives like 'spine_agent_ping'. It implies use for checking status and config, but lacks when-not-to-use or comparison with siblings.

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

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

With no annotations, the description discloses core behavior: non-destructive (only runtime handshake file, no Spine JSON) and integration with WinForms wizard. Adequate for a ping tool.

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

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

Three focused sentences, front-loaded with purpose, no wasted words. Very concise and well-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 simple handshake tool with no output schema and fully documented parameters, the description covers purpose, usage, and behavioral constraints completely.

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

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

Schema description coverage is 100%, so baseline 3. The description adds no extra parameter meaning beyond the schema, which is sufficient for these self-explanatory fields.

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

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

The description clearly states it is an agent connection handshake tool, distinguishes it from spine animation tools by noting it only writes a runtime handshake file, not Spine JSON.

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

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

It specifies when to use (after agent connects MCP) and the effect (WinForms shows green status). No explicit exclusions, but sibling tools are all animation-related, making usage context clear.

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

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

No annotations are present, so the description must fully disclose behavior. It mentions setting keyframes at the same time point but doesn't specify if existing keyframes are overwritten, what the curve parameter does, if the operation is reversible, or if it modifies the file immediately. The dryRun parameter hints at safety but is not explained.

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

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

The description is a single short sentence, which is concise but too brief for a tool with 9 parameters. It lacks structure or elaboration, making it insufficient despite being front-loaded.

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

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

Given no output schema, no annotations, and 9 parameters with many nested objects, the description is incomplete. It doesn't explain the return value, preconditions (e.g., file must be valid Spine JSON), or postconditions. The tool's complexity demands a more comprehensive description.

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

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

Schema description coverage is only 11% (only filePath has a description). The description adds little parameter context: it implies bones and slots are the targets, but doesn't explain their object structure, the meaning of curve, or the purpose of dryRun and expectedHash. The description fails to compensate 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 clearly states the tool batch-sets pose keyframes for multiple bones and slots at the same time point. It uses specific verbs and resources, distinguishing it from sibling tools like spine_set_bone_keyframe which set individual keyframes.

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

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

The description does not provide guidance on when to use this tool versus alternatives. For example, it doesn't mention that this tool is for batch operations at a single time point, while spine_apply_pose_sequence might be for sequences over time. No when-not-to-use or prerequisite information is given.

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

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

No annotations are provided, so the description must carry the full burden. It states 'create or overwrite', implying mutation, but does not disclose side effects such as potential data destruction, permissions required, or other behavioral traits like the role of the 'overwrite' parameter.

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

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

The description is a single sentence, which is concise, but it could be more structured (e.g., bullet points or separate clauses) to improve readability. It is adequately sized but not front-loaded with the most critical information.

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

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

Given the complexity of the tool (9 parameters, no output schema, mutation), the description is too brief. It lacks details on return values, parameter usage, and behavioral context, making it incomplete for an agent to fully understand the tool.

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

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

Schema description coverage is only 11%, and the description adds no meaning to parameters beyond the schema. The description does not explain the 'poses' structure or other parameters, failing to compensate for the low coverage.

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

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

The description clearly states that this tool creates or overwrites animations and batch writes pose timestamps, which is a specific action. However, it does not differentiate from the similarly named sibling tool 'spine_apply_pose_keyframes', so clarity is slightly reduced.

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 mentions suitability for reducing multiple writes, backups, and review calls, but lacks explicit guidance on when to use this tool versus alternatives, and no exclusions are given.

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

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

With no annotations, the description carries full burden. It only mentions default non-overwrite behavior but omits details on side effects, return values, or the effects of parameters like dryRun. Minimal transparency.

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

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

Two concise sentences that front-load the main purpose. No unnecessary words; every sentence adds value.

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

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

Given 7 parameters, no output schema, and no annotations, the description is too brief. It leaves critical gaps about behavior on existing targets, dry run semantics, and required permissions.

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

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

Schema description coverage is only 14%; the description does not explain individual parameters beyond the default overwrite. Parameters like sourceAnimation, targetAnimation, dryRun are left undocumented, adding little meaning.

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

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

The description clearly states the verb 'clone' and the resource 'existing animation', and distinguishes it from creating a new animation by specifying it as a 'template for editing'. It also notes the default non-overwrite behavior, adding specificity.

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

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

The description implies usage for creating an editable copy, but does not explicitly state when to use versus alternatives like spine_create_animation. No when-not-to-use or exclusion criteria are provided.

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

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

No annotations are present, so the description must fully disclose behavioral traits. It only states 'copy' without explaining side effects like overwriting existing keyframes, how conflicts are handled, or if changes are reversible. For a mutation tool with complex parameters, 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 sentence, making it concise. However, it lacks structure and fails to provide essential details needed for correct invocation. Conciseness is not prioritized over completeness.

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 (no output schema, no annotations, nested objects, 9 params), the description is incomplete. It does not explain return values, what happens on success/failure, or the behavior of optional parameters like dryRun or targets.

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

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

The input schema has 9 parameters, but only filePath has a description (11% coverage). The description adds no parameter information. The nested objects and enums are undocumented. With low schema coverage, the description should compensate but does not.

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

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

The description clearly states the verb 'copy' and the resource 'animation clip' (keyframe range) to another animation or same animation at a specified time. It is distinct from sibling tools like spine_clone_animation (entire animation) and spine_delete_keyframe_range. However, it does not explicitly differentiate from siblings in the description text.

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 guidelines are provided. The description does not mention when to use this tool versus alternatives, nor does it specify any prerequisites or constraints. The agent is left to infer usage from the name and schema 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 discloses only the default overwrite behavior. With no annotations provided, the description carries the full burden of behavioral disclosure, but it does not explain side effects like file modification, the effect of dryRun, expectedHash, or allowUnsupportedVersion parameters.

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

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

The description is very concise, consisting of two short sentences. It front-loads the main action and adds a behavioral note. However, it could be more structured to include parameter details.

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

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

Given the complexity of having 6 parameters with low schema coverage, no output schema, and being a mutation tool, the description is insufficient. It only addresses one behavioral aspect and fails to provide a complete understanding of the tool's behavior and parameters.

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

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

Schema coverage is only 17%, with only filePath having a schema description. The tool description does not explain the meaning or usage of the animation parameter, nor does it provide context for overwrite, dryRun, expectedHash, or allowUnsupportedVersion. This is insufficient for a 6-parameter tool.

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

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

The description clearly states the tool's purpose: creating a new empty animation. It differentiates from sibling tools like clone, delete, and get animations by using the specific verb 'create' and specifying 'empty animation.' The default behavior is also mentioned.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. No mention of prerequisites, when not to use it, or comparison with other tools like spine_clone_animation or spine_apply_pose_keyframes.

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

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

No annotations are provided, so the description must disclose behavior. It mentions high-risk nature and confirm requirement, but fails to detail side effects, irreversibility, or what happens during deletion. The description partially compensates but is insufficient for a destructive 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. No redundant information is present; 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 tool has 6 parameters, 3 required, and no output schema, the description is far too minimal. It does not describe return values, effects on the document, prerequisites, or post-conditions. A complete absence of context for a complex destructive operation.

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

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

Schema description coverage is only 17% (only filePath described). The description adds no parameter-level details beyond the confirm flag requirement. It does not clarify 'animation', 'dryRun', 'expectedHash', or 'allowUnsupportedVersion', leaving most parameters unexplained.

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

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

The description clearly states '删除动画' (Delete animation), which is a specific verb-resource pair. It distinguishes this tool from sibling tools like spine_create_animation or spine_clone_animation by implying destruction.

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 warns that this is a high-risk operation and requires confirm: true, but it does not provide guidance on when to use this tool versus alternatives (e.g., spine_delete_keyframe_range) or when not to use it. No explicit usage 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?

No annotations provided; description only mentions deletion and filtering but fails to disclose destructive nature, irreversibility, or behavior after deletion. DryRun parameter is not explained in the description.

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

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

Single concise sentence that front-loads the purpose. No unnecessary words, though it is in Chinese and may benefit from slight expansion for English 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?

With 7 parameters, nested objects, and no output schema, the description omits crucial details like return values, side effects, and how dryRun works. Incomplete for safe invocation.

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

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

Schema description coverage is low (14%); description adds meaning for the time range and filtering concepts, but does not elaborate on the structure of targets (e.g., targetType enums, names, timelines). Partially compensates.

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

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

The description clearly states it deletes keyframes in a time range with optional filtering by bone, slot, or draw order, distinguishing it from siblings like spine_remove_keyframe (single) and spine_copy_keyframe_range (copy).

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

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

No explicit guidance on when to use this tool versus alternatives like spine_remove_keyframe. The description implies its use for range deletion but lacks context for prioritization.

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

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

With no annotations, the description should disclose behavioral traits. It only states what is returned, but fails to mention that the tool is likely read-only, whether authentication is needed, or error handling (e.g., file not found). This is insufficient for safe invocation.

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

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

The description is a single concise sentence that conveys the core purpose. It could be more structured (e.g., listing output types), but there is no redundancy or clutter.

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

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

Given no output schema, the description should clarify the return format (e.g., is it a list or object?). It mentions 'statistics' but not the structure. Also lacking error conditions. Complete enough for basic understanding but not comprehensive for automated agents.

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

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

The input schema covers 100% of the parameter with a description. The tool description adds no additional meaning beyond the schema's own description, so the baseline of 3 is appropriate.

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

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

The description clearly states that the tool returns animation names, estimated durations, and timeline type statistics, which is a specific verb+resource. Among siblings like spine_get_animation_timelines and spine_get_animation_sheet, it distinguishes itself by focusing on high-level animation metadata.

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., when to use spine_get_animation_timelines instead). There is no mention of prerequisites or context for use.

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

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

No annotations provided, and the description does not disclose behavioral traits. It implies read-only ('get') but does not explicitly state side effects, permissions, or whether it modifies 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?

Single sentence conveys the main purpose and output fields. Efficient, though could be slightly more structured with separate usage notes.

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?

Lacks details on parameter values (only filePath described), output format details, and behavioral context. With 4 parameters and no output schema, the description is insufficient for an agent to use the tool confidently.

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

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

Schema description coverage is 25% (only filePath documented). The description adds context about output fields but not parameter meanings. Without output schema, the description partially compensates by listing return fields.

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

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

Description clearly states it returns a keyframe table for Agent editing, listing specific fields (target, timeline, time, value, curve, JSON path). While the verb '返回' is clear, it does not differentiate from sibling tools like spine_get_animation_timelines.

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

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

No guidance on when to use this tool versus alternatives. Does not mention prerequisites, required tools, or when not to use it.

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

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

With no annotations, the description carries full burden but only describes the output (timeline and summary). It does not disclose whether the operation is read-only, any side effects, permissions, or rate limits.

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

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

The description is a single concise sentence, but it omits important details and could be better structured to front-load key information.

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

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

The description is incomplete given no output schema and sparse annotations. It does not explain what 'original timeline' or 'normalized summary' entail, nor does it describe the return format or any constraints.

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

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

Schema coverage is low (25%). The description adds meaning for 'targetType' and 'targetName' by mentioning filtering, but does not clarify the 'animation' parameter or the 'filePath' beyond the schema's brief 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 returns the original timeline and normalized summary of a specified animation, with optional filtering by target type and name. This distinguishes it from sibling tools like spine_get_animations or spine_get_skeleton_hierarchy.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or exclusions.

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

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

The description does not explicitly state that the tool is read-only, and there are no annotations provided. However, the nature of 'get_document_summary' implies no destructive behavior. It could be improved by confirming no side effects.

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

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

The description is a single sentence that efficiently lists the output components. It could benefit from structured formatting but is not verbose.

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

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

While the description lists the outputs, it omits details about the return format, error conditions, and confirmation of read-only behavior. Given the absence of an output schema, more detail would be beneficial.

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

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

The single parameter filePath is already well-described in the schema. The tool description adds no further detail about its format or constraints beyond what the schema provides.

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

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

The description clearly states the tool returns Spine JSON version, file hash, top-level fields, counts, and V1 write permission, making its purpose specific and distinct from sibling tools that focus on animations, skins, etc.

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

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

No guidance is provided on when to use this tool versus alternatives like spine_get_animations or spine_validate_json. The agent receives no context about appropriate use cases or prerequisites.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states 'returns' indicating a read-only operation, but does not explicitly mention side-effect safety, required permissions, or rate limits. This is adequate but lacks full transparency.

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

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

The description is a single sentence that conveys the key purpose and content. It is front-loaded with the main action. Could be slightly more structured by listing items, but it is efficient and clear.

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

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

Given no parameters and no output schema, the description tells what the tool returns but does not detail the format or structure of the return value. For a tool that returns spec information, more detail about what the summary includes would be helpful. Adequate but not fully complete.

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

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

The tool has no parameters, so the baseline is 4. The description adds meaning by explaining what the tool returns, which compensates for the lack of parameters. No additional parameter information is needed.

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

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

The description clearly states the tool returns a summary of the official Spine JSON specification review, writable timeline rules, and 4.1.24 field adaptation instructions. It distinguishes itself from sibling tools like spine_get_document_summary, which returns a document summary, by specifying the content related to spec review and rules.

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 obtaining spec information, but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The context suggests it is for understanding specs, but no clear when/when-not instructions 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 full burden. It discloses the return of skeleton tree and optional transforms but omits details like whether it is read-only, any side effects, the format of the tree, or error conditions. For a tool with no annotations, 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?

Extremely concise: two clauses in one sentence. The main action '返回骨骼树' is front-loaded, with the optional behavior appended. Every word is necessary; no 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's simplicity (2 params, no output schema, no annotations), the description covers the basic functionality but lacks details about the return structure, error handling, or the meaning of 'skeleton tree' in terms of hierarchy. It is minimally adequate but not richly informative.

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 covers 50% (filePath has a description, includeSetupPose does not). The description adds meaning for includeSetupPose: '可选返回 setup pose 的局部变换' (optionally returns local transforms of setup pose), which clarifies the boolean's effect. This compensates for the missing schema 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 it returns the skeleton tree (骨骼树) and optionally the local transforms of the setup pose. The verb '返回' and resource '骨骼树' are specific. Among sibling tools like spine_get_slots or spine_get_skins, the purpose is distinct, though no explicit differentiation is provided.

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

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

No guidance on when to use this tool versus alternatives like spine_get_document_summary or other getters. There is no mention of prerequisites or context (e.g., filePath must exist). The description only states what it does, not when to choose 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 should disclose behavioral traits. It only states the output (names and summaries) but does not mention if the operation is read-only, destructive, or requires permissions. The behavior is inferred but not explicit.

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

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

The description is a single sentence with no redundant words. It is concise, though perhaps too minimal; it could benefit from slightly more context without becoming verbose.

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

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

Given no output schema and no annotations, the description provides the core purpose but lacks details on return format, error conditions, or usage context. For a two-parameter tool, it is minimally adequate but not comprehensive.

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

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

Schema description coverage is 50% (filePath has a description, includeAttachments does not). The description adds no additional meaning for parameters. includeAttachments is left unexplained beyond the default, which may confuse agents on what it controls.

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 returns skin names and attachment summaries, which is a specific purpose. It distinguishes from sibling tools like spine_get_slots or spine_get_skeleton_hierarchy by focusing on skins, though it does not explicitly differentiate from similar list tools.

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

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

No explicit guidelines on when to use or alternatives. The description implies usage for retrieving skin data, but lacks when-not or context for choosing over siblings.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It does not explicitly state that the operation is read-only or safe, nor does it mention any side effects or permissions. A brief clarification would improve transparency.

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

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

Single sentence, zero waste. Front-loaded with the key information about what is returned. Perfectly concise.

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

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

No output schema provided, so description should explain the return structure. It lists what fields are returned but not their format (e.g., array vs object). Lacks details on the exact structure, which could be important for an agent. Adequate but incomplete.

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

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

Schema coverage is 100% with a clear description for filePath. The tool description adds no additional meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns slot drawing order, bound bones, default attachments, and display properties. It is specific and distinguishes from sibling tools like spine_get_skeleton_hierarchy or spine_get_animations.

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

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

No explicit guidance on when to use this tool versus alternatives. The description only states what it returns, but the context of sibling tools provides implicit differentiation. Missing when-not-to-use or alternative suggestions.

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 explicitly states 'read-only, does not write JSON', which is a critical behavioral trait. It also mentions validation capability. However, it does not specify how validation results are returned (e.g., errors in output).

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

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

The description is a single, front-loaded sentence that efficiently covers resource, action, filtering, validation, and read-only nature. No redundant words.

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

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

For a list tool with two optional parameters and no output schema, the description covers purpose, filtering, validation, and safety (read-only). It lacks details about the output format (e.g., file names, timestamps), but is otherwise complete.

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

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

Schema coverage is 100%, so baseline is 3. The description paraphrases the schema (filter by filePath, includeValidation) without adding new semantics or constraints beyond what the schema provides.

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

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

The description clearly states the tool lists Spine JSON backups from backups/, with optional filtering by target filePath and validation. It distinguishes from siblings like spine_restore_backup (restore) and spine_validate_json (validate arbitrary JSON).

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 listing backups, but does not explicitly state when to use this tool versus alternatives like spine_restore_backup or spine_validate_json. No guidance on 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 must carry full behavioral disclosure. It only states that keyframes are copied, without mentioning whether existing keyframes at targetTime are overwritten, the role of dryRun, or any side effects. The default dryRun behavior is not explained, which could mislead an agent into thinking the tool is destructive.

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

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

The description is a single sentence, making it concise. However, it omits critical details that would aid an agent, such as parameter explanations and behavioral notes. It earns points for brevity but loses some for not being front-loaded with essential information.

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

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

Given the tool's complexity (8 parameters, no output schema, no annotations), the description is insufficient. It does not explain common workflows, the meaning of the nested targets parameter, or the return value. The agent would lack context to use the tool correctly.

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

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

Schema description coverage is 13% (only filePath has a description). The description mentions sourceTime and targetTime but adds no format or constraints. Parameters like targets, dryRun, expectedHash, and allowUnsupportedVersion are entirely unexplained. The description does not compensate 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 clearly states the action (copy keyframes from sourceTime to targetTime) and the specific purpose (closing the beginning and end of a loop animation). This distinguishes it from general copy tools like spine_copy_keyframe_range.

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

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

The description implies usage for loop animation closure but provides no explicit guidance on when to use this tool versus alternatives like spine_copy_keyframe_range. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It says 'adjust' but does not disclose whether changes are destructive, requires permissions, or what happens on failure. The dryRun parameter is not mentioned, which is critical for understanding test 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 short (two sentences) and front-loaded with purpose. However, it could include more context without being verbose, such as mentioning the dryRun parameter or the supported timeline types.

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

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

With 10 parameters, nested objects, no output schema, and low schema coverage, the description is severely incomplete. It does not explain the role of each parameter, the meaning of offset/scale for different timeline types, or the effect of dryRun. The tool is complex but the description is minimal.

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

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

Schema description coverage is only 10%. The description only mentions offset and scale, but does not elaborate on filePath, animation, bones, timeline, range, dryRun, or other parameters. The agent receives little extra meaning beyond the schema.

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

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

The description clearly states it batch adjusts bone timeline values with offset or scaling. It uses specific verbs ('批量调整', '增加偏移或按比例缩放') and distinguishes from sibling tools focused on individual keyframe operations or different aspects of animation editing.

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

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

No guidance on when to use this tool versus alternatives like spine_scale_keyframe_times or spine_shift_keyframes. The description does not mention prerequisites, nor does it indicate cases where this tool is inappropriate.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses the tool is read-only and does not write JSON, which is the key behavioral trait. However, it does not detail what happens on failure (e.g., error handling) or whether any state is modified.

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

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

The description is extremely concise (two sentences) and front-loaded. Every word adds value without redundancy. It efficiently communicates the tool's purpose and key behavioral constraint.

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

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

For a simple existence-check tool with no output schema, the description covers the essential purpose and read-only nature. It could mention return type or status messages for missing assets, but the description is largely complete given the tool's complexity.

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

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

Schema coverage is 100% with each parameter having a complete description. The tool description adds overall context but does not provide additional parameter-level meaning beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool checks for the existence of JSON, atlas, and atlas reference textures required for preview, and confirms target animation existence. It explicitly states it is read-only. The name 'spine_preview_check_assets' aligns perfectly with this purpose, and the tool is distinct from siblings.

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

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

The description implies usage for checking assets before preview but does not explicitly state when to use this tool versus alternatives like spine_preview_get_config or other preview tools. No context or exclusions are provided, so usage is only implied.

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

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

No annotations are provided, so the description carries the full burden. It reveals that the tool clears session state and restores defaults without affecting Spine JSON, which is valuable behavioral context. However, it does not disclose potential side effects, permissions, or rate limits.

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

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

The description is two sentences long, front-loading the action and providing essential clarification. Every sentence adds value 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 has no parameters, no annotations, and no output schema, the description is largely complete. It explains the action and its scope (only session state). However, it could mention what the return value or outcome is, though not required.

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

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

The tool has no parameters, and schema coverage is 100% (since there are no parameters). The description adds no parameter information beyond the schema, which is baseline appropriate for a parameterless tool.

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

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

The description clearly states the tool clears the current preview session state and restores default JSON, atlas, and animation. It explicitly distinguishes itself from siblings like spine_preview_set_session and spine_preview_get_session by noting it only writes session state and does not modify Spine JSON.

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 the tool is used to reset the preview session, but it does not provide explicit guidance on when to use it versus alternatives, such as when to use spine_preview_set_session instead. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states read-only behavior, which is good. However, it does not disclose whether the tool makes network requests, requires authentication, or has any side effects beyond fetching data. Some behavioral transparency is present but not comprehensive.

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

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

The description is two concise sentences with no filler. It front-loads the main purpose and adds the read-only note efficiently. Every word contributes value.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description provides a high-level list of return contents (default config, runtime version, URL parameters). This is largely sufficient, though more detail on the return structure would improve completeness.

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

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

Schema coverage is 100% with a single optional parameter 'baseUrl' that includes a default description. The description does not add any additional meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states that the tool returns default config, official runtime version, and URL parameter descriptions for the browser preview layer. It explicitly notes read-only behavior ('只读，不写入 JSON'), distinguishing it from sibling tools that modify or create content.

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 context through its read-only declaration, but does not explicitly state when to use this tool versus alternatives. However, among sibling tools, this is uniquely focused on retrieving preview configuration, so the context is clear enough for an agent to infer appropriate usage.

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

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

No annotations are provided, so the description carries the full burden. It correctly identifies the tool as read-only, but it does not disclose error conditions (e.g., no active session), authentication requirements, or side effects. Adequate but not thorough.

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 only two sentences, no fluff. Every word adds value, clearly stating the action and its read-only nature.

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

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

For a simple read tool with one optional parameter and no output schema, the description is nearly complete. It covers purpose and behavior. Missing information about what happens on failure (e.g., no session) but overall sufficient given low complexity.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds nothing beyond the schema for the single optional parameter 'baseUrl'. The purpose of the parameter is already clear from its schema 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?

Description clearly states the tool reads the Agent-driven preview session state and returns the preview URL. It explicitly says it is read-only and does not write JSON, which distinguishes it from write tools like spine_preview_set_session and spine_preview_clear_session.

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 reading session state, but it does not explicitly state when to use this tool versus alternatives like spine_preview_get_url or when not to use it. No preconditions or exclusions are given.

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

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

Description explicitly states read-only and no JSON writes, but lacks details on URL expiry, authentication needs, or performance considerations. Moderate coverage given no annotations.

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

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

Two concise sentences, front-loaded with primary action and read-only note. No redundant information.

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

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

For a URL generator with 9 parameters and no output schema, the description covers core functionality and key options. Minor omission of speed parameter explanation, but adequate for differentiation among siblings.

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

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

Description lists 7 of 9 parameters (filePath, atlasPath, animation, skin, PMA, mipmaps, autoload) adding meaning beyond schema, but misses speed and baseUrl. Schema coverage is low (33%), so description partially compensates.

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 generates a browser preview URL for Spine assets, specifying supported options. It distinguishes from sibling editing tools by emphasizing read-only URL generation.

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

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

No explicit when-to-use or when-not-to-use guidance. The read-only hint implies safe usage, but no comparison to alternatives like spine_preview_check_assets or other preview 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. It discloses that the tool only writes session state and does not write Spine JSON, and explains the effect on preview layers. However, it lacks details on side effects, error behavior, or required authentication, making it moderately transparent.

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

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

The description is concise, consisting of three short sentences that clearly state the purpose, effect, and limitation. Every sentence adds value without redundancy, 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 the tool's complexity (10 parameters, nested objects, no output schema), the description is minimal. It does not explain return values, success criteria, or provide usage examples. Compared to sibling tools with similar complexity, this description lacks completeness for an agent 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?

The input schema has 10 parameters with only 40% coverage (4 described). The description does not add meaning beyond the schema; it only provides a general purpose statement. For example, parameters like animation, skin, speed, etc., have no additional context in the description, leaving the agent with limited guidance.

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

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

The description clearly states the tool's purpose: setting an Agent-driven preview session state with specific resources (JSON, atlas, animation, operation instructions). It explicitly distinguishes from write operations by stating '只写会话状态，不写 Spine JSON', differentiating from sibling tools like spine_preview_clear_session and spine_preview_get_session.

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 context (updating preview session without writing files) but does not provide explicit when-to-use or when-not-to-use guidance. Sibling tools exist for clearing and getting sessions, but no direct comparison or exclusion criteria are mentioned.

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

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

With no annotations, the description bears full burden but only states 'delete keyframes' without disclosing side effects, permission requirements, or the role of the dryRun parameter. The behavior is implied but not explicitly detailed.

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

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

The description is a single short sentence with no unnecessary words, which is concise. However, it sacrifices completeness for brevity, omitting important context and parameter details.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is grossly inadequate. It does not cover return values, error handling, or the purpose of dryRun and expectedHash, leaving the agent with insufficient information to use the tool correctly.

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

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

Schema description coverage is only 11%, yet the description adds no information about parameters like targetType, timeline, time, dryRun, etc. It fails to compensate for the lack of schema descriptions, leaving most parameters unexplained.

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

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

The description clearly states the action (delete keyframes), the target types (bone, slot, drawOrder), and the method (by time). However, it does not differentiate from sibling tools like spine_delete_keyframe_range which deletes a range of keyframes, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as spine_delete_keyframe_range or spine_shift_keyframes. It lacks context about prerequisites or preferred use cases.

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

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

With no annotations provided, the description carries full burden. It discloses high-risk nature, required confirm flag, default dryRun, and backup of current target before actual restore. Additional details like exact overwrite behavior or error conditions would improve transparency.

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

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

The description is a single, efficient sentence that front-loads the main purpose and critical behavioral constraints. Every phrase earns its place: high risk, confirm requirement, dryRun default, and backup before restore.

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, no output schema, and no annotations, the description covers the main workflow, risk, defaults, and safety measure (backup). It does not detail error handling or expected return values, but for a restore tool, the core behavior is well-explained.

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

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

Schema description coverage is 80% (missing dryRun description). The description compensates by stating dryRun defaults to true, and clarifies confirm must be true. This adds value beyond the schema, especially for the required confirm and default dryRun.

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 (restore backup to target JSON file) and resource (backups/ directory and target file). It distinguishes from sibling tools like spine_list_backups (listing) and spine_validate_json (validating) by specifying it's a restore operation with high risk and default dry run.

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

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

The description implies usage when restoring from a backup, with explicit notes that confirm must be true and dryRun defaults to true. It does not explicitly state when not to use it or provide alternative tools, but the context of sibling tools makes the purpose clear.

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

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

The description explicitly states it is read-only and does not write JSON, which provides clear behavioral transparency. Without annotations, this is valuable. However, it does not mention other potential side effects or requirements.

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

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

The description is two sentences, concise and front-loaded with the core purpose and behavioral trait. Every sentence adds value without extraneous information.

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

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

The description covers the main purpose and read-only nature, but lacks information about the output (e.g., return format or error handling). With no output schema and 5 optional parameters, additional context about what the tool returns would improve completeness.

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

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

Schema description coverage is 100%, so the schema already explains each parameter. The tool's description does not add additional semantics beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description clearly states it uses the official spine-core runtime to verify if resources can be loaded by the current 4.1 runtime, distinguishing it from sibling tools like spine_validate_json which likely validate JSON syntax. The read-only nature is explicitly mentioned.

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 it is for checking runtime compatibility, but does not provide explicit guidance on when to use this tool versus alternatives like spine_validate_json or spine_run_validation_pipeline. No when-not-to-use instructions.

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

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

With no annotations, description must fully disclose behavior; it states read-only and lists steps but omits return values, side effects (e.g., does preview URL persist?), permissions, or error behavior, leaving significant gaps for a 10-parameter 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?

Single sentence front-loads purpose and key actions without wasted words, but could benefit from separation of concerns (e.g., listing outputs) for improved 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?

No output schema and no explanation of return value or state changes; the tool combines multiple validations and URL generation, yet description lacks details on how results are conveyed, making it insufficient for correct invocation decisions.

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 covers all 10 parameters with descriptions, achieving 100% coverage, so description adds no extra meaning beyond listing the validation steps, which do not directly map to parameter use.

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

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

Description explicitly states it executes a read-only validation pipeline including structure validation, runtime loading validation, and preview URL generation, clearly distinguishing it from sibling tools like spine_validate_json or spine_runtime_validate by combining multiple checks into one process.

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?

Indicates usage 'after writing' and describes it as a recommended post-write process, but does not explicitly list when not to use or compare to alternatives, though context from sibling names implies differentiation.

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

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

With no annotations, the description carries full burden for behavioral disclosure, but it only mentions compress/stretch. It does not explain whether the operation is destructive, how it affects keyframes outside the specified range, or what permissions are needed.

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

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

The description is a single sentence with no wasted words, making it concise. However, it lacks structure and omits critical parameter explanations, slightly reducing its effectiveness.

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 (9 parameters, nested objects, no output schema), the description is severely incomplete. It fails to explain the effect on the timeline, the role of each parameter, or the outcome, leaving the agent poorly informed.

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

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

Schema description coverage is only 11% (only filePath has a description). The tool description does not explain any of the 9 parameters, such as range, originTime, scale, targets, or dryRun, despite the schema's lack of 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 it compresses or stretches keyframe times around an originTime, which is a specific action. However, it does not differentiate from sibling tools like spine_shift_keyframes or spine_copy_keyframe_range, which could also alter keyframe timing.

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

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

No guidance is provided on when to use this tool versus alternatives such as shifting or copying keyframes. The description lacks any context about prerequisites, typical use cases, or exclusions.

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

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

With no annotations, the description carries full burden but fails to disclose key behaviors such as whether existing keyframes are overwritten or merged, side effects on other keyframes, or any authorization requirements. The minimal description leaves significant ambiguity.

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

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

The description is a single concise sentence in Chinese, which efficiently conveys the core action. However, it lacks structure such as bullet points or separation of key aspects, and is too brief for a tool with 10 parameters.

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

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

Given the tool's complexity (10 parameters, no output schema, no annotations), the description is insufficient. It does not explain return values, the dryRun mode, error handling, or the expectedHash parameter, leaving many usability 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 only 10%, yet the description adds no parameter-level details beyond the tool's general purpose. Parameters like timeline, value, curve, dryRun, and expectedHash are not explained in the description, failing to compensate for the sparse 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 explicitly states the tool inserts or updates rotate/translate/scale/shear keyframes for existing bones in existing animations, clearly identifying the verb and resource. It distinguishes from sibling tools like spine_apply_pose_keyframes, which apply poses rather than individual keyframe manipulation.

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. Prerequisites (e.g., animation and bone must exist) are implied but not stated, and no exclusion or when-not-to-use information is given.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as whether the operation is destructive, requires authentication, or has side effects. The presence of a dryRun parameter suggests a safety mechanism, but this is not mentioned in the description.

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

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

The description is a single sentence and front-loaded, but it sacrifices completeness for brevity. It could be considered concise, but the lack of detail reduces its utility.

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 output schema, no annotations), the description is too brief. It does not cover return values, error behavior, or constraints, leaving significant gaps for the agent.

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

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

The schema description coverage is only 14% (only filePath described). The description does not explain any parameters, including the critical offsets array, leaving the agent to infer structure from the schema alone.

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

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

The description clearly states the tool's action (insert/update draw order keyframes) and specifies the mechanism (using official draw order offsets structure). It distinguishes from sibling tools that handle other keyframe types like bone or slot attachment.

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 does not mention prerequisites, scenarios, or exclusions, leaving the agent without context for selection.

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

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

Without annotations, description carries full burden. It discloses that attachmentName null hides attachment, but does not explain overwrite behavior, file modification, or other side effects.

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

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

Two sentences are concise and front-loaded. No unnecessary words.

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

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

With 8 parameters, 5 required, no output schema, and no annotations, the description is severely lacking. Key behavioral details and parameter semantics are missing, making it incomplete for safe 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?

Only filePath has schema description; description adds meaning for attachmentName (null hide) but leaves other critical parameters like animation, slot, time, dryRun, expectedHash unexplained. Schema coverage is 13%.

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

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

The description clearly states it inserts or updates a slot attachment keyframe, with a specific verb and resource. It distinguishes from siblings implicitly by being a slot attachment operation among many spine tools.

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

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

No guidelines on when to use this tool vs alternatives. Does not mention prerequisites, effects on existing keyframes, or when not to use.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as whether shifting is destructive, how out-of-range keyframes are handled, or the role of dryRun and expectedHash. Only the basic operation is stated.

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

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

The description is a single concise sentence in Chinese, front-loading the core action. It is efficient but could be slightly expanded for clarity without harming 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 8 parameters with nested objects, no output schema, and low schema coverage, the description is incomplete. It lacks details on return values, error conditions, or how the shift operation precisely works.

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

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

Schema description coverage is only 13% (only filePath has a description). The tool description does not add meaning to parameters like deltaTime, targets, or dryRun, leaving their semantics unclear.

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

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

The description clearly states it moves keyframes overall forward/backward within specified animation, time range, and target filter. It is a specific verb+resource but does not differentiate from sibling keyframe tools like spine_copy_keyframe_range or spine_scale_keyframe_times.

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 shifting keyframes in time but provides no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or when-not contexts.

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

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

No annotations exist, so the description must disclose behavior. It only lists validation areas but omits side effects, return value, error handling, or whether it is read-only.

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

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

Extremely concise single sentence covering multiple aspects. No fluff, but could be slightly more informative without adding length.

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

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

Despite being a validation tool with no output schema, the description fails to mention output format (e.g., success/error list) or typical usage. Incomplete for an AI agent to correctly interpret results.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema's parameter description, which is adequate.

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

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

The description explicitly lists the validation aspects: structure, version, references, keyframe ordering, and slot attachments. It clearly distinguishes from sibling tools like spine_runtime_validate and spine_run_validation_pipeline.

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 siblings, no prerequisites or context for invocation provided.

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