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

With no annotations, the description carries the full burden and does disclose real behavior: it validates target names, curve generation, frame alignment, handoffs, and loop seams, implying invalid specs are rejected. However it doesn't say whether it mutates runtime_json in place, whether it is idempotent, or what a validation failure looks like, which matters for a tool writing out_json.

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?

Purpose is front-loaded in the first sentence and the remaining sentences add workflow, spec shape, and validation behavior. Slightly dense and mixes imperative instructions with descriptive facts, but no sentence is filler.

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

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

For a 3-required-param mutation tool with no annotations and no output schema, the description covers the spec payload and validation behavior reasonably but omits the meaning of the two file-path parameters and any hint about the result written to out_json. Adequate but with clear gaps.

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

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

Schema coverage is 0% for three required params, so the description must compensate. It partially does by describing the motion_spec contents (fps, clips, optional handoffs, bone/slot keys), which is genuinely beyond the generic 'object' schema, but runtime_json and out_json are never explained, leaving two of three parameters undocumented.

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

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

States a specific verb and artifact ('Compile an explicit numeric motion spec into a Spine skeleton'), which is enough for an agent to distinguish it from validate_motion or rig_and_animate. It identifies the input artifact and the output target, though it never explicitly names the sibling it must not be confused with.

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

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

Gives workflow placement ('Inspect the source/project first ... then call this tool'), which implies the prerequisite inspect_source step and clarifies the ordering relative to other tools. It stops short of explicit when-not-to-use conditions or naming alternatives like validate_motion for an already-built spec.

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

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

With no annotations, the description carries the full burden, and it does disclose the key behavioral contract: blank/static previews are rejected and motion/duration/occupancy are compared. It does not state what the result of a failed audit looks like, whether it mutates or blocks any state, or any permission requirements, so significant gaps remain.

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

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

A single front-loaded sentence with the reject condition first and the comparison second; no filler. It is slightly dense and could have used a clause to route against siblings, but every word earns its place.

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

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

For a two-parameter validation tool with no output schema and no annotations, the description covers the core purpose and the optional reference reasonably well. It leaves the failure/output behavior and the required parameter's format undocumented, which is the main missing piece.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that the reference GIF is an optional 'art-direction reference', which explains the reference_gif parameter and its empty default, but it says nothing about the required preview_gif or expected format beyond naming the checks.

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

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

States a specific action ('reject blank/static previews') on a specific resource (the preview GIF) and enumerates the checks it performs: duration, motion, occupancy. An agent can tell this is a preview-quality gate, though it doesn't explicitly contrast itself with the nearby validate_motion / validate_output 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 phrase 'before a delivery is accepted' implies usage timing, so an agent can infer this is a final gate step. However, no alternatives are named and there is no guidance on when to prefer this over validate_output, preview, or validate_motion, which is a real gap given how many similar siblings exist.

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

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

The description mentions the return value but does not disclose potential side effects (e.g., file modification, overwriting, required permissions) nor any behavioral traits beyond the basic action. With no annotations, this transparency gap is significant.

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

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

The description is concise (two sentences), well-structured, and free of unnecessary details. It efficiently communicates the core functionality without padding.

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 action and return, but lacks details about the two unexplained parameters, potential prerequisites, error conditions, or how the output summaries are structured. This leaves some gaps, though it is not overly complex.

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

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

The description explains two parameters (roster_dir and out_root) by referencing them in the action, but leaves kind and make_editable unexplained. Since the schema provides no descriptions, the description only partially compensates for the missing parameter semantics.

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

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

The description clearly states the tool's action ('Rig every PhotoshopToSpine export subfolder under roster_dir into out_root/<name>/') and its output ('Returns per-character summaries'), providing a specific and unambiguous purpose.

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

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

The description gives no indication of when to use this tool over alternatives, lacks prerequisites or conditions, and does not mention any specific use cases or limitations.

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

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

With no annotations, the description carries the full burden, and it does disclose real behavior: the ordered pipeline, that export/Spine save happens only when Spine is installed, and that a rig_report.json artifact is written. However, it says nothing about overwrite semantics for out_dir, permissions/auth, runtime or failure behavior for a heavy multi-stage mutation.

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

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

Two tightly packed sentences with the full-pipeline scope front-loaded and the rig_only special case last. Dense but every clause corresponds to a distinct stage of the operation; nothing is redundant.

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

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

