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 transparently explains key behaviors: new frames start as copies of the previous one (copyPrevious default), '.' leaves pixels unchanged and never erases, transparent pixels can be set via '#00000000', and stamps are placed per frame. It also mentions the return value (sprite status). This is a solid effort, though it does not address potential side effects like overwriting existing frame content or requiring specific permissions.

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 information-dense but not overly verbose. The main purpose is front-loaded ('Draws several frames in ONE call'), and subsequent sentences each add meaningful usage details. It avoids redundancy with the schema and stays focused. A slightly more compact phrasing could be achieved, but the current structure is clear and efficient.

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

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

The tool is complex, with nested objects for frames, stamps, and palettes. The description covers the core usage patterns (inline frames, file-based generation, stamps, copyPrevious) and explicitly states the return value ('Returns the sprite status'). It does not mention error conditions or limitations, but given the absence of an output schema and the richness of the input schema, the description is sufficiently complete for an agent to call the tool correctly.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description adds significant semantic value beyond the schema, particularly for the 'frames' and 'stamps' parameters: it explains the meaning of x/y and '.' for leaving pixels unchanged, the non-erasing property of '.', and the transparent color convention. It also clarifies how stamps are used with 'place'. This goes well beyond the baseline of 3 for high schema coverage.

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

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

The description states a clear purpose: drawing several frames in a single call, with the automatic creation of missing frames. This distinguishes it from single-frame drawing tools like aseprite_draw, though it does not explicitly name any sibling. The verb 'draws' and resource 'frames' are specific, but the differentiation from aseprite_batch (which also handles multiple operations) is implicit rather than explicit.

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 practical usage guidance: it explains how to use copyPrevious for incremental changes, how to use stamps for repeating parts, and how to pass a .json file for generated animations. However, it does not explicitly state when to use this tool versus alternatives (e.g., aseprite_draw for single frames, or aseprite_batch for batch operations), nor does it mention any exclusions or conditions that would route the agent away from it.

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

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

With no annotations provided, the description carries full responsibility, and it excels: it states that operations run in order, stops at the first error, earlier ops stay applied, each op is its own undo step, and it returns one short result per op plus final status if layers/frames changed. This is rich, actionable behavioral disclosure.

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 long but every sentence earns its place: purpose, structure, allowed ops, error handling, return format, and a representative example. It is front-loaded with the core purpose and flows logically. Slightly dense but appropriate for a complex batch wrapper.

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

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

The description covers all essential aspects: operation ordering, error behavior, undo granularity, return value, and argument mapping to individual tools. The example anchors it. It doesn't enumerate every possible argument for each op, but that would be redundant since they mirror the individual tools, which is explicitly stated. Complete enough for correct usage.

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

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

Schema coverage is 0%, so the description must explain the only parameter 'ops'. It does so precisely: each item is an object with an 'op' key and 'the same arguments as the tool aseprite_<name>'. The example concretely illustrates the structure. This adds enormous semantic value 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 states a clear, specific purpose: 'Runs several operations in ONE call, in order' – a verb+resource that immediately distinguishes it from the individual sibling tools. It also names the allowed ops, reinforcing what the tool does. This is unambiguous and differentiates from the per-operation 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?

It explains the benefit ('saves round trips and tokens') which implies when to use it, and the example demonstrates a realistic multi-step workflow. However, it doesn't explicitly say 'use this instead of multiple single calls' or mention when the individual tools might be preferred, so it stops short of a full when/when-not contrast.

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 goes well beyond the readOnlyHint annotation by disclosing the stateful baseline behavior, the exclusion of the agent's own calls, the pixel-map encoding, and the meaning of peek and reset. This is rich behavioral context with no contradiction to annotations.

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

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

The description is dense but readable, with each sentence contributing a distinct fact and key behavior front-loaded. There is no redundant restatement of the title or schema.

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 core watch/diff behavior, return format, and peek/reset flags are fully explained in the absence of an output schema. It is slightly incomplete about what the first call returns and how palette/frame parameters affect the result, but an agent can still invoke it correctly.

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

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

