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

With no annotations, the description bears the full burden of behavioral disclosure. It only indicates a mutation ('Add') without explaining whether the frame is appended, inserted at the current position, created blank, or loaded from the filename parameter. This leaves important side effects undisclosed.

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

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

The description is extremely concise with no wasted words and the core action is front-loaded. However, it is so terse that it sacrifices necessary semantic content, making it slightly under-specified for the conciseness criterion.

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

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

For a simple one-parameter tool, the description still omits critical context: what filename means, what type of frame is added, and how the frame is placed in the animation timeline. With no output schema and no annotations, the agent lacks enough information 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?

Schema description coverage is 0%, so the description must clarify the 'filename' parameter, but it does not. The name suggests a file, yet it is unclear whether filename is the image source, an output name, or something else. The parameter's meaning is entirely 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 states the exact action ('Add') and resource ('one animation frame'), and the singular 'one' weakly differentiates it from the sibling 'add_frames'. It lacks detail about the target animation or how the new frame relates to existing frames, so it is clear but not fully distinctive.

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 usage guidance is provided. The description does not specify when to use this tool over alternatives such as add_frames, set_frame, copy_frame, or delete_frame, and gives no context about preconditions or typical workflow placement.

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 disclosure. It only says 'add a deterministic number of animation frames,' leaving unclear whether frames are appended or inserted, what 'deterministic' means regarding frame counts, and any side effects on existing animation data. This is severely under-disclosed.

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

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

The description is a single sentence, which is concise, but it is too lean to be useful. It does not front-load any key distinctions or constraints. A sentence that adds little information is not efficient – it is merely brief.

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 absence of annotations, output schema, and rich parameter documentation, this description is grossly incomplete. It does not explain the relationship to sibling tools, the meaning of 'deterministic,' or expected behavior. An agent has almost no basis to call this tool correctly.

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

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

Schema description coverage is 0%, so the description must explain parameter meaning, but it mentions none of the three parameters (filename, count, duration_ms). An agent cannot infer what 'count' refers to or what duration_ms does from the description alone.

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 ('Add') and resource ('animation frames'), indicating the core operation. However, it does not differentiate from sibling tools like 'add_frame' or clarify whether multiple frames are added at once. The term 'deterministic' adds ambiguity, but the basic purpose is discernible.

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

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

No guidance is provided on when to use this tool versus alternatives such as add_frame, copy_frame, or propagate_frame_to_range. There is no mention of prerequisites, typical use cases, or scenarios where this tool is inappropriate.

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 for behavioral disclosure. It only says 'Add' without mentioning side effects (e.g., whether the document is mutated on disk, if the operation is undoable, or if it requires a saved file). For a mutation tool, this is a notable gap, though the simplicity of adding a layer group mitigates severity slightly.

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

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

The description is a single, front-loaded sentence with no wasted words. However, it is under-specified rather than efficiently complete, so it does not earn a high conciseness score because the brevity sacrifices necessary 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 no annotations, no output schema, and three parameters, the description should clarify parent_group semantics, document preconditions, and any return value. None are provided. For an agent to call this correctly, it would need to inspect the schema and guess behavior, which is a clear completeness gap.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters. The phrase 'named layer group' implies group_name is the name, but filename and parent_group are entirely unmentioned. The agent is left to guess the meaning of parent_group and its default behavior from the schema bare names.

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: 'Add a named layer group to an Aseprite document.' It clearly identifies the action and target document. It does not explicitly differentiate from add_layer, but the term 'group' inherently distinguishes the resource type, so it is specific enough for an agent to grasp the core function.

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

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

No guidance is provided on when to use this tool versus alternatives such as add_layer, create_tilemap_layer, or other layer operations. An agent must infer selection from the name alone, which is insufficient for confident tool choice.

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 conveys that this is a mutation and that placement inside a group is conditional, but doesn't say whether the group is auto-created, whether existing layers are affected, or what happens on name collisions.

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?

Eight words, with the action and key parameter both front-loaded. There is 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?

For a mutating, annotation-free tool with 3 parameters and no output schema, this is too thin. Missing filename semantics, group creation behavior, error conditions, and differentiation from sibling layer tools.

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 explain all parameters. It hints that layer_name is the layer's name and group is the optional parent group, but leaves filename completely unexplained despite being required.

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?

Identifies a specific action (add) and resource (named layer) with an optional group placement. Clear enough to distinguish from add_group/delete_layer, but doesn't state what filename refers to or how set_layer differs.

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 statement of when to use this vs add_group/set_layer or other layering operations. No mention of valid target files, group requirements, or whether the layer is inserted at a particular position.

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 present, the description carries the full burden of behavioral disclosure. 'Apply' implies modification, but the description doesn't state whether it's destructive, whether it operates on the whole sprite or a region, or whether it affects only the current frame/layer. Critical side effects are left undisclosed.

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

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

The description is a single concise sentence with no wasted words. It front-loads the core operation. However, it is so terse that it sacrifices necessary explanatory content, but for pure conciseness it's effective.

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 9 parameters, no output schema, and no annotations, this description is critically incomplete. It doesn't explain the operation's scope (layer/frame/region), the parameter semantics, expected return value, or side effects. 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?

Schema description coverage is 0%, and the description offers no parameter details. It doesn't explain that brightness/contrast ranges are -100 to 100, or the meaning of x/y/width/height, layer_name, or frame_index. The agent must guess from parameter names and defaults, which is inadequate for 9 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 clear verb ('Apply') and resource ('Aseprite native brightness and contrast adjustment'). It's specific enough to indicate the core operation, but it doesn't differentiate from sibling adjustment tools like 'adjust_hsl_native' or 'apply_color_grade'.

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 (e.g., adjust_hsl_native, apply_color_grade). There are no prerequisites, no mention of selection vs. full-layer scope, and no exclusions. Usage must be inferred entirely from the tool name.

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 does add useful context by constraining the operation to an opaque cel and stating that alpha is preserved. However, it omits whether the edit is in-place, reversible, what happens to semi-transparent pixels, and 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?

One sentence, front-loaded with the action, and no filler. Every clause adds relevant information: target, operation, scope, and preserved channel.

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 six-parameter mutation tool with no output schema and no annotations, the description is adequate but thin. The core operation is clear enough to invoke, but an agent is left without return-behavior or failure-mode expectations.

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 conveys the conceptual mapping from hue/saturation/lightness to the three shift parameters, but it does not explain the identifier parameters (filename, layer_name, frame_index) or the bounds/clamping behavior beyond what the schema already shows.

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 ('Shift') with a concrete resource ('opaque cel') and names the affected properties (hue, saturation, lightness), plus the alpha-preservation constraint. This clearly distinguishes it from nearby color tools like adjust_brightness_contrast and invert_colors.

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 for when to use this tool instead of related tools such as adjust_hsl_native, adjust_brightness_contrast, replace_color, or apply_color_grade. The 'opaque cel' phrase is the only implicit scoping, with no exclusions or prerequisites.

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 but only restates the operation. It does not disclose whether the adjustment is destructive, whether it applies to a region/layer/frame, what 'native' implies about behavior, or any side effects. This is a mutation tool with zero behavioral context.

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, but it is under-specified. It conveys only the basic operation and omits all parameter and usage context, so the brevity comes at the expense of completeness.

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

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

For a tool with 10 parameters, no schema descriptions, no output schema, and no annotations, this one-line description is clearly inadequate. An agent cannot know the spatial scope, layer/frame targeting, or the meaning of 'native' in Aseprite context, leaving most invocation-critical information missing.

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 mentions hue, saturation, and lightness but gives no meaning for filename, x, y, width, height, layer_name, frame_index, nor any guidance on ranges or interaction. An agent has to infer the role of 7 undocumented 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?