For a 14-parameter, no-annotation, no-output-schema tool, the description covers scope and the output artifact but leaves most parameter semantics, overwrite/permission behavior, and failure handling unaddressed. It is minimally viable rather than complete.

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

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

Schema description coverage is 0% across 14 parameters, so the description is the only source of parameter meaning. It does map several parameters to pipeline steps (animate→animations, mesh/weight→auto_weight/clean_mesh, preview→make_preview, and explicitly rig_only, ik, clipping), but source, out_dir, name, source_group, fx_presets, and slot_presets remain undefined.

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

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

The description uses a specific verb ('Run the complete production workflow') and enumerates the resource stages (rig, animate, mesh/weight, IK, clipping, save/export, preview, report). It implicitly distinguishes itself as the end-to-end pipeline versus siblings like rig_and_animate or apply_motion_spec, but never names an alternative explicitly.

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

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

Usage is only implied: 'complete production workflow' suggests running this when you want everything in one pass, and 'Set rig_only for a zero-animation rig' gives one conditional branch. There is no explicit when-to-use vs when-not-to-use guidance relative to rig_and_animate, apply_motion_spec, or the individual step tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention side effects (e.g., file overwrites), required permissions, or what happens to existing files. The agent cannot infer whether this is a safe read-only operation or a mutating export.

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 immediately conveys the action and key choices. It uses no filler and efficiently communicates the core purpose and format options.

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 sparse for a tool with no annotations and no output schema. It does not mention side effects (e.g., writing files, overwriting), required permissions, or what constitutes a successful result. The '+pack for atlas' hint touches on related functionality but doesn't clarify dependencies or edge cases.

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

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

The description explains the 'fmt' parameter with 'json|binary' and '+pack for atlas', adding meaning beyond the schema's default. It does not elaborate on 'project' or 'out_dir', but these are fairly self-explanatory from their names. Given 0% schema coverage, the description partially compensates but could be more explicit about all parameters.

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

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

The description clearly states the action ('Export a .spine project') and the resource (runtime files), with format options. This distinguishes it from siblings like pack_atlas and project_info, making its purpose unambiguous.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. It implies usage for generating runtime files but lacks context about prerequisites, scenarios, or boundaries with sibling tools like pack_atlas or preview.

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 behavioral burden. It usefully discloses that this is a non-destructive inspection ('WITHOUT building anything'), but adds nothing about permissions, side effects, or output format.

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

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

Two tight sentences with no waste; the capstone constraint (no building) and the sequencing advice are both front-loaded and easy to scan.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description should do more. It conveys what gets listed and when to call it, but leaves source_group and the return shape unexplained.

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

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

Schema coverage is 0%, so the description must compensate, yet it only indirectly clarifies 'source' (accepts a .psd file or an export folder) and says nothing about 'source_group' or its default. The second parameter is effectively undocumented.

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

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

States a specific verb (list) and resource (parts and detected head-state families) and scopes it to .psd or PhotoshopToSpine export folders. Distinguishes itself from build-oriented siblings via 'WITHOUT building anything', though it doesn't name the specific alternative tool.

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?

'Use this first to confirm what will be rigged' gives clear sequencing guidance and an implied alternative (build/rig later). It stops short of explicitly naming rig_and_animate or build_workflow as the follow-up.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the import/creation nature but omits critical details such as overwrite behavior, required permissions, return values, and what 'EDITABLE' implies for the output project.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the core action without redundancy.

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

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

For a tool with only two string parameters and no output schema, the description should clarify expected return behavior and side effects. It does not state whether the output file is created, overwritten, or what happens on failure, making it incomplete for confident invocation.

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

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

The schema provides no parameter descriptions (0% coverage), and the description only loosely maps runtime_json to 'runtime skeleton json' and out_spine to '.spine project'. It does not clarify formats, constraints, or provide examples, leaving agents to guess parameter semantics.

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

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

The description clearly states a specific action: importing a runtime skeleton json into an editable .spine project. This distinguishes it from siblings like export_project and pack_atlas, which perform different operations.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description only states what it does, without mentioning prerequisites, exclusions, or a preferred context, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not mention any side effects, whether output files are overwritten, prerequisites, or the nature of the operation beyond 'pack.' This lack of detail is insufficient for an agent to anticipate consequences.

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

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

The description is a single, concise sentence that front-loads the core action and output. It contains no redundant or unnecessary information.

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

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