The description adds meaning to peek and reset, which have no schema descriptions, and explains the output encoding that relates to palette keys. It relies on the schema for frame, palette, and paletteName, so parameter semantics are well covered across the two sources.

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 a stateful diff tool: it starts watching the active sprite and returns only pixels changed by the artist since the previous call. It distinguishes itself from siblings by explicitly excluding the agent's own tool calls and pointing to aseprite_pixel_map as the downstream consumer.

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

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

It gives concrete call sequencing ('first call starts watching', 'later calls return changed pixels'), and explains peek and reset semantics. It does not explicitly name alternatives or state when not to use it, but the collaborative watch-mode context 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 provided, the description carries the full burden of disclosing behavioral traits. It fails to mention that the operation is destructive (clears pixel data), whether it is reversible, or whether it respects the current selection. It also does not clarify if the 'whole layer' means all frames or only the current frame, though the schema hints at frame specificity.

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 efficiently conveys the core functionality. It is front-loaded with the primary action and clearly states the two modes, with no extraneous words or repetition.

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

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

For a simple clear operation with three optional parameters and no output schema, the description is mostly adequate. However, it lacks important context such as the destructive nature of the operation, the default behavior when no rect is provided (which is implied but not explicit), and how frame and layer parameters interact. These gaps could lead to incorrect usage.

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

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

The input schema already documents all three parameters with clear descriptions. The description adds a small hint that the 'rect' parameter is for clearing a rectangle and that the default is the whole layer, but it does not introduce any new semantic meaning beyond what the schema provides. Since schema coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: it clears a whole layer or a rectangular region. The verb 'clears' and the resource 'layer' are specific, and it distinguishes the two modes of operation. This unambiguously separates it from sibling tools like draw, copy, or set_pixels.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or conditions for use. It merely states what it does, leaving the agent to infer that it is the appropriate tool for clearing operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses 'one undo step', explains the default destination when x/y are absent, and details the flip semantics through a worked example. It does not explicitly state that the destination pixels are overwritten (though skipTransparent in the schema implies it) or mention any other side effects, which keeps it from a 5.

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 reasonably concise: two sentences plus an example. It front-loads the core operation, then adds default behavior and a concrete illustration. The example is valuable but makes it slightly longer than strictly necessary, so it does not receive a 5.

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

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

For a tool with 9 parameters and no output schema, the description covers the important behavioral nuances: destination defaults, flip semantics, and undo grouping. It leaves detailed parameter defaults to the schema (which is complete), and the example helps anchor usage. A fully complete description might also mention overwrite behavior explicitly, but the schema's skipTransparent covers that indirectly.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by explaining the interaction between x/y and the source rectangle: without x/y it writes back in place. The symmetry example clarifies how rect, flip, and x combine, adding meaningful semantics that the schema alone does not convey.

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 ('Copies a rectangle of pixels') and specifies the resource (pixels/region) and the optional operations (flipped, to another position/layer/frame). It distinguishes itself from siblings like aseprite_set_pixels or aseprite_draw by emphasizing the copy/mirror action and the 'one undo step' behavior.

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 the tool: to copy or mirror a region, with explicit context about the default behavior when x/y are omitted ('writes back in place'). It gives a concrete symmetry example that illustrates a typical use case. It does not explicitly name alternative tools or offer exclusions, but the context is clear enough to route an 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?

No annotations are provided, so the description carries the burden. It discloses the point-count behavior for each tool type, which is useful. However, it doesn't mention side effects like whether drawing replaces existing pixels, whether it modifies the active layer/frame, or whether it's destructive. The description adds some behavioral context but not comprehensive.

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 that front-loads the core purpose and then lists tool-specific point requirements. It's efficient with no wasted words, though the long list of tool names makes it slightly dense. The structure is logical: purpose first, then per-tool 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?

The description covers the essential point-count semantics for each tool, which is the most complex aspect. However, it doesn't mention return values (no output schema), error conditions, or interaction with layers/frames. Given the tool's complexity (11 parameters, 13 tool types), the description is adequate but not fully complete.

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

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

Schema coverage is 73%, and the description adds significant meaning beyond the schema by explaining how the 'points' parameter varies per tool. It clarifies that line/rectangle/ellipse take 2 points, freehand tools take any number, paint_bucket takes 1, curve takes 4, and polygon/contour take corners. This is valuable semantic information not present in the schema's generic 'List of [x, y]' description.

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

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