States a concrete operation ('Apply Aseprite native hue, saturation, and lightness adjustment') with a specific verb and resource. However, it does not explicitly distinguish itself from the sibling 'adjust_hsl' tool, relying on the word 'native' to imply the difference.

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 no guidance on when to use this tool versus alternatives like 'adjust_hsl' or other color-adjustment tools. No exclusions, prerequisites, or context are given, so an agent cannot decide between this and its siblings.

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

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

Annotations are absent, so the description must disclose behavioral traits. It only says 'Normalize' and 'repair,' implying mutation, but it does not state whether the file is modified in place, what happens to out-of-range cels, whether it is destructive, or what the return value looks like. This is a critical gap for a tool that clearly alters animation data.

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 concise. However, it is severely under-specified and lacks structure – there is no front-loading of key information like side effects or typical invocation context. The brevity is not an asset because it omits essential details.

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 high parameter count (17), no annotations, and no output schema, the description is grossly incomplete. An agent cannot correctly call this tool without understanding what each parameter does, what the repair action entails, or what the expected outcome is. This is far below the minimum viable level.

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% – the schema provides only types and constraints, no descriptions. The tool description does not mention any of the 17 parameters, so it adds no meaning beyond what the schema already shows. Parameters like 'out_of_range_action' and 'layer_names' are opaque without context.

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

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

The description states a specific verb ('Normalize') and resource ('animation cels') and mentions an optional repair action. It distinguishes from siblings like inspect_animation_quality or normalize_sprite by focusing on cels and out-of-range activity, though the exact meaning of 'normalize' is not defined.

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 any alternative. It does not mention prerequisites, typical use cases, or conditions under which the repair option should be chosen. With 17 parameters and no context, an agent cannot decide when to invoke it.

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

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

With no annotations, the description carries the behavioral burden and does add useful traits: the result is 'deterministic' and 'concise,' and 'Return' implies a read-only action. However, it does not describe the response format, error behavior, or any side effects, leaving some uncertainty.

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 earns its place: it states the action, the output nature, and the supported workflow domains.

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 low complexity with one optional parameter, but there is no output schema or annotations, so the description is the only behavior source. It provides enough to invoke the tool by choosing among character/environment/general, but it leaves the actual guide contents and exact return representation unspecified.

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's only parameter, use_case, has no description (0% coverage), so the description must compensate. It names the three workflow categories—character, environment, and general—that map to likely input values, giving an agent meaningful guidance 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 action ('Return') and a concrete object ('concise deterministic guide'), then scopes it to character, environment, or general animation workflows. This clearly distinguishes the tool from sibling tools that perform direct edits, generation, or inspection.

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 character, environment, or general animation workflows' gives clear contextual guidance on when to use this tool. It does not explicitly name exclusions or alternative tools, but the domain and purpose are clear enough for selection.

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 alone must disclose side effects and behavior. It adds the useful trait 'deterministic,' but does not state whether the source sprite is modified, whether a new output file is created, which formats are supported, or whether the operation is reversible/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 single sentence is economical and front-loads the core action and deterministic nature, with no filler. However, the extreme brevity comes at the cost of omitting necessary parameter and usage 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?

For a 6-parameter tool with no annotations and no output schema, the description is too thin. It leaves out input/output file behavior, supported formats, value semantics, and the relationship to sibling adjustment tools, making correct invocation uncertain.

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 repeats the names brightness, contrast, and saturation without explaining their meaning or relationships. It does not clarify input_filename/output_filename semantics, the format enum, or how values like contrast=1 and saturation=1 should be interpreted.

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 ('Apply') and identifies the resource ('a sprite') plus the exact operations involved ('brightness, contrast, and saturation grading'). It is clear enough to distinguish the general purpose from unrelated siblings, though it does not explicitly differentiate from overlapping adjustment 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 given about when to use this tool versus siblings like adjust_brightness_contrast, adjust_hsl, or apply_convolution. The description implies a combined color-grading use case, but there are no explicit alternatives, conditions, 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 present, so the description must carry the safety/behavior disclosure. It does not state that applying a convolution matrix overwrites layer pixels, whether it respects selections/bounds, or whether the operation is reversible. The sentence implies pixel modification but gives no side-effect or state-change detail.

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, no filler, and the operation is front-loaded. Efficient, though the brevity comes at the cost of substance captured by 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?

For a tool with 8 parameters, no annotations, and no output schema, a single sentence is materially incomplete: required filename is absent, region parameters are unexplained, and available matrix names are not referenced. An agent has little basis for a correct first call.

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 echoes the param names 'layer' and 'frame' plus the 'built-in' nature of matrix. Required filename and the x/y/width/height region controls are left undefined, so it does not compensate for the schema 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 names the exact verb ('apply'), resource ('built-in Aseprite convolution matrix') and target ('layer and frame'), which is sufficient to differentiate it from sibling list_convolution_matrices and apply_dither_pattern. It is compact but 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 on when to prefer this tool over alternatives, nor any mention of the sibling list_convolution_matrices for discovering available matrix values. Prerequisites are absent; the only context is the operation 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?

With no annotations, the description carries the full burden. It adds useful behavioral information by stating the operation is 'deterministic' and that it preserves transparency and source data, implying non-destructive output. It omits important prerequisites, such as whether a depth or normal map is required, how unsupported inputs are handled, or the exact result of applying lighting.

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 qualifier—deterministic, depth-aware, directional, preserving transparency and source data—adds meaningful information 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?

Given six parameters, no annotations, no output schema, and zero schema descriptions, this definition is too sparse to fully support correct invocation. An agent cannot tell what depth information the tool relies on, how the parameters interact, or what output behavior to expect beyond writing to output_filename.

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 does not explain any parameter specifically. It only gestures at 'directional' and never clarifies how ambient, strength, or format affect the result; the agent must rely entirely on parameter names, enums, and defaults in the schema.

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

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

The description uses a specific verb ('Apply') and resource ('sprite') with precise qualifiers: 'deterministic depth-aware directional lighting.' This clearly distinguishes it from lighting-adjacent siblings like generate_normal_map, apply_convolution, or generate_sprite_shadow without needing to inspect 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?

The description implies a clear use case—adding directional depth lighting to a sprite—and notes that transparency and source data are preserved. However, it does not explicitly say when to prefer this tool over alternatives or provide any exclusions, so usage guidance remains inferential rather than explicit.

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

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

No annotations are present, so the description bears the full burden. It indicates a mutating fill operation, but does not disclose whether existing pixels are overwritten, how coordinates are interpreted, what happens when the layer/frame is missing, or any default behavior such as create_if_missing. Side effects remain implicit.

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 or repetition. It is efficient, though its brevity comes at the cost of missing parameter and context details that would make it more helpful.

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 11 parameters, no annotations, and no output schema, a one-sentence description is not enough. The agent is left to infer usage, side effects, and distinguishing behavior from parameter names alone, which is especially risky given the large sibling list of gradient, drawing, and dither tools.

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 names no parameter. 'Rectangle' loosely hints at x/y/width/height and 'two-color' hints at color_start/color_end, but there is no explanation of coordinate meaning, color format, or the optional horizontal and create_if_missing parameters. The description does not compensate for the schema's lack of 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 verb ('Fill'), a specific target ('rectangle'), and a distinct method ('two-color Bayer-dithered gradient'). This clearly differentiates it from non-dithered gradient tools like apply_gradient_rect and generic pattern tools like apply_dither_pattern, even without explicitly naming a 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?

