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

With no annotations provided, the description carries the behavioral burden. It transparently discloses the key side effect: 'The newly added backdrop becomes the one shown.' It does not detail edge cases like list ordering or failure behavior, but it covers the important visible outcome.

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 with the action, options, and side effect front-loaded. Every sentence adds useful information with no 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-optional-param tool with no output schema, the description covers what can be added, where it applies, and what happens when added. It could mention naming behavior for file imports, but the schema's 'name' description already covers that.

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 some value by enumerating built-in names and implying file-vs-built-in exclusivity, but it does not explain parameter combinations or conflicts in depth.

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 clear verb and resource: 'Adds a stage backdrop,' with explicit sub-cases (built-in or file). It also distinguishes this from sibling tools like add_costume or add_sprite by anchoring to the stage and the visible result.

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 clear context: use this to add a stage backdrop, either built-in or from a file. It does not explicitly name alternative tools or exclusions, but the stage-backdrop framing makes the intended use obvious.

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, but it only restates the action and the two input sources. It does not mention any side effects, permissions, error handling, or return behavior. The description is essentially a rephrasing of the title with no added behavioral depth.

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

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

The description is a single concise sentence that front-loads the core action and quickly clarifies the two input sources. Every word contributes; there is no redundant or filler content.

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

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

The tool has four parameters and no output schema, but the operation is simple. The description, combined with the schema, conveys the essential inputs. However, it does not address potential edge cases like what happens if the sprite doesn't exist, whether costumes are appended or replaced, or any file path constraints. These gaps are minor for a straightforward add operation but prevent a higher score.

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 already provides descriptions for all four parameters (file, name, target, costume) with clear meanings, so the description does not need to add much. The description's mention of 'built-in shape or an image file' maps to the costume and file parameters, but it adds no new semantics beyond what the schema covers. Baseline of 3 is appropriate given 100% 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 (adds another costume) and the target (existing sprite), and specifies two sources: built-in shape or image file. This distinguishes it from siblings like add_sprite or add_backdrop by focusing on costumes and the existing-sprite constraint.

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 by stating 'existing sprite', which suggests the tool is not for creating sprites, but it does not explicitly mention alternatives or when not to use it. There is no guidance on when to prefer this over add_backdrop or add_sprite, though the existing-sprite wording offers some context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the compilation behavior and hat attachment, but it does not mention whether an existing script is replaced, whether the target must already exist, or what the tool returns.

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 with a compact, high-value example that demonstrates the DSL shape. It front-loads the main purpose and ends with actionable reference guidance, with no redundant or filler content.

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

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

Given the moderately complex JSON DSL, the description adequately covers the core invocation with an example and directs the agent to dsl_reference for exhaustive syntax. It does not describe return values or side effects, but the pointer to the reference tool fills the main knowledge 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. The description's example adds a practical illustration of the do array and when field, but it does not provide semantic detail beyond what the schema already documents.

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 plus resource: it compiles a JSON action list into Scratch blocks and attaches them under a hat block. This clearly distinguishes add_script from sibling tools like add_sprite or add_costume, and the example concretely illustrates the intended operation.

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

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

The description gives useful routing guidance by telling the agent to call dsl_reference for every available action, expression, and hat. It does not explicitly state when not to use add_script or contrast it with clear_scripts, but the core usage context is clear.

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

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

No annotations are provided, so the description carries the burden. It discloses accepted file formats (.wav) and built-in sound names, which is useful. However, it does not mention that adding a sound might overwrite an existing sound with the same name, or state any effects on the project (e.g., the sound is added but not automatically attached to a script).

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 with no waste. It front-loads the primary action and then lists built-in options. It is appropriately sized for a simple 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?