The description clearly states the tool's purpose: using an Aseprite tool like a mouse stroke. It enumerates the specific tools and their point requirements, which distinguishes it from sibling tools like aseprite_set_pixels or aseprite_pixel_map. The verb 'draw' and resource 'Aseprite tool' are specific and unambiguous.

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

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

The description provides clear context on how to use the tool by specifying the number of points required for each tool type. It doesn't explicitly name alternatives or when-not-to-use, but the detailed point requirements serve as implicit usage guidance. The sibling list shows related tools, but the description doesn't explicitly route to them.

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

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

With no annotations available, the description carries the behavioral disclosure burden i and does useful work by stating that 'new' copies the frame by default, becomes active, and that the tool 'Returns the sprite status.' It does not disclose delete/replace side effects or prerequisites like an open sprite, but the core behavioral traits are clearer than most unannotated tools.

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

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

Two sentences convey all operations, default behaviors, an alternative, and the return value with no filler. The list of actions is front-loaded and the sibling reference is compactly placed at the end.

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

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

For a four-action tool with four parameters and no output schema, the description is reasonably complete: it states what each action does, key defaults, the return status, and the relevant sibling. It could mention prerequisites or failure behavior for delete/duration, but it gives enough for an agent to make a correct call in the common cases.

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

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

The schema already documents most parameters, and the description reinforces their meaning by tying 'frame' to the active frame/after insertion, 'copy' to the default behavior of 'new', and 'duration' to seconds. This adds contextual meaning beyond the raw schema, especially for action-dependent parameter use.

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 resource (frames) and the exact operations: creating, selecting, deleting, and setting duration. It also distinguishes itself from aseprite_animation by explicitly pointing to that sibling for batch drawing. This gives an agent a clear, differentiation-ready understanding of the tool's 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?

The description gives explicit operational context for when to use this tool and names a concrete alternative: 'To draw several frames at once use aseprite_animation.' This is a clear when-not condition that prevents the agent from confusing frame management with multi-frame drawing.

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 declare readOnlyHint=true, so the safety profile is known. The description adds value by specifying the content of the guide and the recommendation to read it once, going beyond the annotation without contradicting it.

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

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

Two concise sentences with no filler. The main purpose is front-loaded, and the usage condition is stated clearly. Every word earns its place.

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

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

For a read-only help tool with no parameters and no output schema, the description fully covers what it returns and when to invoke it. Nothing an agent needs to call it correctly is 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?

The tool has zero parameters and 100% schema coverage (empty schema), so no parameter description is needed. Baseline 4 applies because the description adds no parameter info but doesn't need to.

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 'Returns' and resource 'short usage guide' with content details (workflow, pixel_map format, stamps, tips). Clearly distinct from sibling drawing/editing tools, which perform operations rather than provide guidance.

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?

Explicitly tells the agent when to use it: 'Read it once before drawing' and the condition 'if your client did not show the server instructions'. This directly guides selection among siblings and avoids redundant calls.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without explaining effects like whether undo is destructive, whether it operates on the current document, or what happens to the history stack. This is a significant gap for a mutation tool.

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

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

The description is extremely concise with no wasted words, and the verb is front-loaded. However, it is under-specified for a tool with two parameters and no annotations; conciseness is achieved at the expense of necessary detail, making it only barely adequate.

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 (undo/redo with a step count and action enum) and the absence of annotations or output schema, the description is incomplete. An agent would not know how to correctly invoke it, what happens on undo, or how to handle the step limit. Essential context is 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%, so the description must compensate by explaining parameters. It mentions 'steps' in the verb but does not clarify the meaning of the 'action' parameter or the 'steps' count semantics (e.g., how many steps are undone/redone). The description adds minimal value beyond the schema itself.

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 ('undoes or redoes') and a resource ('steps'), making the core purpose understandable. However, 'steps' is vague without domain context, and it doesn't explicitly differentiate from any sibling tools, though no direct alternative exists.

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. There is no mention of conditions, prerequisites, or exclusions, leaving the agent to guess when undo/redo is appropriate.

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

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