No guidance is given for when to use this tool over alternatives. The description does not mention apply_gradient_rect, apply_dither_pattern, draw_rectangle, or any conditions, prerequisites, or exclusions, leaving selection entirely to the agent's inference.

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

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

No annotations are provided, so the description carries the full burden. It says 'Fill' which implies a mutating operation, but it doesn't disclose whether it creates the layer if missing (though create_if_missing param hints at it), whether it overwrites existing pixels, how density affects the pattern, or what happens with out-of-bounds coordinates. The description adds minimal behavioral context beyond the operation itself.

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, no waste, and the key concepts (rectangle, uniform Bayer dither, two colors) are front-loaded. It's appropriately concise for a simple operation, though it could add a bit more detail without becoming bloated.

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 an 11-parameter tool with no annotations and no output schema, the description is too thin. It doesn't explain the density parameter's role, the create_if_missing behavior, or how this relates to the layer/frame system. An agent would need to inspect the schema and guess at semantics for most parameters.

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 'two colors' (color_a, color_b) and 'rectangle' (x, y, width, height), but doesn't explain density, create_if_missing, frame_index, or layer_name semantics. The description adds some meaning for 2 of 11 parameters but leaves the rest 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 states a specific verb ('Fill'), a resource ('a rectangle'), and the method ('uniform Bayer-dithered mix of two colors'). It clearly distinguishes from the sibling 'apply_dither_gradient' by specifying 'uniform' and 'two colors'. However, it doesn't explicitly name the sibling or contrast with it, so it's clear but not fully differentiated.

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: when you need a dithered fill of a rectangle with two colors. It doesn't explicitly state when to use this vs. alternatives like apply_dither_gradient, draw_rectangle, or fill_area. The context is clear enough for an agent to infer, but no explicit when/when-not guidance is 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?

With no annotations, the description carries the behavioral burden and does so well: 'deterministic', 'isolating per-file failures', and 'preserving every source' are meaningful behavioral guarantees beyond the raw schema. It does not cover all possible side effects, but it discloses the most important traits.

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

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

The description is one tight sentence that front-loads the action and packs in the three most important behavioral constraints: batch size, determinism, and failure isolation. There is no filler or repetition of schema fields.

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 no annotations and no output schema, the description would ideally explain expected results or per-file return behavior. It covers failure isolation but not what the caller receives, and it leaves meaningful parameter semantics to the schema. It is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only adds 'up to 24' (mirroring maxItems) and 'deterministic' (loosely related to seed), leaving goals, seed, max_colors, and output_filename semantics unexplained. The schema's enums and defaults help, but the description does not carry its share.

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 ('Enhance'), a resource ('assets'), a scope ('up to 24'), and a batch mode. It also distinguishes itself from single-asset or non-deterministic tools by adding 'in one deterministic batch', which helps separate it from siblings like apply_enhancement_plan.

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 'up to 24 assets in one deterministic batch' gives clear context for when this tool is appropriate: multi-asset enhancement with deterministic output and per-file failure isolation. It does not explicitly name alternatives or exclusions, but the batch/cap language provides usable usage 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 must disclose side effects itself. It does usefully state that the tool is deterministic, creates a new output file, and preserves the source asset. However, it does not explain what happens if the output file exists, whether the plan is provided as a parameter or referenced elsewhere, or what the tool returns on success or failure.

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 tight sentence with no filler, and the most important behavioral facts are front-loaded. It loses a point only because it omits enough substantive detail that the conciseness comes at the cost of usefulness.

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

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

This is a 6-parameter tool with no output schema and no annotations, yet the description does not explain what an enhancement plan is, where it comes from, or how the parameters influence the result. The minimal 'new output file while preserving source' context is helpful but far from sufficient 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 adds no parameter-level meaning. It does not clarify that filename is likely the source asset, output_filename is the new file, or what goals, seed, max_colors, and format control. The enum values for goals are left entirely 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 names a concrete action ('Apply'), a specific resource ('enhancement plan'), and the target behavior ('to a new output file while preserving the source asset'). This clearly distinguishes it from the sibling apply_enhancement_batch, which operates on multiple items, and from suggest_enhancement_plan, which only creates a plan.

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 versus suggest_enhancement_plan or apply_enhancement_batch. The phrase 'deterministic enhancement plan' implies a prior plan exists, but the description never states that precondition or any alternative-selection condition.

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 not explain the effect of create_if_missing, whether existing pixels are overwritten, coordinate semantics, or whether the operation is destructive. For a mutation tool, 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 with no filler. It front-loads the action and target, and every phrase contributes to the core purpose.

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

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

With 11 parameters, 9 required, no output schema, and no annotations, this one-sentence description is insufficient. It omits orientation defaults (horizontal defaults to true), layer creation behavior, coordinate interpretation, and expected return values, making correct invocation difficult.

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 11 parameters by name. It only conveys the general concept of a gradient rectangle, leaving agents to infer the meaning of color_start, color_end, horizontal, create_if_missing, and coordinate fields from names alone.

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 operation ('Apply'), the gradient type ('horizontal or vertical linear gradient'), the target shape ('rectangle'), and the target context ('named layer and animation frame'). This clearly distinguishes it from related drawing tools like draw_rectangle and apply_dither_gradient.

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

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

The description clearly implies when to use it: when a linear gradient rectangle is needed on a specific layer/frame. However, it does not explicitly mention alternatives or exclusions, leaving some selection burden on 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 burden of behavioral disclosure. It usefully states that results are deterministic and that transparency and source data are preserved, which are meaningful operational traits. However, it does not say whether the input file is overwritten, whether a new output file is written, what format constraints apply, or what failure modes 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?

The description is a single, compact sentence with no filler, and it front-loads the tool's material set and key guarantees. The term 'granularity' is somewhat vague, but overall the length is appropriate for the information provided.

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 six-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin to fully support correct invocation. It does not explain the intensity parameter, seed behavior, format handling, or whether the result replaces the input or produces a new file, and the large sibling list contains many apply_* tools with no exclusionary guidance.

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 restates the material enum and adds no explanation for seed, intensity, format, input_filename, or output_filename. The agent is left to infer the role of output_filename and the meaning of determinism in relation to seed from parameter names alone.

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 ('Apply') and clearly enumerates the supported materials (water, earth, grass, stone, snow), so an agent can tell what resource it operates on. It does not explicitly contrast itself with sibling image-processing tools like apply_convolution or generate_seamless_texture, but the name and material list make the core intent reasonably clear.

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 generate_seamless_texture, apply_dither_pattern, or apply_pixel_outline. The description implies an image-processing context but provides no when-to-use, when-not-to-use, or prerequisites, so an agent must infer selection from the name and materials alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but does not explain side effects (e.g., whether it modifies the sprite in place, affects all frames, requires an existing sprite, or returns a result). This is insufficient 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 sentence, which is concise and front-loaded. However, it is so brief that it omits critical usage and parameter details, making it less effective. It earns its place but could be more informative 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?

For a tool with two required parameters, no output schema, and no annotations, the description is incomplete. It does not explain how to specify the preset or what the expected outcome is. An agent would struggle to invoke it correctly without additional 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 does not clarify the parameters. It hints at the preset parameter by mentioning 'built-in retro palette preset' but does not list valid preset values or explain what 'filename' refers to. No guidance on parameter format or required context.

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

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

The description states a specific verb 'apply' with a clear resource 'built-in retro palette preset' and target 'sprite'. This clearly distinguishes it from siblings like list_palette_presets (which lists) and set_palette (which sets a palette directly). It is unambiguous 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?

