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

No annotations are provided, so the description carries the full burden. It discloses the read source (ROM at offset 0x5E90) but omits that the tool writes an output file (implied only by the output_path parameter), any failure modes, ROM validity requirements, or compute cost. For a tool that produces artifacts, the write side-effect should be 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?

A single well-formed sentence, verb first, with zero filler. Every word is informative, and the precise offset detail 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 single-purpose tool with 100% schema coverage this is mostly adequate, but it leaves gaps: no usage context among the torch_* family, no confirmation of the output format (only hinted by output_path's 'Output YAML file path'), and no prerequisites such as requiring a valid BK64 ROM.

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 applies. The description adds the domain detail 'offset 0x5E90' which enriches the ROM-source context, but it adds no parameter-specific semantics beyond what the schema already documents for rom_path, timeout_ms, torch_path, and output_path.

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

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

States a specific verb ('Generate'), a specific resource ('Banjo-Kazooie (BK64) baseline asset table hashes from a ROM at offset 0x5E90'), and a precise offset that removes ambiguity. The sibling tools (capabilities, validation, rendering, parsing, export/pack/import, diagnostics) are all clearly different in purpose, so no agent could confuse this with them.

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

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

The description offers no explicit when-to-use guidance, no exclusions, and names no alternative. Usage context is only implied by the tool's unique purpose among the torch_* siblings; there is no statement of the conditions that select this tool over any other.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verbs 'probe', 'inspect', 'detect', and 'review' strongly imply a read-only, non-destructive operation, which is conveyed. However, the description does not explicitly state the operation is safe/read-only, nor does it disclose failure behavior (e.g., what happens if torch_path is invalid or a subcommand is unsupported) or potential slowness from probing an external binary.

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 sentence front-loaded with the core action ('Probe Torch executable') followed by a compact list of distinct aspects. Efficient and free of waste, though packing four actions into one sentence slightly blurs each item's clarity. Every clause 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?

This is a moderately complex tool (8 subcommand enum values, external binary dependency) with no output schema and no annotations, so the description must carry more weight. It covers the 'what' but not the 'what you get back' — there is no indication of return format or how to interpret detected features/asset types. The cryptic enum values are also left unexplained. For a discovery tool, this is a notable gap.

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

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

Schema description coverage is 100%, so the baseline is 3. Both parameters are well-described in the schema (subcommand queries CLI11 help; torch_path overrides binary path), and the tool description reinforces the subcommand concept. However, the 8 enum values (otr, o2r, code, binary, header, pack, hashes, modding, ui) are cryptic abbreviations that neither the schema nor the description explains, leaving meaning for the agent to guess.

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 specific action verbs (Probe, inspect, detect, review) against a clear resource (Torch executable) and enumerates four distinct things it covers: CLI subcommands, compiled features, asset types, and upstream caveats. This clearly distinguishes it from all operational siblings (validate, render, export, import, pack, hash), which act on projects rather than introspect the binary itself. However, some specifics remain fuzzy — 'compiled features' and 'upstream caveats' are vague terms an agent can't fully act on.

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 usage context is implied rather than stated: as an introspection/discovery tool among purely operational siblings, it is naturally a precursor to the export/pack/import tools. But the description never explicitly says when to use it, when not to, or names an alternative (e.g., 'use torch_diagnose_binary for binary-level debugging'). The guidance is left to inference from sibling names.

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 transparency burden. 'Diagnose' suggests a read-only operation and 'get recommended workarounds' indicates a return value, but side effects, failure modes, and behavior when rom_path is omitted are not disclosed.

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

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

The description is a single sentence with no filler. The primary action and outcome are front-loaded, making it efficient and easy to parse.

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

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

The description is minimally adequate for basic invocation: it says what the tool does and the schema covers the optional parameter. However, with no output schema and no annotations, it omits output format, alternatives, and edge-case behavior that would make it 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?

The single parameter rom_path is fully documented in the schema with 100% coverage. The description adds no additional meaning about how rom_path affects the diagnosis or the recommended workarounds, so it lands at the high-coverage baseline.

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

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

The description names a specific action ('Diagnose the upstream "torch binary" subcommand bug') and a concrete outcome ('get recommended workarounds for extracting raw binary assets'). This distinguishes it from the sibling pack/export tools, though it never explicitly contrasts them. The use of 'upstream' is slightly jargon-heavy, preventing a 5.

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 intended context is implied: use this when encountering the upstream torch binary subcommand bug during raw-binary-asset extraction. However, there is no explicit when-not-to-use guidance and no mention of alternatives among the torch_* 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 provided, the description carries the full burden of behavioral disclosure dirty. It names the operation 'Extract' and the archive formats, but does not disclose side effects (e.g., writing debug files), external dependencies (the torch binary), or success/failure behavior. This is minimal for a tool that wraps an external process.

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

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

The description is a single clear, front-loaded sentence with no filler. Every word contributes to identifying the tool's core function and output formats.

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, two archive formats, and an external binary), this description is too sparse. It omits the need for a config.yml, the distinction between o2r and otr behavior beyond the schema enum, debug output, and the external Torch dependency. The schema covers parameter names but not the overall execution context.

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

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

