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

With no annotations, the description carries the full burden. It does disclose that the tool mutates the sprite by appending a frame and that it returns the new frame count. However, it omits important behavioral details such as whether the new frame is blank or duplicated, how duration_ms applies, and what side effects occur.

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 zero filler. 'Append a frame; returns the new frame count' is efficient and structurally clear, even though more content could have been added without hurting conciseness.

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

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

For a mutation tool with no annotations and ambiguous sibling names, the description is too thin. It does not explain how the appended frame is created, why sprite_path is required, or how duration_ms affects the new frame. The output schema may define the return shape, but the description still lacks enough context for reliable tool selection and invocation.

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

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

Schema description coverage is 0%, and the description does not compensate. It never mentions sprite_path or duration_ms, their roles, or acceptable values. The schema property names are somewhat self-explanatory, but the description adds no parameter-level meaning beyond what the raw field names imply.

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 operation: append a frame and return the new frame count. It is specific enough to distinguish from delete/duplicate/duration tools, but it does not differentiate from similarly named siblings like ase_add_frames or ase_add_frames_blank, so it falls short of 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?

There is no guidance on when to use this tool versus alternatives. An agent cannot tell from the description whether to choose ase_add_frame over ase_add_frames or ase_add_frames_blank, nor whether it appends a blank frame or a copy of the current frame.

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 key mutation side effect with 'Saves in place' and adds operational context with 'headless CLI.' It also discloses the optional tag-wrapping behavior, giving an agent a solid picture of what happens when the tool is invoked.

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 only three sentences, all of which add value. The core operation is front-loaded, the use case is concise, and the in-place save/headless behavior is stated in a short final sentence. There is no redundant repetition of schema fields or annotations.

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 enough high-level context for an agent to understand the operation and the fact that the file is modified in place, and the presence of an output schema means return values need not be described. Still, there are gaps around layer semantics, image ordering, and what happens when a tag_name is or is not supplied, which leaves some ambiguity for a fully autonomous agent.

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

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

Schema description coverage is 0%, so the description must compensate, and it does provide conceptual mappings: PNGs correspond to image_paths, the .aseprite sprite corresponds to sprite_path, 'new layer' maps to layer_name, and 'animation tag' maps to tag_name. However, it does not explain ordering, path formats, defaults, or the exact effect of layer_name when a layer already exists, so compensation is incomplete.

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 opens with a specific verb and resource: 'Append each PNG as a new animation frame on a new layer of an .aseprite sprite.' It clearly distinguishes itself from sibling frame tools by focusing on PNG inputs and optional tag wrapping, so an agent can tell it apart from tools like ase_add_frame or ase_add_frames_blank.

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 explicitly provides a use case: 'Useful to turn RD generations into idle-animation frames.' This gives clear context for when the tool is appropriate, though it does not explicitly contrast it with sibling alternatives such as ase_add_frames_blank or ase_import_layer.

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 and does it well: it states the append effect, that each frame receives the supplied duration, and that the call returns the new frame count. It does not cover side effects like file modification, but that is a minor gap for a simple append 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?

One compact sentence with no filler: the operation, per-frame duration, and return value are all present and front-loaded. 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 small three-parameter append tool, the description covers the operation and return value, and the schema covers types and defaults. It is slightly incomplete because sprite_path is never described and blank-frame semantics are taken for granted, but nothing essential blocks invocation.

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

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

Schema description coverage is 0%, but the description maps 'N' to count and 'given duration' to duration_ms, adding meaning beyond the raw schema. It does not clarify sprite_path semantics, leaving one of three parameters without descriptive help.

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 ('Append'), a concrete resource ('blank frames'), and states the result (new frame count). It is clear, but it does not explicitly distinguish itself from the sibling ase_add_frames or ase_add_frame.

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 use case is implied: use this when you need to append multiple blank frames with a specified duration. However, there is no explicit guidance about when to choose this over related frame tools such as ase_add_frames or ase_duplicate_frame.

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 only says 'Add a new image layer,' with no mention of where the layer is inserted, whether it is a blank raster layer, or what side effects occur.

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, and it front-loads the core action. 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?

While the tool is simple, the description omits placement behavior and fails to route the agent away from sibling layer-adding tools. With no annotations and no usage guidance, a one-line description is insufficient for confident selection and invocation.

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

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

Schema description coverage is 0%, and the description adds no parameter-level meaning beyond what the names sprite_path and layer_name imply. The parameter names are somewhat self-explanatory, but the description doesn't compensate for the missing 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 uses a specific verb ('Add') and a clear resource ('image layer'), so an agent knows the core action. However, it doesn't differentiate from nearby siblings like ase_import_layer or ase_create_tilemap_layer, so it stops short of 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?

There is no guidance about when to use this tool versus alternatives. With sibling tools like ase_import_layer, ase_add_frames, and ase_create_tilemap_layer available, the agent gets no basis for choosing this one.

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 burden of disclosing behavior. It does mention the key side effect (palette grows by one), which is helpful, but it omits other details such as error conditions, color format expectations, or whether appending affects existing colors. The transparency is adequate but not exhaustive.

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

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

A single, efficient sentence with no redundant words. It is front-loaded with the core action and effect, making it easy to scan.

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

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

While an output schema exists (so return values are covered), the description fails to explain parameter semantics or provide usage context relative to sibling tools. For a 2-parameter tool with zero schema coverage, this is incomplete—an agent cannot confidently call it without additional knowledge.

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

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

Schema description coverage is 0%, and the description provides no information about the 'color' or 'sprite_path' parameters. The agent is left to guess the expected format for 'color' (hex, name, etc.) and the meaning of 'sprite_path'. This is a critical gap for correct 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 states a specific verb ('Append') and a clear resource ('sprite palette') with an explicit effect ('grows by one'). This distinguishes it from siblings like ase_set_palette_color, which implies modification of an existing entry rather than addition.

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—adding a new color—but does not explicitly contrast with alternatives like ase_set_palette_color or ase_get_palette. It provides no when-to-use or when-not-to-use guidance, leaving the agent to infer context from the name and description.

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 disclosure burden and does add useful behavioral detail: it affects only opaque pixels, layer None means all layers, and frame=0 processes every frame. However, it is silent on whether the sprite is mutated in place, whether the operation is undoable, or whether the change is destructive.

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

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

The description is dense and front-loaded: ranges, scope, and special-value semantics are all packed into two sentences with no filler. Every clause adds operational value.

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

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

For a moderate-complexity tool with no schema descriptions, it covers the critical invocation details: shift ranges, opaque-pixel restriction, and the special meaning of layer None and frame=0. The only missing context is persistence/undo behavior, which is minor because an output schema exists for return values.

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

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