Given the tool's simplicity (4 params, no output schema, no annotations), the description covers the essentials: what it does, target, and file format. However, it omits potential pitfalls (e.g., mandatory file or sound? What if both are provided? Does it replace existing sounds?) that an agent would need to avoid errors.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds a small extra: the file format requirement, which is not explicit in the schema (though schema says 'Path to a .wav file', so it's redundant). The description doesn't clarify parameter interactions (e.g., 'sound' vs 'file' are mutually exclusive?), which could be ambiguous.

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 ('Adds') and the resource ('a sound to a sprite or the stage'), and mentions the target defaults to the stage. It lists built-in sounds and file requirements, distinguishing it from siblings like add_speech and add_costume, though not explicitly naming 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?

It implies usage by indicating built-in sounds vs. file loading, and the target parameter's semantics are clear. However, it does not explicitly state when to choose this tool over alternatives like add_speech or add_backdrop, nor does it provide exclusions or prerequisites (e.g., project must 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?

With no annotations, the description carries the full burden. It discloses the side effect (attaches the sound to a sprite), the return values (duration and mouth-loop repeat count), and the offline/no-network requirement. It also gives a behavioral tip about playback sequencing. It does not mention reversibility or permissions, but these are minor for a TTS 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 three sentences, each earning its place: purpose, behavior/return, and a usage tip. It is front-loaded with the core action, contains no redundant phrasing, and is easily scannable.

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 purpose, behavior, return values, and even a usage tip, which is quite complete for a tool with 7 parameters and no output schema. It lacks explicit error conditions or prerequisites, but for a creative TTS tool these are not essential. The offline/no-network note and the sprite attachment are sufficient 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 seven parameters. The description does not add parameter-level meaning beyond what the schema provides, though it does mention the return value context (mouth-loop repeat count) which relates to how the parameters are used. This matches the baseline for high 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 states a specific action: 'Synthesizes speech with the machine's offline text-to-speech engine and attaches it to a sprite as a Scratch sound'. It clearly distinguishes this from add_sound (which likely handles existing audio files) and list_voices, making the 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 provides a clear usage tip for the generated sound ('Use {"play_sound": name} (not play_sound_until_done) before the mouth loop'), but it does not explicitly state when to choose add_speech over alternatives like add_sound. The offline/no-file characteristic implies a distinction, but it is not articulated as a comparison.

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 burden. It adds useful context like the list of built-in costumes and the tinting syntax ('ball:red'), which are not fully in the schema. However, it omits any disclosure of side effects (e.g., name conflicts, project state changes) or prerequisites beyond what is obvious. For a simple additive tool, this is 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 two sentences with zero fluff. It front-loads the core action and costume list, then provides the tinting example, then the alternative. Every word earns its place, making it highly 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?

Despite having 9 parameters and no annotations, the description covers the primary use case (built-in costumes) and the key alternative (file-based import). Parameters like coordinates, size, and rotation are adequately documented in the schema, so the description doesn't need to repeat them. However, it doesn't mention any constraints like name uniqueness or project state, which is a minor gap for a mutation tool. Overall, it's complete for typical usage.

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

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

Schema coverage is 78%, so baseline is 3. The description adds meaningful detail for the 'costume' parameter by enumerating the built-in options and providing the tinting format, which goes beyond the schema's generic description. It also clarifies when to use the 'file' parameter by referencing import_character. This enhancement warrants a 4.

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

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

The description clearly states the action ('Adds a sprite'), specifies the resource ('built-in costume'), lists the available costumes, and mentions optional tinting. It also explicitly contrasts with the sibling tool import_character for file-based art, making the purpose unambiguous and distinct.

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 provides an explicit when-not directive ('To use character art from a file, use import_character instead'), which directly guides tool selection. This is a clear alternative condition, satisfying the requirement for usage 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 supplied, so the description carries the full burden of behavioral disclosure. It clearly states the destructive effect (deleting all blocks) and what is preserved (costumes and sounds), which is useful beyond the tool's name. It does not mention reversibility or error behavior, but that is a minor gap for such a simple destructive action.

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

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

The description is one concise sentence, front-loads the primary action, and immediately clarifies what is not affected. There is no filler or redundant elaboration.

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

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