No guidance is given on when to use this tool versus alternatives such as set_palette, list_palette_presets, or extract_palette. The description does not mention prerequisites, typical use cases, or situations where this tool should be preferred over others.

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 disclosure burden, but it only says 'Add a deterministic pixel outline.' It does not disclose whether the tool writes to output_filename, modifies inputs, handles transparency/alpha, or what happens with formats, thickness, or missing colors. 'Deterministic' is a small transparency gain, but significant behavioral context is absent.

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. It conveys the core behavior and a key property ('deterministic') in minimal space, which is appropriate for conciseness even though more detail is needed elsewhere.

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 5 parameters, no output schema, no annotations, and 0% schema coverage, this description is too sparse for an agent to confidently invoke the tool. It omits which fields are required, how thickness interacts with the outline, what format defaults to, and what the result looks like. The moderate complexity of the tool demands more operational context than one sentence provides.

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 meaning for any of the 5 parameters. It does not mention color, thickness, format, or how input_filename/output_filename relate to the operation. The schema provides structural constraints, but the description fails to compensate for the complete absence of parameter-level guidance.

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 ('Add') and resource ('pixel outline around opaque sprite edges'), and 'deterministic' adds useful precision. It does not explicitly distinguish itself from closely related siblings like outline_native or apply_convolution, but the phrase 'opaque sprite edges' gives enough scope for a clear purpose.

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

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

No guidance is provided for when to use this tool versus alternatives such as outline_native, generate_sprite_shadow, or apply_convolution. The description does not state any exclusions, prerequisites, or conditions that would help an agent choose this tool over its siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions 'audit' without clarifying whether it is read-only, whether it modifies the file, what it returns, or any side effects. This is a significant gap for a tool that likely produces a report or validation results.

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, which is concise and front-loaded. However, it is so short that it provides minimal additional value beyond the tool name, and it does not structure any additional context. It is not verbose but also not sufficiently 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 has 10 parameters, no output schema, and no annotations, the description is grossly inadequate. An agent cannot determine how to invoke the tool correctly, what inputs are expected, or what the output will be. The description fails to cover essential context for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It only mentions 'cels, overlaps, and declared frame ranges,' which hints at the tool's purpose but does not explain any of the 10 parameters like filename, start_frame, end_frame, layer_names, report_cels, max_overlaps, overlap_pairs, report_bounds, max_out_of_range, or layer_frame_ranges. The description adds almost no meaning beyond the schema.

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

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

The description states a specific verb (Audit) and resources (animation cels, overlaps, declared frame ranges), which clearly distinguishes it from other audit tools like audit_asset_library. However, it does not explicitly tie it to a file or sprite, though the name and context imply it. It is clear enough for an agent to know the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives such as inspect_animation_quality or animation_sanitize. It only states what it does, not the conditions under which it is the preferred choice. An agent must infer usage from the name and sibling 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 must carry the behavioral disclosure burden. It lists what is audited, implying a read-only inspection, but does not disclose what an audit produces, whether it can fail, or whether it has any side effects. 'Audit' weakly suggests non-destructive behavior, but the agent is left guessing about the result.

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 an active verb, a precise list of audited resources, and a useful temporal context ('before composing a scene'). There is no filler or redundant restatement of the tool name.

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 no output schema and no annotations, the description should explain what the agent will receive or what a completed audit looks like. It clearly states scope and timing but omits the tool's result format and any error/failure semantics, leaving a meaningful gap for a tool with no structured output metadata.

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

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

The tool has zero parameters and the empty schema fully covers parameter semantics, so there is no additional burden on the description. A baseline of 4 is appropriate; there is no parameter information that could be added.

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, 'Audit', and lists concrete resources: library ids, preset references, categories, folders, and navigable asset paths. It is not a tautology and gives a clear sense of what the tool examines. It stops short of a 5 because it does not explicitly distinguish itself from similar-looking siblings like audit_asset_manifest or summarize_asset_library.

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

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

The phrase 'before composing a scene' provides a clear temporal/usage context, telling the agent when this tool is relevant. However, it does not state when not to use it or name alternatives such as audit_asset_manifest, so it misses full routing guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal the checks performed (missing, empty, format, SHA-256 metadata), which is useful. However, it does not state whether the tool is read-only or mutating, whether it returns a report or fixes issues, or what 'format' validation covers. This leaves meaningful behavior undisclosed.

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

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

A single sentence that front-loads the core action and resource, then lists the audit dimensions. Every word earns its place, with no redundant filler or repetition of schema details.

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

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

For a one-parameter tool, this is close to adequate: an agent can identify when to use it and what input to provide. However, without annotations or an output schema, the absence of any statement about return values, side effects, or failure behavior leaves a meaningful gap in the round-trip understanding of calling the tool.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter. It connects manifest_filename to the 'generated manifest' concept, which adds some meaning beyond the bare schema. Still, it does not explain what the filename should reference, what file types are expected, or how the manifest locates its files, leaving room for invocation ambiguity.

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 ('audit') and resource ('files referenced by a generated manifest') and enumerates the exact audit dimensions: missing, empty, format, and SHA-256 metadata. This clearly differentiates it from related siblings like audit_asset_library or inspect_asset_batch, which target different resources or scopes.

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 case is implied: use when a generated manifest exists and its referenced files need validation. However, there is no explicit guidance about when not to use it, what prerequisites exist, or how it compares to nearby audit/inspect tools such as audit_asset_library or inspect_asset_bundle. The agent must infer routing 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only hints at 'in order or return one batch plan' but does not disclose side effects, default dry_run behavior, failure handling, or whether jobs execute asynchronously.

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 with a front-loaded verb and no filler. It is efficient, though it sacrifices useful detail for brevity.

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 moderate complexity, no annotations, and no output schema, the description is incomplete. It omits dry_run semantics, job ordering guarantees, error behavior, and how results or a batch plan are returned.

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 does not explain the jobs array structure or the dry_run parameter. The phrase 'or return one batch plan' weakly implies dry-run behavior, but the agent cannot reliably map that to dry_run=true.

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 ('Run') and resource ('several compact asset recipes'), and clarifies the batch/planning scope. It distinguishes this from single-recipe siblings like run_asset_recipe, though it does not disambiguate from similar batch/job tools such as start_asset_job.

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

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

No explicit guidance on when to use this tool versus alternatives like run_asset_recipe, execute_asset_recipe, or start_asset_job. The description also does not explain when an agent should set dry_run versus run the jobs for real.

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 it does well: 'deterministic' discloses ordering/reproducibility guarantees, and it explicitly states that coordinates, bottom-center pivots, and delays are written to a manifest. It does not mention overwrite behavior or failure conditions, but the core side effects are 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?

A single sentence that front-loads the action and output, with every clause adding useful information: determinism, file formats, spritesheet output, and manifest contents. No filler or redundant restatement of the tool name.

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 five parameters and no output schema, the description covers the essential calling context: input formats, output format, and what the manifest contains. It is slightly incomplete on column/padding behavior and manifest format details, but an agent can meaningfully invoke the tool with the information provided.

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 clarifies that input_filename accepts a PNG or GIF, output_filename is a PNG spritesheet, and manifest_filename holds coordinates, pivots, and delays. However, columns and padding are not explained at all beyond the schema's numeric constraints and default.

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

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