Schema description coverage is 0%, so the description compensates well by documenting the valid ranges for hue, saturation, and lightness and clarifying the special semantics of layer=None and frame=0. Only sprite_path is left to inference from its name.

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 ('Shift') and resource (hue/saturation/lightness of all opaque pixels), and gives concrete use cases such as palette swaps and night scenes. It is clearly distinguishable from sibling color tools like ase_replace_color by the global HSL scope.

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 example applications (palette swaps, night scenes, shadow layers), which imply usage context, but it does not explicitly say when to prefer this tool over alternatives or when not to use it. An agent must infer the selection logic from the operation name and scope.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It does not explicitly state that the tool is read-only, what it returns, or any side effects. It does not mention constraints on the palette format (e.g., hex codes) or how invalid input is handled. For a tool that presumably analyzes without modifying, this lack of transparency is a notable gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It avoids any fluff and conveys the essential function without redundancy. It is concise yet informative.

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 (color theory analysis) and the presence of an output schema (not shown), the description should explain input expectations and output structure. It does neither: it fails to specify the palette format or what the returned data looks like. An agent would need to guess the input format and interpret the output schema without context, making it incomplete for effective 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 description coverage is 0%, so the description must compensate for the undocumented 'palette' parameter. It does not specify what each string in the array represents (e.g., hex colors, names) or the expected format. The description only mentions analysis categories, offering no guidance on how to construct a valid palette input.

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: color-wheel analysis of a palette, listing specific outputs like complementary pairs, triads, analogous groups, and temperature. This is a distinct verb-resource pairing that differentiates it from sibling tools like ase_get_palette (retrieval) and ase_sort_palette (sorting). It leaves no ambiguity about what the tool does.

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 analyzing color relationships but does not explicitly state when to use it versus alternatives, nor does it name any alternative tools. There is no guidance on when not to use it (e.g., if only basic statistics are needed, use ase_get_color_stats). The context suggests it is for design decisions, but that is left to inference.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It makes clear this is a mutating drawing operation, but it does not disclose whether existing pixels are overwritten, how frame/layer resolution works, or any destructive potential.

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 filler. Every word contributes to stating the core operation.

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 5-parameter tool with no schema descriptions and no annotations, this is too thin to fully guide a correct invocation. Color format, layer/frame resolution, and thickness semantics are left to inference, even though the output schema may cover return values.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It adds one useful semantic detail—the outline targets non-transparent pixels—but it does not explain the color format, thickness units, or how layer/frame defaults behave.

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 ('Draw') and a specific resource ('outline around non-transparent pixels of a cel'), so the core action is immediately clear. However, it does not distinguish this tool from closely related sibling tools such as ase_draw_contour or ase_draw_line.

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 on when to use this tool versus alternatives. It doesn't mention exclusions, prerequisites, or why one would choose this over ase_draw_contour or other drawing tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses an important side effect: existing pixels are not automatically remapped and must be quantized afterwards. It does not mention whether the file is saved in place or whether all frames are affected, but the key caveat is present.

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 main action is front-loaded, and the caveat is placed immediately after. 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?

The tool is simple, but with zero schema descriptions and no parameter guidance, the description is incomplete. It does not mention how to obtain valid preset names or that sprite_path is the target file. The output schema exists, so return details are not required, but the missing parameter semantics leave an agent guessing.

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 description coverage, and the tool description does not explain either parameter (sprite_path or preset). It references a 'built-in retro preset' but does not specify valid preset values or how to discover them (e.g., via ase_list_palette_presets). This is a major gap for an agent trying to invoke the tool correctly.

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

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

States a specific action ('Set the sprite palette to a built-in retro preset'), identifies the resource (sprite palette), and clarifies scope by saying only the palette is changed. This distinguishes it from sibling ase_set_palette, which likely sets a custom palette, and from ase_quantize_to_palette, which is explicitly named as a follow-up.

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?

Provides a clear usage context: apply a built-in preset, then quantize existing pixels with ase_quantize_to_palette. It does not explicitly state when not to use this tool versus alternatives like ase_set_palette, but the next-step guidance is useful and directs the agent to a specific sibling.

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 that it operates on 'opaque pixels' and 'base color', and that shading depends on 'which way the silhouette faces the light'. However, it doesn't disclose whether the operation is destructive, whether it modifies the sprite in place, or what happens to transparent pixels. The description adds some behavioral context but leaves important mutation semantics unclear.

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, compact sentence that front-loads the core concept ('Directional cell shading') and then explains the mechanism. It's efficient and readable, though it could benefit from a second sentence clarifying parameter usage.

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 0% schema description coverage, the description is too sparse. It doesn't explain the role of frame, layer, or the exact format of light_direction. The output schema exists but the description doesn't clarify what the tool returns or how it affects the sprite. An agent would need to inspect the schema carefully and still might not know how to set light_direction 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 0%, so the description must compensate. It mentions 'base color', 'shadow/highlight', and 'light direction' conceptually, but doesn't map these to the actual parameters (base, shadow, highlight, light_direction, frame, layer). The description doesn't explain the meaning of frame, layer, or how light_direction values are specified. With 7 parameters and zero schema coverage, this is a significant 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 states a specific verb ('recolor') and resource ('opaque pixels of the base color'), and explains the directional shading concept. It distinguishes itself from sibling tools like ase_apply_outline or ase_adjust_hsl by focusing on directional cell shading, though it doesn't 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 description implies when to use it: when you want directional shading based on light direction and silhouette. It doesn't explicitly state when not to use it or name alternatives like ase_adjust_hsl or ase_replace_color for simpler color changes. The context is clear enough for an agent to infer the use case, but explicit guidance is missing.

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

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

With no annotations, the description carries the full behavioral burden, and it uses the key distinction that this deletes the cel instead of painting over it. It states the destructive effect clearly, though it does not mention reversibility or what happens when the target cel does not exist.

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?

One sentence plus a short, necessary parenthetical and one parameter clarification. Every phrase adds information, and the main action is front-loaded.

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

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

For a small destructive operation with an output schema, this is largely complete: it explains the operation's purpose, the key null-layer behavior, and the distinction from transparent painting. It could add a note that frame 1 is the first frame or that layer strings are names, but an agent can proceed reasonably.

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

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

Schema coverage is 0%, so the description must compensate, but it only clarifies 'layer None = first image layer'. It leaves frame indexing, layer name/identifier format, and sprite_path semantics to be inferred from their names and defaults.

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 first clause names a specific verb and resource ('Delete the cel on a layer/frame') and the parenthetical immediately distinguishes it from the superficially similar 'painting it transparent'. This makes it easy to tell apart from cel-drawing and layer-deletion siblings.

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

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

The contrast with painting transparent states when the tool is appropriate: when the cel should be truly empty rather than just visually transparent. It does not spell out when not to use it versus all cel/layer siblings, so it misses the explicit exclusion bar for 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?

No annotations are provided, so the description carries the full burden. It discloses the conversion operation and dithering options, but does not say whether the conversion mutates the sprite in place, whether pixel data or palette are affected, or whether the operation is reversible. This is a meaningful gap for a tool that likely changes the image's color content.

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?

One sentence front-loads the action and packs all parameter domains into a compact string without filler. 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?

The output schema covers return values, and the description covers all four parameter domains, so an agent can construct a valid call. However, the absence of annotations and the lack of usage/behavioral context leave uncertainty about side effects and when to prefer this over palette/dithering siblings.

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

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

Schema description coverage is 0%, so the description must document parameters. It enumerates valid values for mode, dithering, and matrix, which compensates for the schema's bare strings. It does not explain the conditional relationship (matrix is only meaningful when dithering is ordered), but the core parameter meanings are present.

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 ('Convert') and names the exact resource ('color mode'), then enumerates the three target modes (rgb|grayscale|indexed). This makes the tool's function unmistakable and distinguishes it from the many ase_* sprite-editing siblings.

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

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