For a single-parameter tool with no output schema and no annotations, the description is nearly complete: it defines the target, the destructive action, and the preserved elements. It could add a note on reversibility or success response, but these are minor omissions given the tool's simplicity.

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 already fully describes the only parameter, target, as 'Sprite name, or "Stage"' (100% coverage). The description adds little parameter-specific meaning beyond restating that the action applies to a sprite or the stage, so the 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 states a specific action ('Deletes all blocks') and an explicit resource ('a sprite or the stage'), and it distinguishes the scope by preserving costumes and sounds. This clearly separates it from sibling tools like remove_sprite, which removes an entire sprite.

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 clear context for when to use the tool: when you want to clear all scripts from a target while keeping its costumes and sounds. It does not explicitly name alternatives or state when not to use it, but the preservation clause makes the intended usage unambiguous.

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 explicitly reveals the destructive side effect ('Replaces any project currently open') and provides detailed input format for backdrops, including the special syntax for solid colors. This is transparent and covers the main behavioral traits an agent needs to know before invoking the 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 two sentences with no fluff. It front-loads the core purpose, then the critical side effect, then the backdrop options. Every sentence serves a purpose: the first defines the action and scope, the second warns of replacement, and the third provides input constraints. Highly efficient 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?

Given the tool's simplicity (2 parameters, 1 required, no output schema), the description covers everything needed to call it correctly. It explains the effect (fresh project, replaces current), the backdrop options and syntax, and the side effect. No critical information is missing, and the description is fully sufficient for an agent to invoke the tool correctly without ambiguity.

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 both parameters are already described in the schema. The description adds value for the 'backdrop' parameter by listing valid built-in options and explaining the 'solid:#223344' format for custom flat colors, which goes beyond the schema's generic description. For 'name', it adds no extra meaning beyond the schema, but the added backdrop detail justifies a score above the baseline 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 clearly states the tool's function with a specific verb and resource: 'Starts a fresh project in memory and sets its backdrop.' It also explicitly notes the destructive nature ('Replaces any project currently open'), which distinguishes it from sibling tools like add_backdrop that only modify the backdrop without resetting the project. The description differentiates from siblings by its core action of creating a new project rather than incrementally modifying one.

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 by stating it 'Starts a fresh project' and 'Replaces any project currently open', which signals it should be used when a clean slate is needed. However, it does not explicitly name alternative tools like add_backdrop for scenarios where only the backdrop should change, nor does it provide explicit 'when not to use' guidance. The context is clear but lacks explicit exclusions.

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

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

With no annotations provided, the description carries the full burden. 'Returns' implies a non-mutating lookup, and the description specifies the content scope, but it does not disclose response format, potential size, or that no side effects occur. This is adequate but not rich for an unannotated 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?

Two sentences with no fluff. The primary return value is front-loaded, and the timing hint ('Read this before writing scripts') 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 simple reference tool with one optional enum parameter, this is almost complete: it states what is returned and when to use it. It lacks an explicit note about the response format, but the low complexity and schema coverage mitigate that 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% (the 'topic' parameter is documented with enums and a default). The description adds no parameter-specific meaning, 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 uses a specific verb ('Returns') and resource ('full list of hat blocks, actions, expressions and built-in assets understood by add_script'). It clearly distinguishes itself from sibling action tools by positioning this as a reference for the DSL used by add_script.

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 instruction 'Read this before writing scripts' provides clear, explicit context for when to call this tool (before using add_script). It does not explicitly name alternatives or exclusions, but the reference vs. action distinction among siblings makes the intended usage unambiguous.

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 discloses the key behaviors: background removal, margin trimming, scaling, and optional talk-frame generation. It does not mention failure modes, project prerequisites, or whether an existing sprite is overwritten, but the main transformation behavior is clearly surfaced.

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 starts with the core action and follows with relevant processing details. Every clause informs the agent's mental model, and the talk-frame explanation is concise and useful rather than 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 tool with 10 parameters, no annotations, and no output schema, the description covers the main transformation pipeline well but leaves x and y entirely unexplained, and they are also among the parameters without schema descriptions. The absence of any usage context, prerequisites, or return-value expectations leaves a noticeable gap for correct invocation.

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

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