The description names a specific action (assemble), a resource (frames of a PNG or GIF), and a concrete deliverable (deterministic PNG spritesheet plus manifest with coordinates, bottom-center pivots, and delays). It is distinct enough from siblings like build_contact_sheet or export_spritesheet because it emphasizes animation metadata and determinism.

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 'Assemble all frames of a PNG or GIF' implies when this tool applies, and the mention of a manifest implies it is for animation workflows rather than simple spritesheets. However, there is no explicit when-not-to-use guidance or alternative routing to siblings such as build_contact_sheet or export_spritesheet.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal determinism and the creation of a JSON manifest, but it omits important behavior such as whether existing output files are overwritten, whether input files must exist, or what happens on failure.

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, dense sentence with no wasted words and front-loads the core purpose. It is well-structured, though it sacrifices useful parameter and usage detail for brevity.

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

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

Given 7 parameters, no annotations, no output schema, and a large sibling toolset, this one-sentence description is not complete enough for an agent to invoke the tool correctly with confidence. The manifest structure, layout semantics, and relationship to similar sheet-building tools are all unspecified.

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% parameter description coverage and the description does not compensate. None of cell_width, cell_height, columns, padding, or the filename parameters are explained beyond their names, leaving the agent to guess layout semantics and expected formats.

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 job: fitting heterogeneous sprite previews into a nearest-neighbor contact sheet and writing a JSON manifest. It is specific about the resource and output, but it does not explicitly differentiate itself from close siblings like build_animation_sheet or export_spritesheet.

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 choose this tool over alternatives such as build_animation_sheet, export_spritesheet, or inspect_asset_batch. No use-case context, exclusions, or sibling comparisons 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 provided, the description must carry the burden of behavioral disclosure. It only states 'deterministic operation' which hints at predictability but does not mention side effects, required permissions, output structure, or any state changes. This is a significant gap for a tool that builds multiple outputs.

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 fluff, clearly stating the core purpose. It is appropriately concise but lacks the depth needed to cover parameters or usage context. It is well-structured for the little it conveys.

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 seven parameters (four required) and no output schema, this description is woefully incomplete. It does not explain what the outputs look like, what the parameters control, or any prerequisites. An agent would not know how to call this tool correctly without additional information.

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

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

Schema description coverage is 0% and the description does not explain any of the seven parameters (item_ids, output_prefix, width, height, frames, padding, delay_ms). An agent cannot infer parameter semantics from the description alone, making this nearly useless for parameter understanding.

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 specific outputs (static PNG scene, animated GIF scene, navigation manifests) and the deterministic nature, which distinguishes it from sibling tools like export_animation_gif or build_animation_sheet. It is specific about the resource and action.

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

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

The description provides no guidance on when to use this tool versus alternatives like build_animation_sheet or export_animation_gif. It does not mention any conditions, exclusions, or context that would help an agent choose this tool over others.

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 disclose one useful trait, 'deterministic', and indicates the bundle contains three artifacts, but it does not state whether files are written or overwritten, whether this is a pure build vs. an in-place mutation, or what side effects may occur. For a build/mutation-style tool without annotations, 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, tight sentence that front-loads the core purpose and key output contents. It contains no filler or redundant restatement of the tool name, making it both concise and useful.

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 high parameter count (10), five required parameters, no annotations, and no output schema, this short description is not complete enough. An agent can grasp the high-level purpose, but cannot confidently determine how the required filenames map to inputs/outputs, how optional parameters affect the result, or what the tool returns. More operational context is needed.

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 very little about the 10 parameters. It does suggest that filenames relate to the animation sheet, timing manifest, and hitbox manifest, but it does not explain input_filename, columns, hitbox_mode, sheet_padding, hitbox_padding, or min_component_pixels. Parameter names are somewhat self-explanatory, but the description itself does not compensate for the missing 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 names a specific verb ('Build') and a specific resource ('deterministic runtime bundle'), and clarifies the bundle's contents: animation sheet, timing manifest, and sprite hitbox manifest. It distinguishes itself from similar build/export tools like build_scene_bundle or export_spritesheet through the 'runtime bundle' framing, though it does not explicitly name sibling 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 gives no guidance on when to use this tool versus alternatives like build_animation_sheet, build_scene_bundle, or export_spritesheet. There is no mention of prerequisites, intended use cases, or exclusions, leaving the agent to infer applicability from the tool name and general phrasing.

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

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

With no annotations, the description carries the full burden. It discloses 'deterministic' (a useful trait) and implies output includes adjacency variants and metadata, but it does not state side effects (e.g., whether it writes files), return format, or operational constraints like performance or dependencies. This is a significant gap for a generation 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 sentence with no waste, but it is under-specified rather than concise. It does not front-load the most critical information (parameters, output) and is too terse to be helpful.

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 7 parameters, no output schema, and no annotations. The description provides almost no context about what the tool does beyond a high-level phrase, leaving an agent without enough information to invoke it correctly or interpret results.

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 mentions none of the seven parameters (seed, palette, terrains, tile_size, etc.). It provides no explanation of their meaning, relationships, or expected values, so it adds zero 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 a specific verb ('Build'), a resource ('terrain tileset'), and adds detail ('deterministic', 'adjacency variants', 'metadata') that distinguishes it from broader scene or map generation tools. It is not a tautology, but it does not explicitly name a sibling to differentiate from.

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 generate_world_map, generate_seamless_texture, or generate_biome_transition. The description does not mention conditions, prerequisites, or cases where another tool would be preferred.

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 conveys intent and target state but does not explain whether cancellation is synchronous or asynchronous, whether it is idempotent, what side effects occur, or how failures are reported.

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, redundancy, or unnecessary qualification. Every word contributes to meaning.

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

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

For a one-parameter tool, the description gives the essential target state, making the call minimally viable. However, with no output schema and no annotations, it omits behavioral details such as expected return value, error conditions for already-completed jobs, and how to verify cancellation success.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. It adds no information about job_id beyond the parameter name itself, such as where to obtain it, its expected format, or its relationship to status APIs.

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 ('Request cancellation') and a clear resource ('asset job'), and it qualifies the target state ('queued or running'). This distinguishes it from lifecycle siblings like start_asset_job and get_asset_job_status without requiring schema inspection.

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 'queued or running asset job' clearly indicates the conditions under which this tool applies. It does not name alternatives or exclusions, but the state constraint is enough to guide basic selection among the job lifecycle 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. It states the destructive action ('Delete') but doesn't disclose whether deletion is reversible, whether it affects other frames or layers, or what happens if the cel doesn't exist. No mention of return values or 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 a single concise sentence that front-loads the action and resource. It earns its place but could add a bit more context 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?

For a destructive mutation tool with no annotations and no output schema, the description is thin. It doesn't explain the cel concept, the effect on the animation, or error conditions. Sibling tools like delete_frame and erase_region suggest related operations, but the description doesn't help an agent choose among them.

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 'named layer and frame' which maps to layer_name and frame_index, but filename is not mentioned. The description adds minimal meaning beyond the schema's property names.

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 a cel from a named layer and frame' clearly states the action (delete), the resource (cel), and the context (named layer and frame). It distinguishes itself from sibling tools like create_cel, copy_cel, and set_cel_position, 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?

No guidance is provided on when to use this tool versus alternatives like erase_region, delete_frame, or clear_cel-related operations. The description implies usage for deleting a cel but doesn't state prerequisites (e.g., cel must exist) or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the output format (JSON metrics) and implies a read-only operation, but does not clarify whether frames are flattened internally, what happens on invalid input, or any side effects. Some useful context (flattened frames) is given, but more could be said.

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 that is front-loaded with the purpose and contains no filler. It is concise and easily scanned.

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 three parameters, no output schema, and no annotations, the description is incomplete. It does not specify what 'changed-pixel metrics' includes (e.g., counts, bounding boxes, thresholds), nor does it mention error handling or edge cases. An agent would need more guidance to reliably interpret the result.

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 mentions 'two flattened animation frames' which maps to frame_a and frame_b, and 'filename' is implied, but it does not explain that these are integer frame indices or what the filename refers to. The description adds minimal meaning beyond the schema.

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

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