With no annotations, the description carries the full burden. It does disclose a behavioral detail: creating a layer makes it active. It also states the return value (sprite status). However, it omits potential side effects like delete being irreversible or behavior when renaming a nonexistent layer, which would be valuable given the destructive actions available.

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 packed sentence that lists all actions and the return value. It is front-loaded with the core capability and wastes no words. Every part contributes to understanding the tool.

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

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

The description covers the main actions and return value, but lacks context about prerequisites (e.g., needing an open sprite) and does not explain conditional parameter usage (newName only for rename, visible only for visible) beyond what the schema hints. Since there is no output schema, a clearer description of 'sprite status' would help. Overall, adequate but with notable 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?

Schema coverage is 75%, but the description adds meaning beyond the schema by explaining each action: 'new, becomes active', 'activate (select)', 'show/hide (visible)'. This clarifies the enum values that lack descriptions in the schema. It also notes the return value, which is not 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 clearly states the tool manages layers via specific actions: create, select, delete, rename, show/hide. It names the resource (layer) and the verbs. It does not explicitly differentiate from sibling tools like aseprite_frame, but the focus on layers is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., an open sprite) or conditions that would favor another tool. The description simply lists capabilities without contextual direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'makes it active' and 'returns the sprite status' but omits crucial context such as what happens to the current sprite, whether the operation is reversible, or any side effects. The description is too thin 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 two sentences with no wasted words. The core action is front-loaded, and it is appropriately brief for a simple creation tool.

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

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

Given no output schema and no annotations, the description is incomplete. It does not specify what 'sprite status' includes, the format of the background color, or any constraints beyond the schema. An agent cannot fully predict the tool's behavior from this description.

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

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

Schema description coverage is only 25% (only background has a description). The description adds no additional meaning for width, height, or colorMode, leaving the agent to infer their purpose. It does not compensate for the low schema coverage at all.

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

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

The description clearly states the verb 'creates', the resource 'new sprite', and the side effect 'makes it active', which distinguishes it from sibling tools like open or clear. It is specific and unambiguous.

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

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

The description implies this is the tool for creating a new sprite, but it does not explicitly state when to use it versus alternatives, nor does it provide any exclusions or prerequisites. It relies on the agent to infer from the sibling names.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'as the active sprite' but does not disclose whether opening replaces the current sprite, whether unsaved changes are lost, or how errors such as missing files are handled. For a state-changing 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, front-loaded sentence with no unnecessary words. It efficiently combines the core action, supported formats, and the resulting state of the active sprite.

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 plus schema is minimally sufficient. However, without output schema or annotations, it should clarify side effects on the current sprite and ideally error behavior, which are currently left implicit.

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

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

The input schema covers the only parameter with 100% coverage, including that the path must be absolute. The description adds supported file format examples but does not expand on path semantics or constraints, so the schema already does the heavy lifting.

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 operation (opens a file), the resource (a supported image/sprite file), and the result (becomes the active sprite). This distinguishes it from siblings like aseprite_new_sprite and aseprite_save without requiring the agent 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?

Usage is implied by the name and description: use this tool when you need to open an existing file as the active sprite. However, it does not explicitly name alternatives or state when not to use it, leaving some inference to the agent.

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

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

With zero annotations, the description carries the full behavioral burden and does it well: it discloses the one-undo-step guarantee, the 128x128 sprite size constraint, the alpha < 128 emptiness rule, and the exact color-derivation behavior for the 'selout' style. It stops short of stating whether the operation overwrites existing pixels or what happens if the layer name is invalid, but these are minor omissions given how much context is already provided.

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 four sentences tightly packed with necessary information: main effect, style semantics, size/selection workaround, and alpha threshold. It is front-loaded with the core behavior, and every sentence earns its place; there is no redundant or promotional 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?