Schema description coverage is 100%, so the schema already documents all 10 parameters. The description itself adds no parameter-level meaning beyond the general concept of extracting assets into archives; it does not compensate beyond that baseline.

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 ('Extract assets') and resource ('an N64 ROM') with explicit target formats (O2R and OTR). This clearly distinguishes it from likely sibling tools such as torch_pack_archive, which would more likely package already-extracted assets.

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

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

The description gives no guidance about when to choose this tool over alternatives like torch_pack_archive, torch_export_code, or torch_export_modding. It implies the general use case of extracting from a ROM, but does not state any exclusions, prerequisites, or recommended scenarios.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It says the tool 'exports' decompiled C code, implying filesystem output, but it does not state whether files are overwritten, where output goes, whether the ROM is modified, or what side effects occur. The 10-minute default timeout and optional custom torch path suggest heavier operations that are not disclosed.

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

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

The description is one concise sentence that front-loads the action and resource. It avoids fluff, but the phrase 'decompiled C source code representation' is slightly awkward and the description could be more readable without significant length increase.

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, no annotations, and no output schema, a one-sentence description is not enough context for reliable invocation. The schema describes parameter names, but the description does not explain operational details such as whether a config.yml is needed by default, where output lands, or what the tool returns or writes on success.

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 documents all parameters including 'single', 'srcdir', 'destdir', and 'torch_path'. The description adds no parameter-level meaning beyond the schema, which is acceptable at the baseline of 3.

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

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

The description names a specific action ('Export') and a specific resource ('decompiled C source code representation of N64 assets from a ROM'). 'C source code' differentiates it from sibling export tools like torch_export_headers and torch_export_archive, so an agent can identify what this tool produces without opening the schema.

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 intended use is implied: use this when you want decompiled C code for N64 assets from a ROM. However, the description gives no explicit when-not-to-use guidance, prerequisites, or references to alternative export tools, so the agent must infer context from the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Generate C headers' and does not mention that this likely invokes an external binary, writes files to destdir, may require a config.yml in srcdir, or what side effects or failure modes exist. This is a meaningful transparency gap for a tool that produces files.

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 one short sentence and is front-loaded with the core purpose. However, 'using Torch' is somewhat redundant with the tool name and context, and the sentence is too terse to carry operational guidance, though there is no filler or structural 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 six parameters, no output schema, and no annotations, the description is incomplete. It does not explain what output the agent should expect, whether destdir or srcdir are needed for typical use, or what happens during generation. An agent would need to inspect parameter names and infer workflows to call this 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 100%, so the baseline is 3 even without additional parameter details in the description. The description adds general purpose context but does not enrich the meaning of rom_path, destdir, srcdir, or timeout_ms beyond their schema descriptions.

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

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

The description states a specific action and resource: 'Generate C headers for assets from an N64 ROM using Torch.' This distinguishes it from sibling export tools like torch_export_archive or torch_export_modding by naming the artifact type (C headers) and source (N64 ROM). It is clear but does not elaborate on which assets or what the headers are used for.

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

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