The description states a specific verb ('Compare'), a clear resource ('two flattened animation frames'), and the output ('changed-pixel metrics as JSON'). It is unambiguous and distinguishes itself from all sibling tools, none of which perform frame comparison.

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

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

The description implies when to use the tool (whenever you need to compare two frames), but provides no explicit context, alternatives, or exclusions. Since there are no other comparison tools among siblings, the usage is fairly obvious, but the description does not articulate 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?

No annotations are provided, so the description carries the full burden. It indicates the output is 'compact assets and ordered layers,' but does not disclose whether the operation mutates state, has side effects, requires specific prior steps, or what happens on invalid preset IDs.

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 phrase—'one scene preset,' 'compact assets,' 'ordered layers,' 'single low-token request'—adds useful information without redundancy.

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

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

For a tool with one parameter and no output schema, the description gives a reasonable summary of input and output, but it omits important context: the definition of a scene preset, whether the operation is read-only or creates/modifies state, and what an agent should do if no preset exists. Sibling context suggests more composition guidance 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?

The schema only defines 'id' as a string with minLength 1 and has no parameter descriptions. The tool description mentions 'one scene preset,' which helps the agent infer that 'id' is a scene preset identifier, but it does not explicitly bind the parameter to that meaning or explain where the ID comes from.

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

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

The description uses a specific verb and resource: 'compose one scene preset' into 'compact assets and ordered layers.' It clearly states the tool's main purpose so an agent can infer what it does, though it does not explicitly differentiate it from sibling tools like compose_asset_scene or compose_asset_scene_animation.

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 usage context: when an agent has a single scene preset and wants a compact, low-token asset/layer result. However, it gives no explicit guidance about when to prefer this over related tools such as compose_asset_scene, generate_asset_preset, or plan_asset_scene.

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 adds useful context by stating the output is deterministic and includes a manifest, and it implies the operation reads selected library previews. However, it does not disclose side effects such as overwriting files, whether source assets are modified, or behavior on missing/invalid items.

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 the core action and outputs are front-loaded. It is concise, though the density of ideas (deterministic PNG, navigable manifest, selected previews) could benefit from a bit more 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?

For a 6-parameter tool with no output schema and no annotations, this description is too sparse. It omits usage distinctions, parameter semantics, and behavioral caveats, leaving the agent to infer too much from sibling names and schema property names 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?

Schema description coverage is 0%, so the description should compensate, but it only loosely maps 'selected library previews' to item_ids and 'PNG'/'manifest' to the filenames. It does not explain how width, height, or padding control layout, or what constraints like the 24-item limit mean in practice.

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 verb and resource: composing selected library previews into a deterministic PNG and navigable manifest. It doesn't explicitly differentiate from siblings like compose_asset_scene_animation or plan_asset_scene, but the output format and deterministic qualifier give reasonable distinctiveness.

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 choose this tool over alternatives. The description implies it is for composing previews into a static PNG with a manifest, but it does not contrast with compose_asset_scene_animation, build_scene_bundle, or build_contact_sheet, leaving selection 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 carries the full burden of behavior disclosure. It adds useful context like 'deterministic' and the output artifacts, but does not state whether the tool writes files, whether it is destructive, what input state is required, or what happens on failure. This is a significant gap for a composition 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 with a clear subject-action-object structure and no filler. It is not bloated, though its brevity limits the amount of guidance it can provide.

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, 8 parameters, no annotations, no output schema, and many closely related siblings, this description is under-specified. It gives the core idea but omits usage context, parameter semantics, file side effects, and the relationship to alternative composition/export tools.

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 does not explain the eight parameters. It loosely maps item_ids to 'selected animated library previews' and filenames to 'GIF and frame manifest', but width, height, frames, padding, delay_ms, and manifest details are left undocumented, forcing the agent to guess their meaning.

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 names the action (compose), the resource (selected animated library previews), and the output (deterministic GIF and frame manifest). This distinguishes it well from siblings like compose_asset_scene and export_animation_gif by emphasizing both animation and the manifest artifact.

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 when-to-use guidance or alternatives. It does not explain when to choose this tool over compose_asset_scene, export_animation_gif, build_animation_sheet, or plan_asset_scene, leaving the agent to infer context from the name and siblings.

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

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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses that all frames are converted and delays are preserved, but it does not mention output file overwrite behavior, whether the input is modified, failure conditions, or result format. These are meaningful gaps for a conversion 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 filler. Every word contributes: the operation, the scope, the target style, and the key preservation constraint.

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 8 parameters, no annotations, and no output schema, this one-clause description is incomplete. It gives a high-level purpose but omits parameter guidance, expected outputs, overwrite semantics, and how to adjust conversion quality or resize behavior.

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 mentions none of the 8 parameters or their semantics. It does not explain width, height, dither, max_colors, resize_mode, or alpha_threshold, so an agent must infer their meaning from parameter names and enums alone.

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'), a specific resource ('all image frames'), and the target style ('pixel art') while adding the distinctive preservation of animation delays. This clearly differentiates it from the sibling convert_image_to_pixel_art, which presumably targets a single image.

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 'all image frames' and 'preserve animation delays' implies this is for animated inputs, which gives some usage context. However, it never explicitly states when to prefer this over convert_image_to_pixel_art or other pixel-art/sprite tools, and it provides no exclusions or alternative routing.

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. It does disclose determinism and a shared palette, which is useful, but it does not mention file overwrite behavior, input requirements, or output format. This is thin for a file-conversion 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, tightly worded sentence with no filler. The most distinguishing facts are front-loaded, and 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?

With eight parameters, no annotations, and no output schema, this one-sentence description leaves too much unsaid: required parameter roles, enum behavior, and expected output are all missing. An agent gets the high-level purpose but not enough to reliably 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?

Schema description coverage is 0% and the description mentions none of the eight parameters, their constraints, defaults, or relationships. Terms like 'image' and 'palette' only hint at the domain and do not compensate for the missing parameter guidance.

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 ('Convert'), a single resource ('one image'), and the target result ('pixel art') with a useful qualifier ('deterministic shared palette'). The phrase 'one image' clearly differentiates it from the sibling convert_animation_to_pixel_art.

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 is for a single still image rather than an animation, but it does not explicitly say when to use this tool versus alternatives. It names no sibling tools and gives no when-not-to-use conditions, so usage context is only implied.

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

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

With no annotations, the description carries the burden and does disclose that the destination is replaced 'by default'. However, it does not explain what happens when replace=false, whether source content is preserved, or what the function returns. This is partial transparency for a potentially 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 efficient sentence, front-loaded with the action and target. The default replacement behavior adds meaningful detail without padding. Slightly more explicit parameter mapping would improve it, but it 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?