Given that all parameters are optional, there is no output schema, and there are no annotations, the description covers the essential behavioral contract: what it acts on, how style variants behave, size/selection limitations, alpha handling, and undo granularity. It does not address failure modes (e.g., invalid layer, sprite larger than 128x128 without rect), but the provided context is sufficient for an agent to call the tool correctly in the common 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 coverage is 71%, with style and position lacking descriptions in the schema. The description compensates by explaining that 'style' has two semantic modes ('selout' derives colors from neighboring pixels, 'solid' uses one color) and that 'position' controls outside vs. inside placement. It also clarifies that 'color' is 'solid only' and defines 'strength' as how much darker than the fill, adding meaning well beyond the raw enum/default values.

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 operation: 'Adds a 1px outline around (outside) or on the edge of (inside) everything opaque on a layer'. This is a specific verb-resource-effect statement distinct from sibling tools like aseprite_set_pixels or aseprite_draw, which focus on raw pixel manipulation or drawing primitives. The two position variants and the single undo step further pin down exactly what the tool does.

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

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

The description gives no explicit guidance on when to choose this tool over alternatives, nor does it name any sibling tools or conditions that would make another operation preferable. While the behavior is described thoroughly, an agent is left to infer that this is the tool for adding outlines; there is no 'use this when...' or 'for arbitrary pixel editing use aseprite_set_pixels instead' style guidance.

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

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

With no annotations, the description carries the full burden. It discloses persistence ('on disk', 'reused across sprites and sessions') and gives a concrete example for the ramp action, showing the generated keys format. It doesn't detail overwrite semantics or error behavior, but the provided example and action descriptions give adequate behavioral insight for most cases.

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

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

The description is well-structured: it opens with the primary purpose, then lists actions with concise explanations and includes an example for the most complex action. It's longer than minimal but every sentence carries useful information, and the layout aids scanning. Slight redundancy in the action list could be trimmed, but it remains efficient.

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

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

Given the tool's complexity (7 parameters, multiple actions, nested objects) and the lack of an output schema, the description is quite complete. It covers all actions, explains the integration points, and gives a concrete example. It doesn't cover edge cases like overwriting or deletion behavior, but for a storage/retrieval tool with this level of detail, it's sufficient for an agent to call it correctly.

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

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

Schema coverage is 86%, and the description adds substantial meaning beyond the schema: it clarifies that 'name' is optional for list/ramp, explains the 'from_image' behavior (collects colors from visible frame or layer/rect), and provides a worked example for ramp with base and keys. This goes beyond the schema's terse property descriptions and directly helps the agent construct valid calls.

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

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

The description clearly states the tool's purpose: storing named palettes for reuse across sprites/sessions, and explicitly enumerates the actions (save, list, delete, from_image, ramp) with brief explanations. It distinguishes itself from sibling tools by referencing how paletteName is used in other tools (aseprite_pixel_map, aseprite_read_pixels, aseprite_animation), making its role 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?

The description implies when to use the tool (when you need to persist and reuse palettes) and details each action's purpose. It mentions the integration with sibling tools but doesn't explicitly state alternatives or exclusions. However, the action list provides clear context for when each sub-action is appropriate, so it's close to fully guiding 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?

With no annotations provided, the description carries full responsibility. It discloses key behaviors: '.' and space leave pixels unchanged, mapping a key to '#00000000' erases, one undo step, stamps drawing order, and file override precedence. It does not cover error cases or interaction with active layer/frame beyond defaults, but the core behavior is transparent.

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

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

The description is detailed but efficient, front-loading the core concept and then systematically covering format, examples, stamps, and file usage. Every sentence contributes to understanding how to use the tool. It is slightly long but justified by the complexity of the tool.

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

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

Given the high complexity (10 parameters, nested objects, no output schema), the description covers essential usage patterns, special characters, and file support. It does not explain coordinate origin or error handling, but it is sufficiently complete for an agent to call correctly in typical scenarios.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining the interplay of palette, rows, stamps, and file, plus the special meaning of '.' and space (not in schema). It also clarifies that inline arguments override file values, adding value beyond the schema's individual parameter descriptions.

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

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

The description clearly states the tool's purpose: drawing many exact pixels using a token-efficient palette-and-rows format. It distinguishes itself from siblings like aseprite_set_pixels (likely for individual pixels) and aseprite_draw (for shapes) by emphasizing 'most token-efficient way to draw many exact pixels.'

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

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