Given that there is no output schema and no annotations, the description provides a minimal but adequate overview for a simple tool. It states the output files (.atlas and .png) but omits behavioral details like overwriting or directory creation, making it only partially complete for an agent to safely invoke.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (images_dir, out_dir, name). While parameter names are somewhat self-explanatory, the description adds no explicit meaning beyond the schema titles, leaving the agent to infer semantics from context.

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

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

The description clearly states the tool's function: 'Pack a folder of PNGs into <name>.atlas + <name>.png with the Spine packer.' It uses a specific verb (pack) and resource (folder of PNGs → atlas + png), distinguishing it from sibling tools like export_project or batch.

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

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

Usage context is implied by the action ('Pack a folder of PNGs') but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusion criteria. The description does not mention when it is appropriate or inappropriate 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?

There are no annotations, and the description does not disclose side effects such as file creation (the output PNG) or whether it modifies existing rig data. It simply says 'Render a PNG' without stating if it is read-only or if it overwrites files, leaving behavioral 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 concise and uses a clear list format for parameters, avoiding unnecessary verbosity. It efficiently conveys the tool's purpose and parameter meanings, though the formatting with backticks and angle brackets is slightly cryptic.

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

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

The description covers the tool's core function and provides parameter defaults, but lacks a complete picture. It does not mention what the tool returns (e.g., the output path) and omits maxpx, so a user might be uncertain about the full input/output contract.

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

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

The description explains three of four parameters (rig_dir, images_dir, out_png) with useful defaults and context, but omits any explanation for maxpx. Since the schema has no parameter descriptions, this partial coverage leaves a gap in understanding the maxpx parameter's meaning or units.

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 renders a keyframe-montage PNG of a built rig with specific poses (idle/win/blink/pop), making its primary function clear. It also distinguishes itself from sibling tools like pack_atlas or export_project by focusing on preview 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?

The description provides no explicit guidance on when to use this tool versus alternatives. It implies it is for previewing a built rig but does not mention prerequisites, sequencing, or scenarios where other tools would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Print' suggests a read-only operation, but the description does not state whether it reads from the file system, what the output format is, whether it has any side effects, or what error conditions may occur. The existence of an output schema is not reflected in the description, leaving the agent without a clear understanding of what to expect on success.

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 immediately identifies the tool's action and target. It contains no filler, is front-loaded with the purpose, and does not repeat information already available in the schema or tool name. Every word contributes to the tool's understanding.

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

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

For a one-parameter tool with a structured output schema, the description is nearly adequate—it states what the tool produces and its input domain. However, it lacks clarification on the parameter's exact form (path vs. content) and offers no guidance against sibling tools like inspect_source. These gaps make the description minimally complete but not fully self-sufficient.

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

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

With 0% schema description coverage, the description must compensate for the parameter's meaning. It clarifies that 'project_or_json' refers to a '.spine project or skeleton .json', which adds some semantic value beyond the bare schema. However, it does not specify whether the parameter accepts a file path, file contents, or a URL, so the agent still has to guess the exact expected input format.

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

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

The description uses a specific verb+resource pattern: 'Print bones/slots/animations' identifies the exact output content, and it specifies the input scoping to '.spine project or skeleton .json'. This clearly distinguishes it from the sibling tools like pack_atlas or export_project, though it does not explicitly name an alternative for comparison.

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 for inspecting the structural components of a Spine project or skeleton JSON, but it offers no explicit guidance on when to choose this tool over siblings like inspect_source or preview. There are no stated prerequisites or exclusions, so usage context is left entirely to the agent's inference.

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

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

With no annotations, the description carries the full burden, and it does add real context: make_editable requires the Spine CLI, kind is reserved with both values rigging identically, and a summary with file paths is returned. However, it is silent on the behavior of the seven undocumented flags (ik, clipping, clean_mesh, auto_weight, fx_presets, slot_presets, source_group), so key mutation traits remain opaque.

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

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

The one-line purpose is front-loaded, followed by a clean aligned parameter list that is easy to scan. Padding is minimal, though the choice to document only a subset of parameters leaves the list structurally incomplete.

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 13-parameter mutation tool with no annotations and no output schema, the description covers only 6 parameters and omits all seven of the optional flags an agent would need to reason about. It does compensate for the missing output schema by summarizing the return value, but the parameter gaps are too large for the tool's complexity.

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

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