The description implies the use case—converting a sprite's color mode—but does not name alternative tools or state when not to use it. There is no guidance distinguishing it from closely related operations like ase_quantize_to_palette or ase_dither_gradient.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only diff operation but does not explicitly state it does not modify the sprite. It also introduces 'flattened sprite' without explaining whether flattening is performed automatically or assumed, leaving ambiguity. It does disclose the output nature but lacks side-effect clarity.

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. The first sentence front-loads the core purpose and outputs, the second gives a concrete use case. Every word earns its place; it is appropriately sized 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?

The tool has an output schema, so return values are covered. However, the description does not address potential edge cases like out-of-range frame indices, the meaning of 'flattened' (whether it flattens the sprite or expects a flattened file), or error behavior. For a simple diff tool with only three parameters, this is a moderate 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 coverage is 0%, so the description must explain parameters. It mentions 'two frames' and 'flattened sprite', implying frame_a and frame_b are frame indices, and sprite_path is the file path, but it does not specify indexing (zero-based vs. one-based) or any constraints. It adds minimal value beyond the schema's type hints.

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: 'Diff two frames of the flattened sprite' and enumerates the outputs (changed pixel count, percent, bounding box). It distinguishes itself from siblings by focusing on frame comparison, which no other ase_* tool does. The resource and verb are specific.

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

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

It gives explicit usage context: 'Use while animating to confirm a frame actually changed (or did not change too much).' This tells when to use it, though it does not explicitly mention alternatives or when not to use it. Still, the guidance is clear and actionable.

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 burden of disclosing behavioral traits. It does explain that the copy is independent (unlike linked cels), which is a key behavioral aspect. However, it does not disclose what happens to the target cel if one already exists (the 'replace' parameter), nor any side effects or prerequisites. The mention of 'layer None = first image layer' adds useful default behavior, but more could be said about the operation's effects on the target frame.

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 the core action and differentiator front-loaded. Every word adds value: it states the operation, clarifies independence, names the alternative, and provides the layer default. No wasted words 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?

The tool is relatively simple (copy cel image between frames), and an output schema is present, so return values are covered elsewhere. However, the description omits critical details like the behavior of the 'replace' parameter and does not explain what happens if the source cel is missing. For a mutation operation, the lack of clarity on overwriting behavior is a notable gap. It is minimally adequate but not fully complete.

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

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

The input schema has zero parameter descriptions, so the description must compensate by explaining all parameters. It only explains the 'layer' parameter's default behavior ('layer None = first image layer'), leaving source_frame, target_frame, sprite_path, and replace undefined. While parameter names are somewhat self-explanatory, 'replace' is ambiguous (replaces existing cel? replaces image data?) and no guidance is given. This is a significant gap for a tool with 5 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 states a specific verb ('copy') and resource ('a cel's image from one frame to another') and immediately distinguishes itself from the sibling ase_link_cel by clarifying it creates an independent clone. This is a clear, action-oriented purpose that an agent can act on without ambiguity.

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

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

The description explicitly contrasts with ase_link_cel, indicating this tool is for when an independent clone is needed rather than a shared image. It implies the usage scenario but does not explicitly state when to prefer this over other cel-related tools like ase_create_cel or ase_duplicate_frame, leaving some inference to the agent. Still, the key alternative is named and differentiated.

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

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

No annotations exist, so the description carries the disclosure burden. It clearly discloses the side effect (server clipboard gets the pixels) and the non-destructive nature (sprite intact), which are the main behaviors. It doesn't mention clipboard overwrite or failure modes, but for a simple copy action the core transparency is present.

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

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

Single sentence with no filler, key action and caveat at front. 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?

The tool is simple and has an output schema, but the description omits parameter semantics and usage guidance needed given 0% schema coverage. It assumes the agent already knows an active selection exists and understands frame/layer contexts.

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

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

Schema coverage is 0%, and the description adds no meaning for frame, layer, or sprite_path. An agent cannot tell from the description how frame/layer affect what is copied or whether layer can be null. This is the biggest 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?

States a specific verb ('Copy'), resource ('selected pixels' to 'server clipboard'), and explicitly notes the sprite is left intact, which differentiates it from ase_cut_selection. The key behavior is front-loaded.

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 copying for duplication because it notes the sprite remains intact, but it never says when to prefer this over ase_cut_selection or how paste_clipboard consumes the clipboard. No explicit conditions or exclusions are given.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses that a new sprite is created and its path is returned, but doesn't state what happens to any current/active sprite, whether the file is written immediately, or overwrite 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?

A single efficient sentence that front-loads the core purpose and includes the key color-mode detail plus return value. No wasted words, appropriately sized.

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 creation tool with an output schema, the description covers purpose, color modes, and return. But with 0% schema coverage, no annotations, and no explanation of out_path semantics or required dimensions, some gaps remain 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 description coverage is 0%, so the description must compensate. It explains color_mode options (rgb|grayscale|indexed) but says nothing about width, height, or the out_path parameter, including its null default and what null implies. Only partial compensation for the coverage 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?

States a specific verb 'create' and resource '.aseprite sprite', and notes the supported color modes. The resource is clear enough to distinguish from export/save/color-mode tools, though it doesn't explicitly name which sibling it is not.

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

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

No guidance on when to use this tool versus alternatives like ase_save_as or ase_color_mode. No context about prerequisites (e.g., whether an existing sprite is required) or when creation is appropriate.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the idempotent no-op behavior and the default layer selection, which are useful. However, it does not explain what happens if the specified layer or frame does not exist, whether the cel is placed at x/y, or other side effects beyond creation.

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 filler. It front-loads the core action and includes a high-value parameter default. Every word contributes to understanding the tool's primary purpose and an important edge case.

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?

Although an output schema exists, the description fails to explain several key parameters (x, y, frame, sprite_path) that an agent must understand to invoke the tool correctly. For a tool with no annotations and 0% schema coverage, this is a notable completeness gap, even though the core idea is simple.

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 meaning only for the layer parameter ('layer None = first image layer'), but the input schema has 5 parameters (x, y, frame, layer, sprite_path) with 0% schema description coverage. The meaning of x, y, frame, and sprite_path is entirely omitted, leaving the agent to guess their semantics.

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

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

The description clearly identifies the action ('Create'), the resource ('empty canvas-sized cel'), and the target ('on a layer/frame'), with an explicit no-op condition. It distinguishes this from sibling tools like ase_clear_cel or ase_copy_cel by specifying creation of an empty canvas-sized cel.

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 a use case (ensuring an empty canvas-sized cel exists on a layer/frame) and gives a helpful default for layer, but it does not explicitly state when to use this versus alternative tools such as ase_add_frame, ase_add_layer, or ase_clear_cel. No exclusions or alternative routing is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but does not mention side effects (e.g., adding to the current sprite), coordinate system, units, or any output/return behavior. An agent cannot anticipate what happens on success or failure, nor whether existing slices are affected.

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 waste. It communicates the core purpose efficiently, achieving conciseness without sacrificing clarity.

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

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

Despite having an output schema (not shown) and six required parameters, the description is far too sparse. It does not clarify the coordinate system, the meaning of 'name', or how the slice integrates with the sprite. With zero annotation and schema coverage, this leaves critical gaps for an agent attempting to invoke 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?

The schema has 0% description coverage, so the description must compensate, but it does not mention any parameter names or semantics. The six required parameters (sprite_path, name, x, y, width, height) are completely unexplained, leaving an agent without clues about coordinate origin, units, or naming constraints.

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 ('Create') and a specific resource ('named slice'), and clarifies the purpose for game engines. It clearly distinguishes from siblings like ase_list_slices (listing) and ase_delete_slice (deletion), making the tool's 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?