Schema coverage is 80%, so baseline is 3, but the description adds genuine meaning by explaining why parameters like remove_background, feather, tolerance, max_pixels, and talk_frames exist. It connects these parameters to the underlying processing pipeline, going beyond raw 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 verb and resource,

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 by focusing on turning a jpg/png character picture into a sprite, but it never explicitly says when to prefer this over siblings like add_sprite or add_costume, nor does it provide when-not-to-use guidance. The intended use case is inferable but not stated directly.

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 behavioral disclosure burden. It clearly indicates this is a read-only lookup ('Shows'), specifies the fields returned, and adds a useful caveat about per-machine availability. It could go slightly further by stating there are no side effects, but it is already transparent for a list 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?

Two sentences carry all necessary information, with the core purpose front-loaded and the practical usage note following immediately. There is no filler or redundant phrasing.

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 zero-parameter list tool with no output schema, the description is complete: it states what is listed, what fields are included, and how the result should be used relative to add_speech. An agent has everything needed to call it correctly.

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

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

The input schema has zero parameters and 100% schema description coverage, so there is nothing for the description to explain. Per the baseline for zero-parameter tools, no parameter semantics are needed.

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

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

The description uses a specific verb ('Shows') and names the exact resource: every offline text-to-speech voice installed on this machine. It also lists the returned attributes (gender, locale, engine), clearly distinguishing this discovery tool from the sibling add_speech.

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 explicit guidance to check this tool before using add_speech for a particular voice, because availability differs per machine. It names the relevant sibling and establishes the when-to-use context, though it does not formally list exclusion 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, the description carries the full behavioral burden. It does disclose that the tool starts a localhost server, returns a link, and avoids saving. However, it is silent on whether the project is modified, how long the server or link remains valid, and what happens if the preview fails.

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, tightly written sentence that front-loads the core action and output. There is no filler, and every phrase adds useful 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 low-complexity tool with two optional, fully documented parameters and no output schema, the core behavior and return value are stated clearly. Peripheral details like link lifetime or server teardown are omitted, but they are not essential for invoking 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 coverage is 100%, with both 'open' and 'editor' having clear descriptions in the schema. The description adds no additional parameter-level detail, 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 names the specific resource ('project'), the action ('serves,' 'returns'), and the delivery mechanism ('TurboWarp link'), and distinguishes itself from save_project by noting it happens 'without saving a file first.' It is clear and specific, though it does not explicitly name a sibling alternative.

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 saving a file first' implies use for quick previews rather than persistence, but there is no explicit guidance on when to choose this tool over save_project or create_project. The usage context is implied rather than clearly stated.

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

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

With no annotations, the description carries the behavioral burden. 'Lists' makes the read-only nature apparent and the open-project scope is stated. However, it does not disclose what happens if no project is open or how the listed items are returned (names, IDs, full definitions), leaving those behavioral details unspecified.

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 tight sentence with no filler. The verb and key resource types are front-loaded, making the tool's purpose immediately readable.

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?

As a zero-parameter read-only tool with no output schema and no annotations, the description covers the core purpose and scope. It doesn't state the prerequisite that a project must already be open, nor the return format, which an agent may need to know for reliable use in a multi-step workflow.

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, so the baseline is 4. There is nothing for the description to clarify about parameters, and its focus on project contents fully covers what the agent needs to know for invocation.

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

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

The description uses a specific verb (Lists) and names the exact resources (sprites, costumes, sounds, scripts, variables, broadcasts) in the open project. This clearly distinguishes it from sibling tools like add_sprite, remove_sprite, or create_project, all of which change project state rather than inspect it.

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

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