The description implies usage for bulk pixel drawing and mentions patterns like stamps and file-based generation, but it does not explicitly compare against alternatives or state when NOT to use it (e.g., for few pixels or freeform drawing). It provides context but no exclusions or direct routing to 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 provide readOnlyHint=true, and the description does not contradict it. It adds valuable behavioral details beyond the annotation: transparency represented as '.', trailing '.' cut off, max call size, and layer flattening rules. These are exactly the kind of operational traits an agent needs and are not in the annotations.

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

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

Three sentences, no wasted words. The core purpose and format are front-loaded, followed by key behavioral notes. Each sentence earns its place, covering purpose, format, layer behavior, palette guidance, and limits.

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

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

For a read-only tool with a comprehensive schema and readOnly annotation, this description covers the essential operational knowledge: output format, interpretation of transparency, maximum pixels, and layer/palette behavior. Missing error handling details are minor for this type of tool, and no output schema exists so the description appropriately explains the return format.

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

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

Schema coverage is 100% — every parameter is described with defaults and formats. The description adds the 'same keys back' hint and the max pixel constraint, which are useful but not substantial. Since the schema already carries the semantic weight, the description's contribution is modest, warranting the baseline of 3.

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

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

The description clearly states a specific verb (reads), resource (pixels), and output format (palette + rows), with a concrete use case (inspect colors, copy/modify). It references aseprite_pixel_map but doesn't explicitly contrast itself against that sibling, though the 'reads back' wording implies a read vs. write distinction.

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

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

It explains when to use the tool (inspect exact colors, cheap copy/modify) and provides key context: layer behavior (visible flattened vs. specific layer), palette passing for consistent keys, and a 16384-pixel cap. No explicit exclusions or alternative routing, but the read purpose is self-evident from the name and description.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the critical overwrite behavior and the non-destructive copy/export behavior, which are the main things an agent needs to know. It does not mention error handling or what happens with a new path, but it covers the most consequential behaviors.

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

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

The description is two sentences with no filler. The core action is front-loaded, and the conditional behaviors are presented in a clear, compact 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 simple two-parameter save tool with no output schema, the description covers the essential decision points: when to overwrite and when to export a copy. It could clarify whether copy mode requires a path, but it is otherwise complete enough for correct invocation.

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

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

Schema coverage is only 50% because copy has no schema-level description. The description compensates by explaining that copy=true exports a copy, and that omitting path overwrites the existing file. This adds real meaning to both parameters beyond the schema.

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

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

The description states a specific verb and resource: 'Saves the active sprite.' It also distinguishes the two main behaviors (overwrite existing file vs. export a copy), which makes the tool's purpose unmistakable and separates it from sibling tools like open, draw, or 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?

The description provides clear context: use this tool to save the active sprite, with no path meaning overwrite and with copy=true meaning export a copy. It does not explicitly name alternatives or exclusion conditions, but no sibling tool serves the save/export role, so this is sufficiently clear.

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

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

Beyond the readOnlyHint annotation, the description discloses the empty case ({empty:true}) and the exact behavior of the mask parameter (rows with '#'). This adds meaningful behavioral detail about output format and option 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?

Three sentences, each earning its place. The primary purpose is front-loaded, the mask explanation is concise, and there is no redundant or filler content.

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

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

For a single-parameter read-only tool with no output schema, the description covers the main use case, the empty state, the mask behavior, and its relationship to other tools. Nothing essential for correct invocation is 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 coverage is 0%, so the description must explain the mask parameter, and it does clearly: mask=true adds the exact shape as rows when not a plain rectangle. It also implies the default return is a rect, giving context for the parameter's effect.

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 returns the artist's selected region in Aseprite, explains its purpose for resolving references like 'this part', and distinguishes it from siblings by focusing on selection. The verb and resource are specific and non-tautological.

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

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

It explains when to use the tool (to get the selection for requests needing coordinates) and hints that most tools accept a rect directly, implying you may not need this if you already have coordinates. However, it does not explicitly name alternatives or state exclusions, so it stops short of full guidance.

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

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