No guidance is provided on when to use this tool versus alternatives. Siblings like ase_export_sprite and ase_set_slice_center exist, but the description does not mention any conditions, prerequisites, or exclusions, leaving the agent to infer the appropriate 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create an animation tag' and lists direction options, but does not explain whether the operation is destructive, whether it modifies the sprite file, what happens if a tag with the same name exists, or any side effects. This is a significant gap for a mutation 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 purpose. It is appropriately sized, though it omits critical details. It earns a 4 because it is efficient and to the point, but not a 5 due to missing essential information.

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

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

Given the tool has 5 parameters (4 required) and an output schema, the description is far too thin. It does not explain the semantics of frame ranges, tag names, or sprite paths, and lacks any context about how tags are used in animation workflows. The output schema might partially mitigate return-value clarity, but the description still fails to provide a complete picture.

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 has 0% description coverage, so the description must compensate. It partially explains the direction parameter (forward|reverse|pingpong) but provides no meaning for sprite_path, tag_name, from_frame, or to_frame. An agent cannot infer what these values represent or how they relate to animation tags.

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 ('Create') and the resource ('an animation tag'), and includes the direction options (forward|reverse|pingpong) which adds specificity. It is easily distinguished from sibling tag operations like ase_delete_tag or ase_export_tag by the verb.

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, no prerequisites, and no mention of what constitutes a valid tag definition. The description simply states the action without any context about animation frame ranges or typical workflows.

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. It discloses the two main side effects (setting the sprite grid to the tile size and adding the layer) and explains the reserved tile 0 semantic. It does not mention error conditions or whether prior layers are affected, but the core mutation behavior is clearly conveyed.

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, each earning its place: the first states the operation and side effects, the second conveys a key invariant and directs to the companion drawing tool. No filler or redundancy.

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

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

Given there is an output schema and no annotations, the description provides enough for correct invocation: purpose, side effects, the reserved tile convention, and a pointer to the next tool. It could add caveats about existing layers or grid conflicts, but the essentials are all present.

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

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

Schema description coverage is 0%, so the description must compensate. It associates tile_width/tile_height with the grid tile size, layer_name with the added layer, and sprite_path via 'sets the sprite grid.' This adds meaning beyond the bare parameter names, though it does not give constraints, units, or explicit per-parameter explanations.

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

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

