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. However, it only says 'run raw Aseprite CLI arguments' without mentioning side effects, permissions, or return behavior. 'Raw' hints at unvetted execution, but this is not explicit.

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

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

The description is extremely concise, consisting of two sentences with no waste. Every word serves a purpose, making it well-structured for quick comprehension.

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

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

For a raw CLI execution tool with no output schema or annotations, the description leaves many unknowns: what output to expect, potential destructive behavior, and environmental dependencies. The schema describes params well, but the description fails to provide essential 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?

The schema covers all parameters with descriptions, including an example for args, so the baseline is 3. The description adds no parameter-specific detail beyond what's in the schema, and 'raw' is redundant with the schema's 'Raw Aseprite CLI arguments'.

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 runs raw Aseprite CLI arguments, which is a specific verb+resource. It also distinguishes itself from sibling tools by noting it's for capabilities not covered by higher-level tools, 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 explicitly says to use this tool for any native capability not covered by a higher-level tool, providing clear usage guidance. It implies not to use it when a higher-level tool exists, but it doesn't name specific alternatives, so it falls short of a 5.

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 must carry the transparency burden. It discloses key side effects: opening input files and saving the active sprite. However, it does not mention potential mutation of sprites in memory, failure behavior when commands are disabled, or the fact that it runs headless via batch mode (though the schema covers batch). This is adequate but not rich.

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

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

The description is a single, efficient sentence that front-loads the core purpose and mentions the two most important optional side effects (opening and saving). No wasted words; every phrase 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 tool with 11 parameters and no output schema, the description plus the high-coverage schema provide enough context to understand the tool. The main missing piece is a high-level overview of the command sequence flow (e.g., actions are applied sequentially), but the schema's `actions` array structure implies this. Overall, the purpose and key behaviors are sufficiently covered.

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 91%, so the baseline is 3. The description does not add parameter-level detail beyond implying inputFiles and saveAs, but the schema already provides thorough descriptions for all parameters. No extra value is needed or 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 ('Run') and identifies the exact resource ('Aseprite app.command.<CommandId>(params) actions through Lua'), with clear scope (optionally opening files and saving the active sprite). It distinguishes itself from sibling tools like aseprite_run_lua and aseprite_cli by focusing on the app.command command sequence mechanism.

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

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

No explicit guidance is provided about when to use this tool versus alternatives such as aseprite_run_lua or aseprite_cli. The description only states what the tool does, leaving the agent to infer appropriate usage from the name and schema.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not state whether the tool executes Aseprite, writes files, requires an executable, or has side effects. The dryRun mention hints at Lua generation but does not explain execution or output behavior.

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

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

The description is highly concise: two sentences, front-loaded with the primary purpose and a notable feature. There is no redundancy or filler, though the second sentence could have been repurposed for more substantive context.

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 is complex (nested schema with seven operation types, no output schema, no annotations), yet the description omits key context: what the sprite represents, how drawing operations map to Aseprite features, whether files are saved, and what the tool returns. The terse description is far from sufficient for such a rich tool.

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

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

Schema description coverage is 80% for top-level parameters, so the baseline is 3. The description adds no parameter meaning beyond what the schema already provides; for example, 'Supports dryRun' merely repeats the dryRun parameter's schema description. No effort is made to clarify the complex 'spec' nested structure.

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 'Create a sprite from structured drawing operations,' clearly identifying the verb ('create'), resource ('sprite'), and method (structured drawing operations). It does not explicitly distinguish this from sibling tools like aseprite_run_lua or aseprite_cli, but the phrasing implies a declarative, operation-based creation approach.

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 such as aseprite_run_lua or aseprite_cli. The description only mentions the dryRun feature, which is a capability detail, not a usage guideline or exclusion criterion.

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

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

The description does not disclose beyond the obvious export action any behavioral traits, such as writing output files to disk, executing external processes, potential for overwriting, or dependencies like Aseprite being installed. Since no annotations are provided, the description carries the full burden, and it falls short of revealing side effects, prerequisites, or failure modes.

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, focused sentence that is front-loaded with the core action ('Export an existing Aseprite file/image'). It contains no filler or redundant information, and every word contributes to conveying the tool's purpose.

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

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

For a tool with 17 parameters, no output schema, and no annotations, the one-sentence description is inadequate. It omits details about output behavior, parameter dependencies, edge cases, and the meaning of many schema properties, leaving the agent without sufficient context to invoke the tool correctly for complex use 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 adds no meaning to the input schema, simply noting that common CLI flags are used. With schema coverage at only 35% and many parameters (e.g., tag, layer, trim, splitLayers, splitSlices) left undocumented in both schema and description, the description fails to compensate for the parameter semantics gap.

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

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