The scope is clear: this tool inspects the open project. It gives enough context for an agent to know it should be used when project contents need to be enumerated, and no exclusion or alternative is necessary because no sibling tool performs the same read-only listing. It stops short of explicitly saying 'use when you need to see what's in the project' or naming 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 the full burden of behavioral disclosure. It clearly states the destructive side effect that not only the sprite but everything on it is deleted. It does not mention permanence or error behavior, but the core destructive trait is 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 a single, information-dense sentence with no filler. It front-loads the action and clearly states the destructive scope without wasting 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 simple one-parameter destructive tool, the description and schema together are sufficient for an agent to select and invoke the tool: pass the sprite name and expect the sprite and its contents to be removed. It does not cover return values or error cases, but these are not essential for this basic 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?

The schema provides only a string field named 'name' with no description, and the tool description does not explicitly define the parameter. However, the phrase 'Deletes a sprite' makes it reasonably clear that the parameter is the sprite's name. Some detail is missing, such as exact-name matching, but the single parameter is simple enough to infer.

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 the explicit verb 'Deletes' with a clear resource ('a sprite') and adds scope with 'everything on it.' This is specific enough to distinguish the tool from siblings like add_sprite or clear_scripts, even though no sibling is named.

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 when-to-use or when-not-to-use guidance, and the description does not mention alternatives such as clear_scripts for situations where only scripts should be removed. Usage is only implied by the tool's name and purpose.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states that the tool writes a file and provides a default path, but it does not mention whether the file will overwrite an existing one, what happens on error, or whether it returns any status. This leaves important operational details undisclosed.

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, well-structured sentence that front-loads the purpose and includes the output format and default path. There is no filler or redundant information.

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

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

Given the simplicity of the tool (one optional parameter, no output schema), the description covers the essential behavior, output format, and default path. However, it omits details like overwrite behavior and error handling, which are not covered by annotations or schema, so it is slightly incomplete but not severely.

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 describes the 'path' parameter with a simple description, but the tool description adds the default value (./scratch-projects/<name>.sb3) and clarifies the file format. This adds meaning beyond the schema, which already has 100% coverage, so it goes above the 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 clearly states the verb 'writes' and the resource '.sb3 file', and specifies the format's compatibility with Scratch 3 and TurboWarp. This distinguishes it from sibling tools like create_project or preview_project, making the 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 implies when to use the tool (when you need to save/export the project as .sb3), and the context of sibling tools like create_project or preview_project makes the intended use clear. However, it does not explicitly state when not to use it or name alternatives, so it misses full guidance.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden. It mentions that variables are also created automatically, which is useful, but it does not clarify key behaviors such as whether setting an existing variable overwrites it, errors, or is idempotent, nor does it mention any naming constraints or side effects. For a mutation tool, this is a significant gap in 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 two concise sentences with no filler. The primary purpose is front-loaded, and the additional behavioral note about automatic creation is placed naturally without disrupting clarity. 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 simple setter tool, the description is thin on operational context. It omits crucial details such as behavior on duplicate variable names, whether the variable can be modified later, and any constraints on the name or value types. Since there is no output schema or annotations to fill these gaps, the description is not complete enough for an agent to invoke the tool confidently in all scenarios.

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 descriptions only for 'value' (starting value, default 0) but not for 'name'. The tool description does not add meaningful information about the 'name' parameter beyond implying it is the variable name, and it repeats the 'starting value' concept already in the schema. With only 50% schema coverage, the description fails to compensate for the undocumented 'name' parameter, leaving its semantics underspecified.

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: declaring a project-wide variable with a starting value. It also adds the distinctive behavioral note about automatic creation, which helps distinguish it from any sibling that might manage variables. The verb 'Declares' and resource 'project-wide variable' are specific and 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 implies that this tool is for pre-declaring a variable with a starting value, and that variables are otherwise created automatically. However, it does not explicitly state when to use this tool versus relying on automatic creation, nor does it mention any alternative tools. The guidance is inferred rather than stated, so it's adequate but not explicit.

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