The description clearly states a specific action ('Create a tilemap layer with its own tileset') and the resource affected (the sprite's grid and layer stack). It implicitly distinguishes from plain layer creation (ase_add_layer) by emphasizing tilemap and tileset, so an agent can select this tool appropriately.

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: this tool both sets the grid and adds the layer, and it explains the special role of tile index 0. It also names ase_draw_on_tile as the intended next step for drawing real tiles. However, it does not explicitly contrast with ase_add_layer or state when not to use this 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?

Annotations are completely absent, so the description carries the full burden of behavioral disclosure. It says only 'crop' without revealing whether the operation is permanent, how it affects frames/layers, or whether it relies on the current selection. No side effects or destructive implications are mentioned.

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 single sentence is concise and front-loaded with the action, containing no extraneous words. However, it is so minimal that it approaches under-specification rather than achieving the balance of a well-structured, complete description.

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 5 required parameters, no annotations, and no schema descriptions, the description is far too sparse to support correct tool invocation. It lacks coordinate system details, effect scope (e.g., all frames vs. active frame), and any mention of return values, even though an output schema exists.

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

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

Schema description coverage is 0% for 5 required parameters, and the description adds no meaning to x, y, width, height, or sprite_path. It does not specify coordinate origin, units, or how the rectangle relates to the canvas, leaving the agent with no parameter insight beyond raw types.

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 'Crop the sprite to a rectangle,' which is a specific verb (crop), resource (sprite), and geometric constraint (rectangle). This clearly communicates the core action and distinguishes from tools like ase_resize_canvas or ase_scale_sprite, though it does not explicitly name alternatives such as ase_trim_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?

No guidance is provided on when to use this tool versus related siblings like ase_trim_sprite (which typically removes empty borders) or ase_resize_canvas. The description only states the action, leaving the agent to infer appropriate usage 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 provided, so the description carries the full burden of behavioral disclosure. It does reveal the destructive aspect by stating it clears the cel, which is important, but it omits prerequisites such as needing an active selection, whether the selection itself is preserved, and what happens on error or empty selection.

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 core action and target are front-loaded, making it easy for an agent to parse quickly.

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 mutating tool with no annotations, undocumented parameters, and a large sibling list, this is under-specified. It does not distinguish itself from ase_copy_selection, explain layer/frame defaults, or mention prerequisites, even though an output schema may cover return values.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters: sprite_path, frame, or layer. The word 'cel' only weakly hints at frame/layer context but gives no meaning, defaults, or usage details.

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: 'Copy the selection to the clipboard and clear it in the cel.' This clearly conveys cut semantics and distinguishes it from the sibling ase_copy_selection, which only copies.

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

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

There is no explicit guidance about when to use this tool instead of ase_copy_selection or ase_clear_cel. The intended usage is implied by the wording, but no alternative or exclusion is mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Delete' without explaining that this is destructive and possibly irreversible, how it affects cels, animation tags, or the ordering of remaining frames, or what happens if the frame index is out of range.

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, direct sentence with no fluff, and it front-loads the key action and indexing detail. It is concise without being a tautology, though it could be slightly more explicit about parameter roles.

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 two-parameter deletion tool, the 1-based indexing hint is the most critical detail and is present. Still, with no annotations and no behavioral context, an agent lacks information about destructive consequences and error conditions, so the description is minimally 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?

The description clarifies that the 'frame' parameter is 1-based, which is meaning beyond the bare integer type in the schema. However, with 0% schema description coverage, it leaves 'sprite_path' semantics unaddressed, so it only partially compensates for the missing 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 states a clear action ('Delete') and resource ('frame'), and adds the important indexing detail '1-based'. It is distinct from sibling tools like ase_add_frame or ase_duplicate_frame, though it does not explicitly differentiate itself from 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?

There is no guidance about when to use this tool versus alternatives such as ase_duplicate_frame, ase_add_frame, or ase_clear_cel. The description gives no context about deleting animation frames, preserving cels, or any prerequisites 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?

No annotations are provided, so the description carries the full burden. It only says 'Delete a layer by name,' which implies a destructive operation but doesn't disclose irreversibility, effect on cels, or error handling. This is insufficient for a destructive tool.

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

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

The description is a single, direct sentence, which is concise and front-loaded. It wastes no words, but it is under-specified, lacking any behavioral or usage detail. Still, it is efficiently sized for a simple action.

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 delete operation with two parameters, the description is minimal but lacks critical context: no mention of permanence, undo support, or what happens if the layer doesn't exist. Given no annotations, the description should provide more safety-relevant 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 coverage is 0% and the description doesn't explain the parameters. Although the names sprite_path and layer_name are self-explanatory, the description doesn't add meaning beyond the schema, nor does it clarify formats or constraints.

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 clear verb and resource: 'Delete a layer by name.' It distinguishes from other delete operations (e.g., ase_delete_frame) by specifying 'layer'. However, it doesn't mention the sprite context, which is implied by the sprite_path parameter, so it's not 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?

No guidance on when to use this tool versus alternatives like ase_merge_layer_down or ase_set_layer_visibility. It doesn't state prerequisites (e.g., sprite must be open) or consequences, leaving the agent without direction on when to choose this over similar layer operations.

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 only states the action without indicating that deletion is irreversible, what happens if the slice does not exist, whether the sprite must be saved, or any other side effects. This is a significant gap for a destructive 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?

The description is a single sentence with no filler. Each word contributes meaning, and the action is front-loaded. It is appropriately concise for a simple delete operation, with no wasted text.

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?

Even though an output schema exists, the tool is destructive and requires context about prerequisites (e.g., knowing the slice name from ase_list_slices), error handling for missing slices, and the effect on the overall sprite. The description provides none of this, so an agent would need to infer critical operational details, making the definition incomplete for safe invocation.

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

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

The input schema has two required string parameters with no descriptions (schema coverage 0%). The description only hints at the 'name' parameter via 'by name' but says nothing about 'sprite_path'—how it identifies the sprite file, its expected format, or its relationship to 'name'. The description adds minimal value beyond the raw 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 action (delete), a specific resource (slice), and the selection mechanism (by name). This clearly distinguishes it from sibling tools like ase_create_slice, ase_set_slice_center, and ase_list_slices, which have different actions on the same 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?

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites such as obtaining slice names via ase_list_slices. The description does not mention exclusions, conditions, or when deletion is appropriate, leaving the agent without decision support.

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 full responsibility for behavioral disclosure. It clearly indicates a destructive delete action, but it does not describe side effects, irreversibility, what happens if the tag or sprite is not found, or whether the change must be saved.

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, front-loaded sentence with no redundant words. However, it is so terse that it omits useful parameter context, so it is not maximally effective despite being compact.

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 destructive mutation tool with two required parameters and no annotations, the description is incomplete: it omits parameter semantics for sprite_path, prerequisites, and behavioral details. The presence of an output schema reduces the need to describe return values, but the remaining gaps are significant.

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

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

Schema description coverage is 0%, and the description only clarifies the 'tag_name' parameter as 'by name'. It does not explain 'sprite_path', its expected format, or the relationship between the two parameters, leaving a required parameter semantically undocumented.

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

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

The description 'Delete an animation tag by name' states a specific verb ('Delete') and resource ('animation tag') with a clear selection criterion ('by name'). This clearly distinguishes it from sibling tag tools like ase_create_tag and ase_export_tag, which use different verbs and 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?

No guidance is provided about when to use this tool versus alternatives, nor are prerequisites mentioned such as the tag needing to exist or the sprite being open/loaded. The usage context is only implied by the action itself.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It clearly states the core effect—clearing the server-side selection—but does not discuss idempotence, whether the editor-visible selection is also affected, or any other side effects. For a simple zero-argument operation, 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?

A single sentence with no filler, front-loading the action and the object. Every word contributes meaning and the description is appropriately minimal for this tool.

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

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

For a zero-parameter tool with an output schema, the description is nearly complete: an agent knows what action is invoked and what state changes. The main ambiguity is the meaning of 'server-side selection' and the lack of usage context, but the low complexity keeps this acceptable.

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 accepts zero parameters and the input schema is empty, so there are no parameter semantics to document. The baseline of 4 applies because there is nothing additional the description needs to clarify.

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 ('clear') on a specific resource ('the server-side selection'), so an agent knows what the tool does. It adds the 'server-side' qualifier beyond the title, but it does not explicitly distinguish itself from sibling selection tools.

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

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

No guidance is provided about when to use this tool versus alternatives such as ase_select_* or krita_clear_selection. The 'server-side' qualifier hints at a distinction, but there are no explicit when-to-use or when-not-to-use 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 provided, the description carries the full burden of behavioral disclosure. It explains the algorithm (Bayer 4x4 ordered-dither), the direction (top-to-bottom default, horizontal=true for left-to-right), and the coordinate system (sprite-global, cel normalized to canvas). It also notes the absence of intermediate colors, which is a critical behavioral trait. While it does not detail side effects like overwriting, the act of 'filling' is inherently clear.

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 short sentences with no redundancy. The first sentence states the primary purpose, the second covers direction, and the third clarifies the coordinate system. It is front-loaded and every sentence earns its place, making it easy for an agent to scan.

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

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

Given the tool's complexity (10 parameters, no schema descriptions, no annotations), the description covers the essential behavior, direction, and coordinate system. It does not explain frame/layer defaults or color string format, but these are partly addressed by the schema defaults. The presence of an output schema reduces the need to describe return values. Overall, it is complete enough for a drawing tool, with minor gaps in parameter details.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the rectangle dimensions (x, y, width, height) by referencing a rectangle and sprite-global coordinates, the two colors (color_start, color_end) as the two-color gradient, and the horizontal flag for direction. However, it does not explain the format for color strings, nor the meaning of frame and layer parameters, which are optional but present in the schema. It adds value beyond the schema but leaves some parameter semantics 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 action (fill a rectangle), the specific method (two-color Bayer 4x4 ordered-dither gradient), and the key constraint (no new intermediate colors). It distinguishes this tool from siblings like ase_draw_rectangle or ase_fill_area by specifying the dithering algorithm and gradient nature, making its purpose unmistakable.

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

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

The description implies usage for creating dithered gradients between two colors, but it does not explicitly mention when to use this tool versus alternatives such as ase_draw_with_dither or ase_fill_area. There is no statement about exclusions or preferred scenarios, leaving the agent to infer from 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?

There are no annotations, so the description carries the burden of disclosing behavior. It does reveal the resampling method ('box-ish', 'bilinear then nearest'), which is useful. However, it does not mention side effects such as whether the original file is modified, whether out_path is written, 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 a single sentence that leads with the action and uses a parenthetical to add algorithm detail. Every word earns its place and there is 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?

With no annotations, 0% parameter schema coverage, and only one sentence of description, this tool is under-specified. An agent would not know whether this saves to out_path, how it differs from ase_scale_sprite, or what the expected output is, despite the presence of an output schema.

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

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

Schema description coverage is 0%, and the description does not explain any parameter by name. 'Target size' hints at width and height, but sprite_path and out_path are left completely unexplained, so the description fails to compensate for the lack of schema 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 states a specific action ('downsample to target size') and a specific algorithm ('bilinear then nearest for pixel art'), so an agent can tell it is a resampling operation. However, it does not explicitly distinguish itself from sibling tools like ase_scale_sprite or ase_resize_canvas.

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 'for pixel art' provides an implied use case, but there is no explicit guidance about when to use this tool versus alternatives such as ase_scale_sprite. No exclusions or alternative tool names are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Draw a circle' implies modification of the sprite, but it does not state whether existing pixels are overwritten, whether the operation is destructive, how colors are interpreted, or what happens if coordinates are out of bounds. The description is too thin to inform an agent about side effects.

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

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

The description is extremely short, which is concise, and front-loads the core action. The parenthetical adds value by clarifying the 'filled' option. However, it is under-specified to the point of being terse rather than efficiently informative, so it is only minimally acceptable.

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

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

Given 8 parameters, 0% schema coverage, no annotations, and many sibling tools, this description is severely incomplete. It omits essential information about coordinate systems, color formats, frame/layer targeting, and rendering behavior. An agent cannot reliably invoke this tool correctly from the description alone.

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

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

With 0% schema description coverage, the description must compensate for the 8 parameters, but it only hints at the 'filled' boolean ('filled or outline'). It does not explain sprite_path, center_x, center_y, radius, color, frame, or layer semantics. This is far from adequate for an agent to construct valid calls.

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: 'Draw a circle', which is distinct from sibling tools like ase_draw_line and ase_draw_rectangle. The parenthetical '(filled or outline)' adds a key nuance that maps to the 'filled' parameter. However, it does not explicitly differentiate from other ase_draw_* tools beyond the shape name, so it is clear but not fully sibling-aware.

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. The description says nothing about suitable contexts, such as when a user wants a basic shape vs. a more complex drawing operation, nor does it mention any exclusions or prerequisites. With many sibling draw tools, an agent has no basis to decide between them.

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 only states the basic drawing action and does not explain that it modifies the sprite at sprite_path, what coordinate space points use, how 'closed' and 'thickness' affect the result, or which frame/layer are affected.

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 and front-loaded, with no filler or redundancy. However, it is so brief that it skips structural details that would help an agent, so it earns high marks for conciseness but not full marks for structure.

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 seven parameters, no annotations, and a mutation-oriented drawing operation, a single clause is insufficient. Critical information such as the point object format, coordinate system, default frame/layer behavior, and the meaning of closed/thickness is missing, making the tool hard to invoke correctly in practice.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely associates 'points' with the path. It does not clarify the structure of a point object, nor does it add meaning for sprite_path, color, frame, layer, closed, or thickness.

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 ('Draw') and a distinct resource ('polyline/polygon') rather than just restating the tool name. The phrase 'through points' helps differentiate it from single-segment draw_line, draw_rectangle, and draw_circle siblings, although it does not explicitly name any sibling.

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 explicit when-to-use guidance, no exclusions, and no mention of alternatives. An agent must infer from the name and the word 'polyline/polygon' that this is for connected multi-point paths, but that inference is not made 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 provided, the description carries the full burden of behavioral disclosure. It only mentions the algorithm and optional thickness, but does not state whether the line overwrites existing pixels, whether it targets the active layer, or any side effects like selection handling. This is a significant gap for a drawing tool.

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

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

The description is extremely concise, a single sentence with no filler. It front-loads the primary purpose and includes two useful specifics (Bresenham, optional thickness). While efficient, it sacrifices completeness for brevity, which is acceptable but not exceptional.

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 9 parameters, zero schema descriptions, no annotations, and an output schema that is not described, this description is grossly inadequate. An agent would not know how to set most parameters correctly, what the function returns, or what side effects to expect. It covers almost none of the needed 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 0%, so the description must compensate for the 9 parameters. It only adds meaning for 'thickness' and implicitly for coordinates via the line concept. Other parameters like color, frame, layer, and sprite_path are left undefined. This is insufficient for correct 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 clearly states the verb 'draw' and the resource 'a line', and the parenthetical mention of Bresenham and optional thickness distinguishes it from sibling drawing tools like ase_draw_pixels, ase_draw_rectangle, and ase_draw_circle. It is 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 when to use the tool (when you need to draw a line on a sprite), but it does not provide explicit guidance on when to choose this over alternatives, nor does it mention any prerequisites or exclusions. It is adequate but leaves the selection rationale to the agent.

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 discloses non-obvious behavior: coordinates are tile-local, 0 is a reserved empty tile, tile_index values start at 1, and passing the current tile count appends a new tile. It omits state requirements and error behavior, but covers the key mutation semantics.

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

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

Three focused sentences front-load the action and immediately provide coordinate and format details, followed by the tile_index edge case. There is 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?

For a four-parameter mutation tool with no annotations, the description provides the core semantics needed to call it correctly: coordinate frame, pixel format, reserved index, and append behavior. It leaves unspecified edge cases such as out-of-range tile_index or whether the target layer must already be a tilemap layer, but an output schema exists for return values and the main operational hazards are 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?

The schema has 0% description coverage, so the description must compensate. It precisely documents the pixel element shape ({x, y, color: '#rrggbb'}) and the special tile_index semantics, while sprite_path and layer_name are clear from the resource phrase. This adds significant meaning beyond the bare 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 uses a specific verb ('Paint') and names the exact resource (pixels in a tile of a tilemap layer's tileset), which clearly separates it from sibling tools like ase_draw_pixels that operate on sprite canvas coordinates. It also states the coordinate system and tile-index conventions, making its function 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 gives clear context: use this tool when modifying the pixels that make up a tile in a tilemap layer's tileset, rather than drawing on the sprite canvas or setting tilemap grid positions. It does not name alternatives explicitly or state when not to use it, but the tile-local coordinate and tile_index hints are enough to identify the appropriate scenario.

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 burden of behavioral disclosure. It usefully reveals that the default mode replaces everything including alpha, while merge=True skips fully transparent pixels. However, it does not mention undoability, coordinate bounds, or effects on the rest of the cel.

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

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

The description is short and front-loaded, with the core behavior in the first sentence. The second sentence earns its place by explaining merge behavior. The confusing 'hex via r/g/b/a ints' clause slightly hurts clarity.

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

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

The output schema lowers the burden for return-value documentation, and the essential pixel-drawing behavior is present. But for a 5-parameter tool with 0% schema coverage, the description is thin: pixel format details, defaults, and the hex ambiguity are not fully resolved.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the pixel array shape [{x,y,r,g,b,a}] and the merge parameter's meaning. But it leaves color ranges, frame/layer semantics, and the ambiguous 'hex via r/g/b/a ints' phrase unexplained.

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

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

The description states a specific verb and resource: 'Draw individual pixels ... on a cel.' This clearly identifies the action. It does not explicitly differentiate from the sibling ase_draw_pixels_hex, and the phrase 'or hex via r/g/b/a ints' is confusing.

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 like ase_draw_pixels_hex, ase_draw_line, or ase_fill_area. The merge explanation is parameter behavior, not tool-selection 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, the description carries the full burden of behavioral disclosure. It only restates the core action (draw pixels) and does not clarify whether pixels are overwritten, how alpha colors are composited, or how frame/layer/merge settings affect the 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?

The description is a single efficient sentence that front-loads the key input format. It could be slightly improved by removing the vague 'Convenience:' prefix, but overall it is appropriately concise.

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

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

Given the output schema, return values are likely covered, but the description is incomplete for an agent selecting among many drawing tools. It does not explain the relationship to ase_draw_pixels, the meaning of 'merge', or how the other parameters affect the draw operation.

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

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

Schema description coverage is 0%, so the description must compensate for all parameters, but it only documents the 'pixels' item structure. Parameters like 'frame', 'layer', 'merge', and 'sprite_path' are left to inference from their names and defaults.

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 ('draw pixels') and the exact expected input format, including color encoding. It is distinguishable from most siblings by its hex-color focus, though it does not explicitly distinguish itself from the similarly named ase_draw_pixels.

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 word 'Convenience' implies this is a simplified wrapper, but the description gives no concrete guidance about when to use this tool versus ase_draw_pixels or other drawing tools like ase_draw_line or ase_fill_area. No exclusions or alternatives are named.

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 only says 'draw a rectangle (filled or outline)' and omits key details like whether it overwrites existing pixels, how it interacts with the active frame/layer, or what color format is expected. This is inadequate for a mutation 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 front-loaded sentence with no redundancy, which is efficient. However, it is so terse that it borders on under-specification rather than effective conciseness; it would benefit from a second sentence providing 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?

Given the tool's complexity (9 parameters, no annotations) and the lack of parameter descriptions in the schema, the description is far from complete. It doesn't address coordinate origin, color format, default frame/layer behavior, or any return values, leaving an agent to guess critical call details.

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

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

Schema description coverage is 0% with 9 parameters (6 required), and the description adds almost no parameter meaning. The only hint is 'filled or outline', which maps to the 'filled' parameter, but x, y, width, height, color, sprite_path, frame, and layer are left completely unexplained.

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

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

The description states a specific verb ('draw') and a specific shape ('rectangle'), and mentions the filled/outline option, which helps differentiate it from sibling tools like ase_draw_line or ase_draw_circle. However, it doesn't explicitly name any alternatives or state the sprite context, which prevents 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?

No guidance is given on when to use this tool versus siblings such as ase_draw_pixels, ase_draw_line, or ase_fill_area. The purpose is implied by the name and brief description, but there is no explicit context or exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It discloses the dither pattern types and that it fills a region, but it does not state whether the fill respects selection boundaries, whether it overwrites existing pixels, how the density parameter affects the result, or what the output schema contains. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single sentence that front-loads the core action and includes the key pattern options. It is concise and scannable, though it could be slightly more structured by separating the pattern list from the main action.

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 11 parameters, 7 required, no annotations, and an output schema, but the description only covers the pattern parameter. It lacks essential context about how the region is defined, how colors are specified, what density means, and what the output indicates. This is inadequate for an agent to invoke the tool correctly without opening the schema and guessing.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'pattern' parameter by listing valid values, but it does not explain the meaning of 'density', the format of 'color1'/'color2', or the coordinate system for x/y/width/height. With 11 parameters and no schema descriptions, the description only clarifies one parameter.

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 ('Fill') and resource ('a region with a dither pattern'), and enumerates the pattern types. It clearly distinguishes from sibling drawing tools like ase_fill_area (solid fill) and ase_dither_gradient (gradient dither), though it doesn't explicitly name 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 implies usage for filling a region with a dither pattern, and the pattern list gives some context. However, it does not explicitly state when to use this tool versus ase_fill_area, ase_dither_gradient, or ase_draw_pixels, nor does it mention any prerequisites like active selection or layer requirements.

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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It reveals that insert_after=0 appends at the end, which is useful, but it does not disclose whether duplication copies all cels/layers/frame duration, whether the operation is additive, or how invalid indices are handled. For a mutating tool this is thin.

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 compact sentence with no filler, and the main action is front-loaded. It is appropriately concise, though the brevity contributes to under-specification in other dimensions.

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 and an output schema exists, but without annotations and with zero parameter documentation, the agent only gets a bare action and one parameter hint. It lacks enough context to know what source_frame refers to or what 'duplicate a frame' entails in Aseprite terms.

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

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

Schema description coverage is 0%, so the description must compensate. It explains insert_after (0=end), but says nothing about sprite_path or source_frame, leaving both required parameters to inference.

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: 'Duplicate a frame'. It also gives a concrete behavioral detail about insert_after=0 appending at the end. It does not explicitly distinguish itself from siblings like ase_add_frame or ase_copy_cel, but the verb 'duplicate' is unambiguous about copying an existing frame.

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 ase_add_frame, ase_copy_cel, or ase_duplicate_layer. The insert_after note is a parameter behavior, not selection guidance. No exclusions or alternative 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?

With no annotations, the description carries the full behavioral burden, and it does well: it states that the copy is independent (deep copy of cels), that opacity and blend mode are included, that the copy lands directly above the source, and that the default name follows a suffix pattern. It doesn't mention potential edge cases like overwrite behavior, but the key side effects are 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?

Two sentences deliver the core action, the copied attributes, the placement, and the default naming convention. There is no filler, and the most important information is front-loaded. 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?

For a tool with an output schema and modest complexity, the description is nearly complete: it clarifies what gets duplicated and how the result is positioned/named. It does not mention whether group layers or layer masks are included, but given the simple parameter set and the presence of an output schema, this is not a critical omission.

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

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

Schema description coverage is 0%, so the description must compensate. It explains new_name's default behavior ('source name plus a copy suffix'), which adds value. However, sprite_path and layer_name are not explicitly defined; they are only implied by the context of the description. The description partially compensates for the lack of schema documentation but not completely.

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 opens with the specific verb 'Duplicate a layer', identifying both the action and the resource. It extends the purpose by specifying what is duplicated (all cels independently, opacity, blend mode) and the placement/name behavior, which clearly differentiates it from sibling tools like ase_add_layer, ase_delete_layer, and ase_rename_layer.

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 a full independent copy of a layer is needed—but it does not explicitly name alternatives or state when not to use it. An agent would infer the use case from the verb 'duplicate', but there is no direct guidance such as 'use instead of ase_add_layer for copying existing content'.

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 behavioral burden. It discloses the core behavior (making pixels transparent) and return value, and clarifies layer/frame defaults. However, it does not mention whether the operation is destructive or irreversible, how it interacts with selections, or whether it affects all frames when frame=0 beyond the stated default. These are meaningful gaps for a mutation 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 redundancy. The core action is front-loaded, followed by parameter clarifications and the return value. Every clause contributes new information. This is a model of concise, structured description.

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 5 parameters and no annotations, the description covers the essential behavior, key parameter semantics, and return value. It doesn't mention error conditions, prerequisites like whether the sprite must be open, or how the operation interacts with existing selections. The output schema exists, which covers return format. Given the simplicity of the operation, it's nearly complete but could add a note on destructiveness.

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

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

Schema coverage is 0%, so the description must compensate. It does for three of five parameters: tolerance is given a range (0-255), layer is explained as 'None = all layers', and frame as '0 = every frame'. It does not explain the color format (e.g., hex, name) or the meaning of sprite_path, but the latter is self-evident. The description adds substantial value beyond the raw schema.

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

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

The description clearly states the action (make matching pixels transparent) and specifies per-channel tolerance and scope defaults. It is specific enough to distinguish from ase_replace_color (which changes colors) and ase_fill_area (which fills regions), though it doesn't explicitly name any sibling. The core function is 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?

No guidance is given on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or scenarios where another tool would be preferable. The description only states what it does, not when to choose it. For an agent deciding between erase_color, replace_color, or fill_area, this provides no direction.

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 disclosing behavior. It mentions that out_dir defaults to output/layers_<sprite name>/, which is useful, and that include_hidden exports hidden layers. However, it does not clarify whether the tool creates the output directory, whether it overwrites existing files, what naming conflicts arise, or whether it works for all sprite formats. The reference to --split-layers suggests a CLI wrapper but does not explain the tool's behavior on failure or edge cases.

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, and front-loads the core function. It efficiently mentions the key behavioral details: the --split-layers flag, the default output directory, and the include_hidden option. There is no redundancy or filler, but it could be slightly more structured by separating the default directory from the flag explanation.

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

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

Given the tool has an output schema (which likely describes the output paths or status), the description need not detail the return format. However, it lacks information on prerequisites (e.g., does the sprite need to be open?), edge cases (e.g., no visible layers, hidden layer behavior), and potential side effects (e.g., directory creation). For a tool with only 3 parameters, the description covers the essentials but leaves some gaps in operational 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 0%, so the description must compensate. It explains out_dir's default behavior (output/layers_<sprite name>/) and include_hidden's effect (also exports hidden layers), which adds meaning beyond the schema. However, sprite_path is barely elaborated, only implied as the input sprite file. Given the description covers two of three parameters, it partially compensates for the low schema coverage, but not fully.

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 exports each visible layer as a PNG named after the layer, which is distinct from ase_export_sprite (exports whole sprite) and ase_export_spritesheet (exports a spritesheet). It also mentions the flag --split-layers, which differentiates it from exporting a single image. The verb 'export' and resource 'layers' are specific, and the description conveys the exact output format.

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

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

The description implies usage for exporting layers individually, but it does not explicitly say when to use this tool versus ase_export_sprite or ase_export_spritesheet. It mentions include_hidden to also export hidden layers, giving a hint about typical use cases (visible layers only by default), but lacks explicit exclusions or comparisons. Given the large sibling list, more guidance on when to prefer this over other export tools would be valuable.

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 burden. It discloses one important behavior: frame=0 exports the animation, which is non-obvious given the schema default of 0. However, it does not mention overwrite behavior, path requirements, or any side effects. It adds some transparency but leaves many gaps.

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 sentence with no superfluous words. The core purpose and the frame caveat are front-loaded. It is efficiently structured.

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

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

For a simple file-export tool, the description covers the essential invocation surface (sprite_path, output_path, format, frame) and notes the animation behavior. However, it doesn't mention whether output overwrites, whether paths must exist, or how it relates to sibling export tools. Given no annotations, a bit more context would help.

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

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

Schema description coverage is 0%, so the description must compensate. It provides the allowed format values (png|gif|jpg|bmp) not present in the schema, and explains the special meaning of frame=0. But it does not clarify sprite_path or output_path semantics, which are left to inference. This is partial compensation.

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 clear verb ('Export') and resource ('sprite') with supported formats, and adds a meaningful behavior for frame=0. However, it does not differentiate from sibling export tools like ase_export_spritesheet or ase_export_layers, so an agent may need to look elsewhere to distinguish 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 choose this tool over the sibling export tools (spritesheet, layers, tag). There is no mention of use cases or exclusions. The description only states what it does, not when 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 provided, the description must carry the behavioral burden. It does not disclose whether the export overwrites existing files, whether the output is created in the filesystem, or what the JSON metadata includes. It also does not state any side effects or dependencies as the ase_export_sprite sibling appears to handle single-sprite exports.

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, concise and front-loaded with the core purpose and layout options. It does not waste words, though it could be richer with behavioral details without becoming verbose.

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

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

Given the tool's complexity (5 parameters, multiple layout modes, optional JSON), the description is incomplete. An output schema exists, so return values are covered, but the lack of usage guidance, behavioral disclosure, and parameter semantics leaves agents underinformed 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 description coverage is 0%, and the description does not explain any parameter semantics. The layout options (horizontal, vertical, etc.) are listed, but not defined. The schema parameters like 'include_json' and 'padding' have no additional meaning beyond their names. For a tool with 5 parameters and no schema descriptions, this is a significant 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 states a specific verb ('Export') and resource ('spritesheet') with layout options and optional JSON metadata, which clearly distinguishes it from similar tools like ase_export_layers and ase_export_tag. It does not name siblings explicitly, but the resource and options make 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 does not provide any guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as the sprite being open, or when to prefer ase_export_sprite or ase_export_layers. The layout options are listed, but not explained in terms of use cases.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses the .gif animation vs .png sequence difference, the up-front validation that prevents Aseprite's silent all-frames fallback for a missing tag, and the default output path. It leaves overwrite behavior and other side effects unstated, but the most dangerous edge case is covered.

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

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

Three sentences, each earning its place: the format/output distinction, the validation warning, and the default path behavior. It is front-loaded and contains 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?

For a small export tool with two required parameters and an existing output schema, the description covers the key defaults and the critical validation trap. It is not fully complete because scale is undocumented anywhere and the description does not address what the tool returns, though an output schema lowers that latter burden.

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

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

Schema description coverage is 0%, so the description needed to compensate. It adds meaning for output_path via the default path and hints at tag_name behavior through the validation warning, but sprite_path is taken for granted and scale is entirely unexplained, leaving an agent without enough information to use that parameter correctly.

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 opens with a specific verb and resource ('Export an animation tag') and immediately clarifies the .gif vs .png output behavior. It clearly focuses on tags, distinguishing it from general sprite/spritesheet export siblings, though it does not explicitly name those alternatives.

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 this tool is for exporting a named animation tag, and the warning about Aseprite's --tag behavior provides relevant context. However, it never explicitly states when to prefer this tool over ase_export_spritesheet, ase_export_sprite, or ase_export_layers, nor does it give 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?

No annotations are present, so the description must carry full behavioral disclosure. It adds a tolerance range ('0-255') and labels the tool as flood fill, but it does not disclose side effects such as whether it modifies the active layer/frame, whether the fill is destructive, or how it interacts with selections or layers.

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 fluff. It efficiently names the operationeur and its key parameter, making it 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?

Given 7 parameters, zero annotation coverage, and no schema descriptions, the tool needs more context to be called correctly. The description leaves color format, frame/layer behavior, sprite_path meaning, and expected output unexplained, making it incomplete for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains tolerance (0-255) and implies x/y coordinates, but it does not describe the expected color format, sprite_path semantics, or frame/layer optional parameters. Seven parameters exist and only two are partially clarified.

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 ('flood fill') and resource ('from a point', 'paint bucket'), making the operation clear. It also distinguishes this tool from sibling drawing tools like ase_draw_pixels or ase_draw_rectangle, so an agent can differentiate without inspecting schemas.

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 about when to use this tool versus alternatives, no mention of prerequisites, and no exclusionary context. The description only says what the tool does, not when it should be selected.

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 does disclose the core destructive outcome: all layers are merged into one, which implies loss of individual layers. It does not mention irreversibility, hidden-layer behavior, or whether the change affects the saved file, but the essential behavior is stated.

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

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

The description is a single, front-loaded sentence with zero filler. It packs the operation and scope into five words and 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?

The tool is simple and an output schema exists, so return-value details need not be described. Still, the definition lacks any parameter elaboration or usage context, making it only minimally complete for an agent that must invoke 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?

Schema description coverage is 0%, and the description does not mention sprite_path at all. The only parameter is self-explanatory by name, but the description adds no guidance about how the path is used or what kind of sprite resource is expected.

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: flatten all layers in the sprite into one. This clearly distinguishes it from siblings like ase_merge_layer_down or ase_export_layers, which have different semantics.

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 to reduce the entire sprite to a single composite layer. However, it does not explicitly state when to choose this over ase_merge_layer_down or krita_flatten, nor does it mention any caveats such as hidden layers being affected.

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

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

No annotations are provided, so the description carries full burden of behavioral disclosure. It only states the action 'flip' without describing side effects (e.g., in-place mutation, undo behavior, impact on animations, or whether flipping the sprite affects all layers). This is a significant gap for a mutating 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?

The description is a single sentence with no wasted words, which is efficient. However, it is so terse that it omits important context. The core action is front-loaded, but the brevity borders on under-specification rather than polished conciseness.

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

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

Given there are 3 parameters, no annotations, and an output schema (which we don't see), the description is insufficient. It fails to clarify whether the operation modifies in place, what the return value contains, or how the 'sprite' vs 'active layer' choice behaves. The tool's complexity warrants more detail than a single clause.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly explains 'target' (sprite or active layer) and 'direction' (horizontal|vertical), which adds meaning beyond the raw parameter names. However, it does not clarify the required 'sprite_path' parameter, though its purpose is fairly obvious. It partially bridges the coverage gap.

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