There is no guidance on when to use this tool versus alternatives such as torch_export_code, torch_export_archive, or torch_export_modding. The description gives no context for selecting it, no prerequisites, and no exclusions. An agent must infer the use case entirely from the tool name and the single sentence.

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 disclosing behavior. It states that the tool 'Produces modding.yml manifest and editable raw or XML assets', which conveys the primary output and side effects (writes files). However, it does not mention potential overwrites, prerequisites like config.yml in srcdir, or whether the ROM is modified, leaving some behavioral ambiguity for an export/write operation.

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

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

Two sentences with no filler. The first sentence front-loads the action and method; the second lists concrete outputs. Every word contributes to understanding the tool, making it highly efficient.

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

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

With 6 parameters but 100% schema coverage and a clear description of outputs, the definition is nearly complete for an export tool. The main missing piece is explicit mention of prerequisites (e.g., config.yml in srcdir) and return behavior, but these are either in the schema or minor for this tool. Overall, an agent can invoke it correctly with the provided information.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal meaning by mentioning 'raw or XML assets', which hints at the xml parameter, but the schema already details each parameter including the xml switch. No additional semantic value beyond that is provided.

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 and resource: 'Export editable asset files from an N64 ROM using Torch modding export.' It further distinguishes itself from sibling export tools by naming the 'modding.yml manifest' and 'editable raw or XML assets' as outputs, which separates it from torch_export_archive, torch_export_code, and torch_export_headers.

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 clearly states the scenario: exporting editable assets via the Torch modding export. It implies when to use this tool (when moddable, editable assets are needed) but does not explicitly mention alternatives or exclusion conditions, such as 'use torch_export_archive for packed outputs'. This is clear context without explicit when-not guidance.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It indicates that assets are imported into build targets, which implies writes or modifications, but it does not disclose whether existing targets are overwritten, what files are affected, or any ROM/path requirements beyond the schema.

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

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

The description is a single sentence with no filler. It is front-loaded with the primary action and includes the most relevant path and target information, earning 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?

Given 7 parameters, no annotations, and no output schema, the description is too minimal. It conveys the core action but lacks side-effect disclosure, usage routing, and enough workflow context for an agent to invoke it confidently in a modding pipeline.

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 baseline is 3. The description adds the path relationship 'destdir/modding/modding.yml' and names the target modes, which maps to the mode enum, but it does not explain srcdir, destdir, rom_path, or other parameters beyond what the schema already states.

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

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

The description states a specific verb ('Import'), a specific resource path ('destdir/modding/modding.yml'), and the destination targets ('code, otr, o2r, or header'). This clearly identifies the tool's function and distinguishes it from siblings like torch_export_modding.

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 'back into' implies this is the reverse of an export operation and should be used after editing modding assets, but the description does not explicitly state when to use the tool versus alternatives, nor does it mention preconditions 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 the full burden and it does add one genuinely useful behavioral trait: no ROM or config.yml is required, which shapes an agent's expectation about prerequisites. However, it discloses nothing about side effects such as whether an existing target file is overwritten, whether the source folder is left untouched, or that it shells out to a torch binary (implied only by torch_path/timeout_ms params).

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 zero filler. The purpose is stated immediately and the key differentiator is included. It is efficient, though the one-sentence structure leaves no room for usage routing or behavioral caveats.

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

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