Given no annotations and no output schema, the description is too thin for a 5-parameter mutation tool. It lacks details on the replace parameter's semantics, failure conditions, prerequisites (e.g., layer existence), and the behavior when the destination cel contains content. An agent could misuse this tool without more 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 meaning. It clarifies the domain ('layer cel') and the default replace behavior, and implicitly maps source_frame/target_frame. Yet it does not explicitly explain the replace parameter's effect or frame indexing conventions, leaving gaps.

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 ('one layer cel') with a clear source and destination ('to another frame'), and it adds the default replacement behavior. It does not explicitly name sibling tools like copy_frame or copy_sprite, but the layer-cel specificity gives it enough distinctiveness.

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 about when to use this tool versus alternatives such as copy_frame, copy_sprite, or propagate_cels. There are no conditions, prerequisites, or exclusions provided, leaving the agent to infer the use case.

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, but it only restates the core action. It does not disclose what happens when target_frame is omitted, whether overwrite truly replaces existing cels, or how cel properties like position and opacity are preserved.

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 with no filler, and the core operation is front-loaded. It is slightly too terse to be fully helpful, but it earns its place and avoids redundancy.

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

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

For a mutation tool with four parameters, no output schema, and no annotations, this description leaves too much unstated. An agent cannot confidently determine how to trigger append versus overwrite, or what behaviors to expect when copying into an existing frame.

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 implies the roles of source_frame and target_frame. It does not explain filename, overwrite, or the optional nature of target_frame for the append behavior.

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 operation—copying all cels from one frame to another—which clearly distinguishes it from single-cel tools like copy_cel. It also includes the append-a-new-frame option, though it does not explicitly name sibling 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?

There is no guidance on when to use this tool versus related frame/cel tools such as add_frame, duplicate_frame_range, or propagate_cels. No conditions, prerequisites, or exclusions are provided, so the agent must infer appropriate usage.

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 side effects. It only says 'Copy' and does not mention that the target may be modified, that replace defaults to true, how missing frames are handled, or what happens when layers with matching names already exist in the target.

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 verb and resource. It contains no filler or redundant restatement of the tool name.

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

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

This is a cross-document mutation-style tool with no annotations, no output schema, and 0% parameter coverage, but the description provides only the basic operation. An agent lacks essential context about default behaviors, overwrite semantics, and frame handling, so the definition is not complete enough for correct invocation in non-trivial cases.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It vaguely maps 'one Aseprite document into another' to source/target filenames and 'layers' to layer_names, but it says nothing about the replace or create_missing_frames booleans, nor how 'cels' are selected.

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'), a specific resource ('animation layers and cels'), and a clear destination ('from one Aseprite document into another'). This distinguishes it from within-document siblings like copy_cel and copy_frame, though 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?

There is no guidance about when to use this tool versus alternatives such as copy_sprite, export_layers, or within-document copy operations. The intended use is implied by the action, but no conditions, exclusions, or alternative routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the high-level operation and does not say whether the source is left untouched, whether the destination area is overwritten or composited, how out-of-bounds coordinates behave, or what the function 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 concise and front-loaded in a single sentence. However, it is under-specified for an 11-parameter operation, so the brevity comes at the cost of useful structure and 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?

For a tool with 11 parameters, 9 required, no annotations, and no output schema, this description leaves almost every decision to the agent. It does not clarify coordinate frames, defaults, mutation semantics, or return behavior, making it insufficient 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 needed to explain the roles of the 11 parameters. It only hints at a rectangular region and a layer/frame destination, without mapping x/y/width/height to source geometry, dest_x/dest_y to placement, or describing the defaults of target_layer_name and target_frame_index.

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 rectangular region') plus a destination ('layer and frame destination'). It is not a tautology and broadly distinguishes the tool from siblings like move_region (copy vs move) and copy_sprite/copy_cel (region vs whole asset), though it does not name any 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?

There is no guidance on when to use copy_region instead of related tools such as move_region, erase_region, copy_cel, copy_frame, or draw_rectangle_at. The description implies a copy use case but provides no conditions, exclusions, or alternatives.

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 behavioral disclosure burden. It usefully reveals a non-obvious safety behavior: 'refusing to overwrite by default.' However, it does not disclose what happens when overwrite is false and the output exists, whether the destination document must already be open, or the operation's failure modes.

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

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

The description is a single, compact sentence with no filler. The core action and the key caveat about overwriting are both front-loaded with maximum efficiency.

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

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

The description is adequate for a straightforward copy operation, but it omits several details an agent may need: whether the destination document is created or must already exist, how filename and output_filename should be specified, and what error or return value occurs when overwrite is refused. Without annotations or an output schema, these gaps are noticeable.

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 schema's lack of parameter documentation. It does relate 'to another Aseprite document' to output_filename and 'refusing to overwrite by default' to the overwrite parameter, but it leaves the source filename parameter implicit and does not clarify expected formats or paths.

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 verb ('copy') and resource ('a sprite'), with a precise destination ('another Aseprite document'). This distinguishes it from sibling tools like copy_cel, copy_frame, and copy_region, which operate on smaller elements rather than the whole sprite.

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

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

The description provides clear context: it is for copying an entire sprite across documents, which differentiates it from same-document copy operations among the sibling tools. It does not explicitly name alternatives or provide when-not-to-use guidance, but the intended use case is unambiguous.

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

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

With no annotations, the description must carry behavioral disclosure; it does disclose non-execution, determinism, and reviewability. However, it does not state whether composing creates or persists anything, what side effects occur, 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?

A single sentence with no filler; the key intent and the execution boundary are 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?

The tool has 8 parameters, no output schema, and no annotations, so a single high-level sentence is not enough. The description leaves undefined what a 'recipe' returns, how seed, format, material, and direction influence it, and what the steps represent beyond their enum labels.

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 parameter-level meaning. All 8 parameters, including enums like steps, material, and direction, are left entirely to the schema's bare type and enum definitions.

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

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

The description uses a specific verb and resource ('Compose ... multi-effect asset recipe') and adds a critical boundary: 'without executing it.' This clearly distinguishes it from sibling execution tools like run_asset_recipe and execute_asset_recipe.

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

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

The phrase 'without executing it' gives clear context for when to use this tool rather than an execution sibling, and 'reviewable' signals usage for planning or auditing. It does not explicitly name alternative tools, which keeps it just below a 5.

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

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

With no annotations, the description carries the full burden, but it only says 'create a new,' implying non-destructive creation without explaining side effects, whether a new document/tab is opened, or whether an existing sprite is required. The word 'new' gives slight confidence of non-overwrite, but no real behavioral detail is 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?

A single sentence containing no fluff communicates the core operation immediately. It is appropriately short for the simplicity of the tool, though it could afford a small amount of added context 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?

For a three-parameter, no-annotation, no-output-schema tool, the description is thin. It omits behavior, parameter semantics, and return/output expectations, so an agent has to make assumptions about what 'create canvas' modifies and what it produces.

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 does not explain width, height, or filename. The Aseprite context makes it plausible they are pixel dimensions and a canvas name, but units, file implications, and relationships are left 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?

Describes a specific action (create) and resource (new Aseprite canvas), so an agent knows it instantiates a blank canvas rather than modifying an existing one. It does not explicitly contrast with siblings like resize_canvas or crop_canvas, but the verb and 'new' make the intended operation 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 when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives or state prerequisites, leaving the agent to infer that this is for starting from scratch versus using resize_canvas or import_image_as_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?