With no annotations provided, the description must carry the burden for behavioral disclosure. It highlights two key behaviors: it sets pixels as a single undo step, and the special color '#00000000' erases a pixel. However, it does not disclose other potential behaviors such as how default frame/layer are handled beyond schema defaults, or any side effects on the active layer. The description adds some context beyond the schema but leaves room for more.

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 two sentences that are packed with information. It front-loads the primary purpose, then immediately provides the critical detail about the erase color and the routing to aseprite_pixel_map. Zero wasted words; every sentence 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 tool's moderate complexity (3 parameters, all schema-covered) and no output schema, the description is quite complete. It covers the essential usage, the special erase case, and the alternative tool for scaling. The only minor gaps are that it doesn't explicitly state what happens if the layer or frame is invalid, or the exact behavior of the undo step (e.g., whether it groups all pixel sets into one undo). However, for most agent usage, it is sufficiently informative.

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

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

The schema already documents 'pixels' as a list of [x, y, color] and describes frame and layer, so schema coverage is high at 100%. The description adds semantic value by explaining the special color for erasing, which is not in the schema, and clarifies the undo behavior. It does not describe the exact format of color beyond the schema's 'hex color' note, but the special case is valuable for correct usage.

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

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

The description clearly states the tool's function: setting individual pixels exactly as a single undo step. It distinguishes itself from the sibling aseprite_pixel_map by explicitly noting the token efficiency tradeoff, making it easy for an agent to choose between them.

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

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

It explicitly says when to use this tool vs the alternative: for more than a few pixels, prefer aseprite_pixel_map because it uses far fewer tokens. This gives clear guidance on when to use this tool (few pixels) and when not to, naming the sibling alternative directly.

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

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

The readOnlyHint annotation already flags this as a safe read operation, and the description adds meaningful context: it checks the connection and defines the coordinate origin as (0,0) top-left. This goes beyond the annotation, though exact return structure and failure behavior are not described.

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

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

Two tightly written sentences with the core purpose front-loaded and no filler. The coordinate-system note is brief and useful context rather than noise.

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 no-parameter, read-only status tool, the description is complete: it identifies connection semantics, the active-sprite target, the returned fields, and the coordinate convention. Nothing an agent needs to invoke it correctly is 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?

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about parameter meaning. The baseline of 4 applies because there are no parameter semantics to document.

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 ('Checks') and resource ('active sprite') and enumerates the returned info: size, color mode, layers, frames, active layer/frame. This clearly describes the tool's purpose, though it does not explicitly differentiate it from the similar read-only sibling aseprite_view.

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

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

The description implies the tool is used to verify the connection and inspect the active sprite, but it provides no explicit guidance on when to use it versus siblings like aseprite_view or aseprite_history. No alternatives or exclusions are mentioned.

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

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

Annotations already declare readOnlyHint=true, and the description adds substantial behavior: transparency checkerboard, max 128x128 px output, upscaled rendering, and the exact composition of critique sheets (color, grayscale, silhouette, 1x, optional deutan). No contradictions with annotation.

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?

Six sentences pack the main purpose, transparency display, rect usage, call frequency, alternative, critique mode, and size limit with zero filler. Each sentence serves a distinct purpose, and the most important information is front-loaded.

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

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

The description covers invocation timing, return type (PNG vs critique sheet), use of alternatives, and output size constraints. Minor gaps such as frame parameter behavior are deducible from 'visible, flattened frame' and default annotations, and the lack of an output schema is partially offset by the explicit rendering description.

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

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

The description adds meaning for key parameters: rect is described as zoom-to-detail, critique/panels are explained including the 'deutan' option, and scale's default is implied by 'upscaled'. Schema coverage is 57%, but the description compensates for the most impactful parameters, though frame, grid, and checker details remain inferable rather than explicit.

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

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

The description states a specific verb ('Renders'), resource ('visible, flattened frame'), and output ('upscaled PNG'), making the tool's purpose unmistakable. It also differentiates from aseprite_read_pixels by explicitly noting the alternative for clients that cannot display images.

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

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

It gives explicit timing guidance ('Call it once after a drawing pass, not after every step') and names the alternative aseprite_read_pixels when images cannot be shown. It also clarifies when to use critique mode, leaving no ambiguity about selection.

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