For a 6-parameter tool with no output schema and no annotations, the description covers the essential purpose but leans heavily on the schema for everything else. It adequately explains what the tool does and one distinguishing constraint, but an agent still cannot infer overwrite behavior, dependency on the torch binary, or error conditions without additional probing.

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 the baseline is 3. The description adds marginal meaning by framing 'folder' as 'a directory of prepared resource files' and referencing the O2R/OTR archive types that map to the format enum, but it does not explain the version uint16 format or the torch_path dependency 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 states a specific verb and resource ('Pack a directory of prepared resource files into an O2R or OTR archive') and adds a key scoping fact: it works without a ROM or config.yml. It does not explicitly name the closest sibling (torch_export_archive), but the 'without requiring a ROM or config.yml' clause effectively carves out its niche.

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 'without requiring a ROM or config.yml' implies when to prefer this tool (when those inputs are unavailable), but it never names alternatives like torch_export_archive, nor states when NOT to use it. Usage context is implied rather than explicit.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It implies a read-only operation (parse, inspect, summarize) but does not explicitly state it is non-destructive, nor does it mention error handling, side effects, or permission requirements. It does list the output content, which is useful, but lacks depth for a tool with no annotation support.

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 front-loads the action (Parse, inspect, and summarize) and the resource (Torch config.yml file), then efficiently lists the specific data elements. There is no filler or redundant information, making it 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 tool with one parameter and no output schema or annotations, the description lists what it displays but does not specify the return format or behavior on invalid config files. It also does not mention whether the operation has any side effects or prerequisites. While adequate for a simple parsing tool, it leaves gaps that an agent would need to infer.

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%, as the config_path parameter is fully described in the schema ('Path to config.yml file (or directory containing config.yml)'). The description adds no extra semantics about the parameter, so the baseline of 3 applies since the schema already handles it.

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 with specific verbs (Parse, inspect, and summarize) and identifies the exact resource (Torch config.yml file). It enumerates the specific content it processes (ROM SHA1s, game titles, asset paths, GBI microcodes, output maps, segment definitions), which distinguishes it from sibling tools like torch_validate_project or torch_export_archive.

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 when it is appropriate to choose this over torch_validate_project for validation or torch_export_* for conversion. There is no context about prerequisites or typical use cases, leaving the agent to infer.

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 carries the full burden for behavioral disclosure. It does disclose headless execution, the test-harness mechanism, and the output WAV format, which is helpful. However, it does not mention overwrite behavior, prerequisites, failure conditions, or any return value.

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 a clear 'Headless audio extraction:' label. Every phrase adds useful detail, with no filler or repetition.

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

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

With six parameters, no annotations, and no output schema, the description should cover more context. It defines the output artifact and headless behavior, but it omits what the tool returns on success and what project/configuration prerequisites are required, so it is adequate but not complete.

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

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

Schema description coverage is 100%, so all six parameters are already documented in the schema. The description does not add per-parameter meaning beyond aligning audio rendering with WAV output, so the baseline of 3 applies.

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

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

The description states a specific verb ('renders'), a resource ('sequence-driver audio assets'), and a concrete output ('16-bit PCM stereo 32kHz WAV files'). It also clarifies the headless execution mode, which distinguishes this tool from sibling export/import/config utilities.

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 'Headless audio extraction' implies this is the tool to use when audio must be rendered without a display window, but it gives no explicit when-to-use vs alternatives. No sibling tools are named and no exclusion conditions are provided.

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

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

The description lists the validation steps (SHA1 calculation, config parsing, permission verification, asset path checks) which provides a good sense of what happens, but it does not disclose whether the operation is read-only, what side effects occur (if any), or how failures are reported (exceptions, error codes, etc.). With no annotations provided, the description carries the full burden and only partially fulfills it.

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 primary purpose ('Pre-flight validation') and lists the key checks. It avoids fluff and is easy to parse, though it could be organized as a short list for even faster scanning.

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

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

The description gives an overview of what the tool does but omits essential runtime context: what the tool returns (e.g., a success/failure report, exit code), how to interpret results, and what happens on validation failure. There is no output schema and no mention of error behavior, so an agent cannot anticipate the tool's outcome beyond the general validation actions. For a validation tool, this is a significant gap.

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

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

All four parameters are fully described in the input schema (coverage 100%). The description adds only a high-level overview (e.g., mentions 'calculates ROM SHA1' for rom_path, 'parses config.yml' for srcdir) without providing extra constraints, formats, or interaction details. Since the schema already documents the parameters, the description adds minimal incremental value.

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

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

The description clearly identifies the tool as a validation step with a specific verb ('validate') and resource ('Torch project'). It enumerates concrete checks (ROM SHA1, config parsing, hash match, permissions, asset paths), which distinguishes it from siblings like torch_parse_config (which only parses config) and the export tools. An agent can immediately understand its role.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention that it should be run before exports or other operations, nor does it contrast with sibling tools. An agent would have to infer its placement from the name and sibling context.

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