The description clearly states that the tool exports existing Aseprite files/images to PNG/GIF/sheet/data, which is a specific verb+resource combination. It distinguishes itself from siblings like aseprite_create_sprite (creation) and aseprite_cli (generic command execution) by focusing on export functionality.

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 for exporting sprites, but it does not explicitly state when to use it vs. alternatives like aseprite_cli or aseprite_command_sequence. There is no when-not-to-use or alternative recommendations, making the usage guidance implicit 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?

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, and 'known from upstream commands_list.h' suggests a static source, but the description does not explicitly state safety, caching, or dynamic behavior. Minimal but acceptable for a simple 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?

The description is a single clear sentence with no superfluous information. It front-loads the verb 'List' and states the resource and source efficiently.

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

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

Given the tool's low complexity (one optional parameter, no output schema), the description is mostly complete. It would be slightly better if it indicated the return format or explicitly stated that it helps discover valid commands, but the current content is adequate for 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 has 100% coverage: the single 'filter' parameter is described as 'Optional case-insensitive substring filter for command IDs.' The description adds no additional parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('List') and clearly identifies the resource ('Aseprite command IDs') plus the source ('upstream commands_list.h'). This distinguishes it from sibling tools like aseprite_command_sequence or aseprite_run_lua, which execute commands rather than list 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?

No guidance is given on when to use this tool versus alternatives. The description does not mention that it is useful for discovering available command IDs for other tools, nor does it provide any exclusions or conditions. The usage context is entirely implied.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only mentions that input sprites can be opened first, but it omits that executing Lua scripts can have arbitrary side effects, run in batch mode, or have security implications. This is a significant transparency gap for a code-execution 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 a single concise sentence that front-loads the core action and scope. There is no redundant wording or unnecessary detail.

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 purpose and parameters are adequately described, making the tool usable. However, given the tool's power (arbitrary Lua execution), no output schema, and no annotations, the description should provide more behavioral safety context and usage guidance to be truly complete.

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

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

The input schema covers all 8 parameters with descriptions, giving a high coverage baseline. The description adds a little context by summarizing 'inline or file-based' and 'opening input sprites first', but it does not meaningfully expand on the schema's parameter documentation.

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

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

The description uses a specific verb ('Execute') and resource ('Aseprite Lua script') and clearly distinguishes between inline and file-based scripts. It also differentiates the tool from siblings like aseprite_cli or aseprite_command_sequence by focusing specifically on Lua script execution.

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

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

The description provides no guidance on when to use this tool versus alternatives such as aseprite_cli or aseprite_command_sequence. It lacks explicit use cases, prerequisites, or exclusions, so an agent gets minimal help selecting the correct tool.

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

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

Without annotations, the description must convey safety and side effects. It indicates a read-only operation by title and 'return metadata,' but does not explicitly state that the sprite is not modified, nor does it mention any error conditions or caveats. It does add value by listing the metadata fields returned.

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 gets to the point, front-loading the action and output. No waste.

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

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

For a read-only metadata tool with no output schema, the description gives a good outline of returned data. It falls short of mentioning any dependencies or behavioral caveats, but overall it is adequate for 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 schema covers 75% of parameters with descriptions, but the required 'input' parameter lacks a description. The tool description implies 'input' is a sprite file, but does not clarify expected format or examples. The description adds little beyond the schema for the other 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 uses a specific verb ('return metadata') and identifies the resource ('a sprite'), listing concrete output categories (size, frames, layers, tags). This clearly distinguishes it from sibling tools like aseprite_create_sprite or aseprite_export, which have different purposes.

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 choose this tool over alternatives like aseprite_cli or aseprite_run_lua. It implies its use for reading sprite metadata but does not state exclusions or conditions.

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 states the tool resolves the executable and reports version/configuration, which implies a read-only operation, but it does not mention side effects, failure modes, or whether it modifies any files. This is a minimal disclosure 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, front-loaded sentence with no unnecessary words. It efficiently communicates the tool's core function without fluff, making it highly scannable for an agent.

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 is simple, but the description lacks detail on what 'configuration' includes, how the executable is resolved, or what the output format is. Since there is no output schema, the description should provide more context on return values, but it does offer a high-level indication of version/configuration reporting, which is adequate for a minimal viable description.

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

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

The schema provides only the parameter name 'asepritePath' with no description. The description's phrase 'Resolve the Aseprite executable' provides a hint that this parameter is used to specify the executable's location, adding some meaning beyond the bare schema. However, it does not explicitly state the parameter's purpose or format, so it is partially helpful but not fully compensating for the 0% 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 states a specific action: 'Resolve the Aseprite executable and report version/configuration.' This clearly distinguishes the tool from siblings like aseprite_create_sprite or aseprite_export, which handle different resources. The verb 'resolve' and the report of version/configuration give a precise 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?

No guidance is provided on when to use this tool versus alternatives such as aseprite_cli or aseprite_sprite_info. There are no exclusions, prerequisites, or mentions of alternatives, leaving the agent to infer the appropriate usage context.

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