Annotations are absent, so the description must carry behavioral information. It usefully discloses the conditional non-overwriting behavior, but does not explain what happens if a cel already exists, how x/y positioning factors in, or any side effects/errors.

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, tightly worded sentence with no filler or redundancy. Every phrase contributes meaning.

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, no output schema, and zero parameter documentation, this one-liner is not sufficient. It omits the roles of filename, x, and y, plus any return value or edge-case behavior.

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%, yet the description only references layer and frame. It leaves filename and x/y meanings to inference and does not compensate for the lack of schema-level 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 specific verb and resource: 'Create an empty cel' at a specific location (a layer and frame). The qualifier 'when one does not already exist' clearly distinguishes this from overwriting or copying operations like copy_cel or clear_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 this is for creating a new empty cel where none exists, but does not explicitly state when to prefer this over related sibling tools such as copy_cel or set_cel_position. No exclusions or alternative recommendations 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 provided, the description carries the full burden of behavioral disclosure. It adds the traits 'deterministic' and 'auditable', but does not disclose whether the tool writes files, has side effects, requires authentication, or what the return value is. For a tool that 'creates' something, this is an important omission.

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, tightly worded sentence with no filler. It front-loads the action and the key qualifiers (deterministic, auditable, layered character, Godot exports) and 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?

Given the lack of annotations, output schema, and any parameter descriptions, this brief purpose statement is grossly insufficient. An agent cannot correctly invoke the tool without understanding what asset_id and output_directory represent, what the returned plan looks like, or whether the tool has side effects. The description does not compensate for any of these gaps.

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

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

The input schema has 0% description coverage, and the description does not mention asset_id or output_directory at all. Even the general purpose ('layered character') only vaguely implies what asset_id might mean, leaving the agent to guess the meaning and required format of both 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 ('Create') and a precise artifact ('a deterministic, auditable TypeScript plan') for a clear resource ('a layered character and its Godot exports'). It is distinct from sibling tools like create_scene_plan because it specifies the character focus and Godot export deliverable, so an agent can differentiate it without 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?

The description provides no explicit guidance on when to use this tool versus alternatives such as create_scene_plan, plan_asset_scene, or generate_asset_preset. There is no mention of prerequisites, exclusions, or context that would help an agent decide between similar plan-generation 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?

The description adds behavioral context by specifying that the output is deterministic and auditable, and it clarifies that the tool produces a plan rather than directly modifying a scene. However, with no annotations, it still fails to disclose whether files are written, whether the operation is reversible, or what happens to existing plan artifacts.

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 tight sentence with no filler, front-loaded with the verb and core output characteristics. Every word adds relevant meaning, making it highly concise and well-structured.

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

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

For a tool with two parameters, no annotations, and no output schema, the description is too incomplete. It omits parameter semantics, side effects, expected return/output format, and when to use it among closely related scene-planning 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 needed to compensate, but it never mentions asset_id or output_directory. The property names are somewhat self-explanatory, yet the description adds no meaning about how they relate to the tilemap scene or Godot exports.

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 ('Create') and a specific resource: a deterministic, auditable TypeScript plan for a tilemap scene and its Godot exports. The tilemap and planning focus helps distinguish it from sibling composition/reporting tools, though it does not explicitly name alternatives or boundary conditions.

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 siblings such as plan_asset_scene, compose_asset_scene, or create_character_plan. An agent must infer the intended use case entirely from the tool name and 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 provided, the description carries the full burden of behavioral disclosure. It does not state whether the slice is created on a specific sprite/canvas, whether it overwrites an existing slice with the same name, what coordinate system is used, or what the return value is. The description adds almost no behavioral context beyond the operation name.

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 short sentence with no wasted words. It is front-loaded with the verb and resource. However, it is so terse that it sacrifices useful detail, though conciseness itself is not the problem.

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 six required parameters, no annotations, no output schema, and 0% schema description coverage, the description is far too thin. It does not explain the slice concept, coordinate semantics, target selection, or error conditions. An agent would struggle to invoke this correctly without external 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%, so the description must compensate for six undocumented parameters. It does not explain that x/y likely define the top-left corner, that width/height must be positive, that name is the slice identifier, or that filename refers to the target sprite. The description adds no parameter-level meaning beyond the schema's basic types and 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 specific verb and resource ('Create a named rectangular slice'), which is clear enough to identify the core operation. However, it does not distinguish this from sibling tools like set_slice_center, set_slice_pivot, list_slices, or delete_slice, and 'slice' is a domain-specific concept that is not elaborated. It is minimally clear but lacks differentiation.

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. There is no mention of prerequisites (e.g., an existing sprite or canvas), no exclusions, and no reference to sibling tools. The agent must infer usage entirely from the name and schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The word 'deterministic' adds some useful context, implying seed-based reproducibility, but the description does not disclose whether this creates a file, returns a structure, modifies existing assets, or has side effects. This is a significant gap for a creation 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 sentence with no filler or redundancy, and the key idea is front-loaded. It is appropriately terse in structure, though it sacrifices substance for brevity.

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 nine parameters, nested objects, no annotations, and no output schema, this description is far too thin. It does not explain what a style bible is, what the tool returns or writes, how determinism is controlled, or what the required parameters mean. An agent would be 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%, and the description does not compensate at all. None of the nine parameters (filename, id, base_size, palette, seed, materials, detail_level, outline_color, light_direction) are explained or even hinted at beyond the vague 'visual style' phrase. The agent has no help mapping parameters to intent.

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

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

The description names a specific action ('Create') and a specific resource ('deterministic visual style contract for sprites and maps'). This helps distinguish it from siblings like generate_asset_preset or harmonize_asset_palette. However, 'style contract' is somewhat abstract and could be clearer about what the created artifact actually is.

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 generate_asset_preset, create_asset_recipe, or harmonize_asset_palette. The description states only what it does, not the conditions that make it the right choice.

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 that the tool creates a layer and sets the grid, but does not explain whether an existing file must be open, whether a grid may be overwritten, what tilemap-specific side effects occur, or what happens on failure.

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 the primary action is front-loaded. It is efficient but very terse; the lack of supporting detail hurts other dimensions, not conciseness itself.

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 4-parameter mutation tool with no annotations and no output schema, this description is incomplete. It omits prerequisites, parameter semantics, and operational context such as whether the grid applies to the document or the layer and whether existing tilemap data is affected.

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 by explaining the parameters, but it mentions none. tile_width and tile_height units and their role in the grid are undocumented, and filename and layer_name are only inferable from their names, not from the description or 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 names a specific action and resource: creating a tilemap layer and setting the Aseprite grid. It is more specific than generic layer tools like add_layer or set_tiles, though it does not explicitly contrast it with sibling tilemap tools such as get_tilemap_info or draw_on_tile.

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 like add_layer, set_tiles, or get_tilemap_info. There are no conditions, prerequisites, or exclusions stated, so an agent must infer intended usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Crop' implies a mutating operation, but the description does not state that it irreversibly modifies the sprite, how out-of-bounds coordinates are handled, whether the change is applied in place, or what the resulting canvas dimensions will be. 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 terse sentence with no filler and a front-loaded verb. It is structurally clean, though its brevity contributes to the lack of operational detail.

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

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

For a five-parameter mutating tool with no annotations, no output schema, and zero schema descriptions, the description is not complete enough. An agent needs to know the coordinate system, the crop behavior relative to the existing canvas, whether the operation is destructive, and how filename maps to a sprite. None of this is addressed.

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 offers no parameter-level meaning. The names x, y, width, and height are self-evident individually, but the description does not clarify coordinate origin, units, whether width and height are relative to x/y, or how filename selects the target sprite. The description fails to compensate for the schema's complete lack of 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 clearly identifies the action ('Crop') and the resource ('sprite canvas') with a specific outcome ('to a rectangle'). It does not explicitly distinguish itself from the sibling resize_canvas, but the term 'crop' conveys a distinct operation well enough.

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 crop_canvas versus related tools such as resize_canvas, move_region, or copy_region. No when-to-use or when-not-to-use context is provided, leaving the agent to infer the use case from the tool name alone.

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