Schema coverage is 0%, so the description must compensate, and it partially does: it explains source formats, the out_dir layout, name defaulting, anims defaults, and the make_editable side effect. But 7 of 13 parameters receive no explanation at all, leaving more than half the surface undocumented.

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

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

The opening line states a concrete verb (build), the transformation (rig + animate), and the precise artifact (a Spine skeleton) from a defined input (a cut-up character). This distinguishes it clearly from siblings like pack_atlas, make_project, and export_project, which operate on different artifacts and stages.

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

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

Usage is implied rather than stated: the source is described as a .psd or PhotoshopToSpine export folder, which signals the required precondition, but there is no explicit when-to-use guidance and no named alternative among the many workflow siblings (build_workflow, make_project). The agent must infer when this step belongs in a pipeline.

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?

There are no annotations, so the description must fully disclose behavioral traits. It only states the action (report availability) without mentioning whether it is read-only, whether it has side effects, what it does if dependencies are missing, or any potential errors. The description is minimal and leaves many behavioral aspects unstated.

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 tool's function without any fluff. Every word contributes to clarity, and it is front-loaded with the action verb 'Report' immediately.

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

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

Given the low complexity of a no-parameter doctor check, the description is adequate but incomplete. It does not specify what 'availability' entails (e.g., version checks, path requirements) or what the output format is (e.g., boolean, message). Without an output schema or annotations, the description could be more explicit about the return value and any caveats.

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

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

The tool has zero parameters, and the schema is fully covered by the absence of properties. Per the rule, a baseline of 4 applies for zero-parameter tools. The description adds no parameter information, but since there are no parameters, there is nothing to clarify beyond the schema.

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

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

The description clearly states the tool's purpose: it reports on the availability of the Spine CLI and Python dependencies. This is a specific verb ('report') and resource, and it effectively distinguishes itself from sibling tools that handle project operations like packing, exporting, or previewing.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, such as running this before other tools, or conditions under which it should be called. The name 'doctor' implies a health check, but without explicit context, an agent may not know when to invoke it.

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

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

With no annotations, the description carries the full behavioral burden, and it does not state whether the tool is read-only, whether it mutates the authored clips, what it returns, or how errors are surfaced. 'Audit' implies a non-destructive read, but that is inference, not disclosure.

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

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

A single tight sentence with the detection scope front-loaded and no filler. The terseness is efficient rather than padded, though it errs toward under-specification given the zero param coverage.

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 3-param validation tool with no annotations, no output schema, and 0% schema coverage, the description omits the return shape, error format, and the role of runtime_json. An agent knows what it detects but not enough to call it confidently.

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

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

Schema description coverage is 0% across three parameters, so the description is the only source of meaning. It loosely echoes 'clips' and 'handoff' from the parameter list, but the required runtime_json (presumably the bulk of the payload) is entirely unexplained, as are the expected shapes of clips and handoffs.

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

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

States a specific verb ('Audit') and resource ('authored clips') and enumerates the error classes checked (frame-grid, curve, handoff, loop-seam), which tells an agent exactly what the tool detects. It never distinguishes itself from siblings like validate_output, audit_preview, or spine_doctor, which sound like overlapping validation 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?

There is no statement of when to reach for this tool versus validate_output or audit_preview, and no prerequisites or exclusions. The agent must infer the trigger condition from the sibling name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It never states whether validation is read-only, what it returns on failure (errors list? boolean?), whether it throws or reports, or what happens when atlas/texture are empty strings. For a no-annotation tool this is a substantial gap.

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

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

A single efficient sentence with no filler and the scope front-loaded. It is concise, though its brevity edges toward under-specification for a validation tool.

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

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

For a 3-parameter tool with no annotations, no output schema, and 0% schema coverage, the description leaves the required runtime_json undocumented and says nothing about the shape of validation results. An agent can guess the intent but not how to call or interpret it reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions atlas and texture as validated targets, which loosely maps to two of the three parameters, but the required parameter runtime_json is never explained and no parameter formats or default-empty-string behavior are described.

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

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

States a specific verb ('Validate') and resource ('references') and enumerates the reference kinds checked (bone, slot, skin, IK, atlas, texture, animation), which is more than a tautology. However, it does not distinguish itself from the closely-named sibling validate_motion or from spine_doctor, so an agent cannot tell which validator to pick from the description alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as validate_motion or spine_doctor. The agent is left to infer that this belongs in a build/export validation step.

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