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

With no annotations provided, the description carries full burden. It discloses that the new frame becomes active and can duplicate an existing one, but does not specify where the frame is appended (e.g., after the current frame), effects on undo history, or any side effects. Adequate but lacks 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?

Two concise sentences: the first states the action, the second the behavioral effect. No extraneous information, each 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 has 3 parameters and no output schema or annotations, the description covers core behavior but omits details like append position, prerequisites (e.g., active document), and error conditions. Adequate for a simple append but not fully complete.

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

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

The description adds meaning beyond the schema: it explains that duplicate_from is for optional duplication and that the new frame becomes active. The schema already describes duration_ms well (67% coverage), and the description complements it. However, duplicate_from lacks a schema description, so the description partially compensates.

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 'Append a frame', specifying the verb (append) and resource (frame). It also mentions optional duplication and that the new frame becomes active, which distinguishes it from sibling tools like remove_frame, reorder_frame, or set_frame_duration.

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 adding a new frame but does not explicitly state when to use this tool versus alternatives like copy_cel or remove_frame. No when-not guidance or exclusion criteria are provided.

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

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

With no annotations, the description carries full burden. It mentions the layer is transparent and becomes active, but lacks details on side effects, permissions, or return values. Insufficient for a framework with no 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?

Single, front-loaded sentence with no wasted words. Efficiently communicates core behavior.

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 add-layer tool, the description covers basic purpose and one effect, but misses details like return value, error conditions, and prerequisites. Adequate but could be more complete given no annotations.

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 67% (doc_id and index have descriptions, name does not). The description adds no parameter-specific details beyond what the schema provides, and does not clarify the 'name' parameter or other 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 clearly states the action ('Add a new transparent layer') and adds that it becomes the active layer, distinguishing it from other layer operations like set_active_layer. The verb+resource is specific.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies usage when a new layer is needed, but provides no exclusions or comparisons with sibling tools like remove_layer or rename_layer.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the failure condition but does not describe success behavior, return values, or side effects. Adequate 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?

Two efficient sentences with no wasted words. The core action is front-loaded, and the constraint follows immediately.

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 3 parameters, no output schema, and no annotations, the description is minimal but covers the key constraint. Missing details on parameter usage and success behavior, making it sufficient but not thorough.

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 low (33%), and the description adds no explanation for the 'hex' or 'name' parameters beyond what the schema provides. It mentions 'color' vaguely but doesn't clarify parameter roles.

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

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

The description clearly states the action ('Append a color') and the resource ('the palette'), which is specific and distinguishes it from sibling tools like set_palette_color or remove_palette_color.

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

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

No guidance on when to use this tool versus alternatives (e.g., set_palette_color). Only a failure condition (palette full) is mentioned, but no context about appropriate scenarios.

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

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

No annotations provided, so the description carries full burden. It discloses mutation effects ('all pixels using it update') and the alternative behavior (append with as_new). It does not mention authorization or rate limits, but for a palette adjustment tool the disclosure is adequate.

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

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

Two sentences with no fluff. First sentence defines the core action and parameters, second sentence explains the behavioral modes. Front-loaded 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?

Given no output schema and many sibling tools, the description covers parameters, behavior, and side effects. It could mention the return value (e.g., success confirmation), but this is not critical for a mutation tool. Overall, it is complete enough for the agent to use 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 88% (7 of 8 parameters described in schema). The description adds value by explaining HSL adjustments (darken/lighten via lightness, shift saturation/hue) and the as_new behavior. It also provides the convenience context of saving hand-computing hex, which aids understanding 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 clearly states the tool nudges a palette color in HSL space (darken/lighten via lightness, shift saturation or hue). It distinguishes itself from sibling tools like set_palette_color (sets specific color) and add_palette_color (adds new entry) by specifying it adjusts in place or appends with as_new.

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 explains when to use this tool (nudging in HSL space) and mentions two modes (edit in place or append). It does not explicitly state when not to use it or compare to alternatives, but the sibling context implies differentiation, and the behavior is clear.

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

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

No annotations are provided, so the description carries full burden. It only states 'label the current state' without explaining side effects, permissions, error conditions, or whether the tool is destructive. This leaves significant behavioral ambiguity.

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 verb and object with no wasted words. It is appropriately sized for such a simple tool.

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

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

The description is adequate for a simple tool but lacks context on what 'current state' entails (e.g., entire document vs. specific layer) and does not mention return values. With no output schema and 2 params, more context would improve completeness.

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 50% (doc_id has a description, label does not). The tool description adds no parameter-specific details, failing to compensate for the missing label description or clarify parameter 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 action (label), the resource (current state), and the purpose (for later comparison with view_diff). This distinguishes it from sibling tools like view_diff and implies the workflow.

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 using checkpoint before view_diff, but does not explicitly state when to use or not use it. No alternatives or prerequisites are mentioned, relying on context from sibling tool 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?

With no annotations, the description must disclose all behavioral traits. It only states that pixels become transparent, but omits important details like effect on symmetry, clip behavior, render output, and whether changes are undoable. The description does not explain the side effects of parameters like clip, render, or ignore_symmetry.

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

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

The description is one concise sentence that communicates the core purpose without waste. However, it could be slightly expanded without losing conciseness.

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

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

Given the tool's complexity (7 parameters, nested objects, no output schema), the description is too brief. It lacks explanation of region specification, frame/layer targeting, and behavioral flags like clip and render. Important context for correct usage 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 100%, so each parameter already has a description. The tool description adds no additional meaning to parameters; it does not explain the region options (rect, pixels, selection) or other parameters. Baseline 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: setting every pixel in a region to transparent. The verb 'set' and resource 'every pixel in a region' are specific, and it distinguishes itself from sibling tools like set_pixels, line, or rect that set colors or draw shapes.

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, nor any exclusions or prerequisites. There is no mention of when not to use it or related 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 implies a non-destructive copy, but does not disclose whether the target frame's existing pixels are overwritten or merged. No annotations are provided to clarify safety, so the description should have addressed behavioral traits like overwriting behavior.

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

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

The description is a single, clear sentence with no redundant words. It is appropriately front-loaded and to the point.

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 four parameters, the description leaves significant gaps: it does not explain return behavior, whether the operation is reversible, or the impact on other layers. For a mutation tool, more completeness 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 coverage is 50%, and the description adds context for 'from_frame' and 'to_frame' by mentioning them, but does not provide constraints or format details. It confirms the role of the 'layer' parameter. Baseline is 3, and the description adds minimal extra value.

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

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

The description clearly states the action ('Copy') and the resource ('one layer's pixels from one frame to another'). It distinguishes the tool from siblings like 'copy_region' and frame manipulation tools, though it could be slightly more specific about the layer being the active or specified layer.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'copy_region' or 'paste_stamp'. The description does not mention prerequisites or context, leaving the agent to infer 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 burden. It discloses that the copy is lossless in palette-index space, explains source color mapping behavior ('extend' vs 'nearest'), and states that symmetry is ignored by default. This adds significant behavioral context beyond what the schema provides.

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 paragraph, but it is concise and front-loaded with the main action. Every sentence adds value, though it could be more structured with bullet points for easier scanning. The length is appropriate for 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 tool's complexity (14 parameters, nested objects, no output schema), the description provides good contextual completeness. It covers the multi-agent use case, palette behavior, and symmetry defaults. However, it does not describe the output (e.g., whether a render is returned) or permissions, which slightly reduces completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the 'palette' enum options and the 'ignore_symmetry' default, but does not elaborate on other parameters beyond the schema. It provides useful semantic context for two key parameters, justifying a score 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 it copies a region of pixels from another document into this one, lossless in palette-index space. It explicitly calls it 'the assembly tool for multi-agent fan-out', distinguishing it from siblings like paste_stamp and copy_region. The verb 'copy' and specific resource 'a region of pixels from another document' provide a specific and unique 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 explicitly tells when to use this tool: 'the assembly tool for multi-agent fan-out: subagents draw parts in their own documents, then a parent composes them.' It also notes that placed content ignores symmetry by default, similar to paste_stamp. While it doesn't explicitly list when not to use, the context is clear enough for an AI agent to decide.

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 mention side effects (e.g., whether existing stamps with the same name are overwritten, or if the original region is preserved). The behavior of the stamp storage is obtuse.

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 of 8 words is highly concise and front-loaded with the core purpose. Every word is necessary and contributes to understanding the tool's function.

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 complexity (5 parameters, nested objects, no output schema), the description is minimal. It covers the basic intent but omits details about stamp lifetime, naming conflicts, and region constraints, which are important for effective use.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds no additional meaning beyond what is in the schema; for example, the 'name' parameter is simply 'string' without further constraints. A score of 3 is appropriate as it meets the baseline but lacks extra clarification.

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

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

The description clearly states the action 'copy a region' and its purpose 'into a named stamp for later paste_stamp'. This distinguishes the tool from siblings like paste_stamp and cut_region, as it focuses on storing a region for future use.

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 such as cut_region or copy_from_document. The description implies a workflow with paste_stamp but does not clarify when to choose this over other region copy 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?

Without annotations, the description partially discloses behavior: it notes that palette index 0 is always transparent. However, it omits other important traits like side effects, return value, or whether the document becomes active.

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, no wasted words. First sentence states purpose, second explains palette. Highly 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 3 parameters and no output schema, the description is incomplete. It doesn't mention that width/height are required, nor what the tool returns (e.g., document ID). The palette detail is helpful, but overall context is lacking.

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 low (33%), and the description adds meaning for 'palette' (preset names or hex colors). But 'width' and 'height' are not explained beyond schema bounds, so the description only partially compensates for the coverage gap.

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

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

The description clearly states 'Create a new pixel art document', specifying the verb 'create' and the resource 'pixel art document'. It distinguishes from sibling tools like open_document by focusing on creation.

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

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

No guidance on when to use this tool versus alternatives (e.g., open_document). The description does not specify prerequisites or exclusions, leaving the agent without context for tool 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?

With no annotations, the description carries full burden. It discloses core behavior (copy and clear) but lacks details on side effects (e.g., overwriting existing stamps, undo behavior, error conditions). Adequate but not thorough.

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

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

Single sentence, highly concise, front-loads the action. No wasted words.

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

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

Given the complex input schema (8 parameters, nested region object) and no output schema, the description is too minimal. Does not address optional parameters or return behavior, making it incomplete for full use.

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 88%, so most parameters already have descriptions. Description adds no additional parameter meaning beyond what's in the schema, meeting baseline.

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

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

Description uses specific verb and resource: 'Copy a region into a named stamp and clear it from the layer.' Clearly distinguishes from siblings like 'copy_region' (copy without clear) and 'clear_region' (clear without copy).

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

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

No guidance on when to use this tool versus alternatives. Does not mention that it performs a cut-like operation or when to prefer it over separate copy and clear 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?

Clearly states permanent deletion from memory and disk, and irreversibility. With no annotations, description carries full burden and does so well. Could mention potential side effects or failure modes.

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

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

Two sentences, front-loaded with action and effect. No wasted words.

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

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

Single parameter, no output schema, no annotations. Description adequately covers purpose and behavioral traits. Could mention success/failure indicators, but sufficient for a destructive 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?

Only one parameter (doc_id) with schema coverage 100%. Description adds no extra meaning beyond schema's 'Document id'. Baseline of 3 is appropriate.

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

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

Description clearly states action: 'Permanently delete a document', specifies resource ('document'), and notes irreversibility. Distinguishes from sibling tools like create_document or open_document.

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?

Implies caution with 'Cannot be undone', but no explicit when-to-use or alternative guidance. Could mention that other tools like archive or move exist for non-destructive actions.

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

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

No annotations are provided, so the description must disclose behavioral traits. It lists what is returned but does not mention if the operation is read-only, if permission is required, or any side effects. This lack of detail hurts transparency.

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

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

The description is very concise (one fragment listing components) and front-loaded with 'Full document state'. However, it could be slightly improved by being a full sentence, but overall it efficiently conveys the core information.

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

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

Given the tool's low complexity (one parameter, no output schema), the description provides a clear list of what the state includes. However, it does not specify the output format (e.g., JSON structure) or whether it includes metadata. It is adequate but not rich.

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

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

Schema description coverage is 100% (only one parameter 'doc_id' with description 'Document id'). The description adds no additional semantics beyond the schema, so 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 explicitly states 'Full document state' and lists specific components (size, palette, layers, etc.), clearly indicating the tool's purpose. It distinguishes itself from sibling tools like 'view' by providing a comprehensive snapshot rather than a single aspect.

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 when a complete view of document state is needed, but it does not provide explicit guidance on when to use it versus alternatives (e.g., 'view' for just the image), nor does it mention any prerequisites or exclusions.

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

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

With no annotations, the description carries full burden. It explains the dithering technique and mentions that index 0 fades to/from transparent. However, it does not clarify if the tool modifies the image in place, whether it respects existing alpha, or any prerequisites like palette existence. It is adequate but could be more explicit.

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

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

The description is four sentences long, each earning its place. Front-loaded with the core action, it explains the technique and key parameters without unnecessary details. No fluff.

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 complexity and no output schema, the description sufficiently covers the tool's behavior and parameters. However, it does not mention what the tool returns (e.g., success status) or explicitly state that it modifies the current document, leaving minor ambiguity.

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

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

Schema coverage is high (91%), but the description adds value by explaining the purpose of from_index/to_index (palette colors), axis (horizontal/vertical/radial), pattern (bayer vs checker), and the special meaning of index 0. This goes beyond the schema's basic descriptions, making parameter usage clearer.

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 it fills a region with an ordered-dither gradient between two palette colors, using specific parameters like from_index, to_index, axis, and pattern. It distinguishes the tool as the 'indexed-color way to blend a smooth-looking transition,' which differentiates it from sibling tools like 'gradient' or 'blend' 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?

The description provides context on when to use the tool (for indexed-color images needing a smooth transition via dithering) and explains key parameters. However, it does not explicitly state when not to use it or mention alternatives among sibling tools, which would improve 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 fully disclose behavioral traits. It only states the basic drawing action and mentions outline/filled, but fails to describe side effects, permissions required, or behaviors related to parameters like clip, ignore_symmetry, or render. This is inadequate for a tool with 12 parameters.

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

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

The description is extremely concise, consisting of a single sentence that front-loads the core purpose. It wastes no words, though it sacrifices clarity on non-essential details. For a simple tool this is effective, but for one with many parameters it is slightly too sparse.

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 12 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the effect on the document, how layers and frames interact, or what the tool returns. Important context about clip behavior, symmetry, and rendering is omitted.

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

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

The description adds no meaning beyond what the schema already provides for parameters like cx, cy, rx, ry, and filled. With schema description coverage at 58%, the description does not compensate for undocumented parameters nor clarifies how parameters like clip or layer affect 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 explicitly states the verb 'Draw', the resource 'ellipse', and specifies the center coordinates (cx,cy) and radii (rx,ry) along with the outline or filled distinction. This clearly differentiates from sibling drawing tools like line and rect.

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 rect or flood_fill. There is no mention of prerequisites, constraints, or context that would help an agent decide to invoke 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?

Without annotations, the description carries the burden. It explains the return behavior (file path, optionally base64) and the different behaviors of each format (png: true transparency, gif: animation, aseprite_json: embedded spritesheet). It does not disclose potential side effects like file overwriting or authorization requirements, but covers the main behavioral aspects well.

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: three sentences with no redundancy. The first sentence states the core function, the second lists format-specific behaviors, and the third clarifies the delivery purpose and distinguishes from perception tools. Every sentence adds essential value.

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

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

For an export tool with 7 parameters (2 required) and no output schema, the description covers the main behavior and format distinctions. It does not detail every parameter (e.g., scale, loop), but the schema already does. Missing are potential error conditions or file overwrite semantics, but overall it is sufficient for an agent to understand the tool's purpose and 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?

With 86% schema description coverage, the schema already documents most parameters. The description adds value by explaining the semantic implications of the format parameter (what each format yields). This contextualization helps the agent understand the output beyond the raw schema properties.

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

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

The description clearly states the tool exports a document to a real file and returns its absolute path. It explicitly lists three formats (png, gif, aseprite_json) with their specific behaviors (transparency, animation, embedded spritesheet), and distinguishes itself from view tools by stating it is for delivery humans and contains no rendered 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 description provides a clear guideline to use view/view_frames for perception when the user needs to see the rendered image, which helps avoid misuse. However, it does not explicitly mention when to use this tool over other export-like siblings, though no direct siblings exist for exporting.

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 discloses that the tool does not create a document, returns hex colors and a swatch render, and is designed for extracting palettes. It could mention error conditions or side effects, but the given details are sufficient for safe use.

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?

Description is three sentences, front-loaded with the core purpose, and every sentence adds necessary information. No redundant or vague phrasing.

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

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

Given no output schema, the description adequately explains the return structure (list of hex colors + swatch). It covers parameter usage, algorithm, and integration with other tools. Could mention pagination or performance limits, but overall complete for a palette extraction 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 coverage is 100%, so baseline is 3. The description adds significant value: clarifying mutual exclusivity of 'path' and 'png_base64', explaining the quantization algorithm, and showing how output integrates with other tools (create_document, add_palette_color).

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 ('extract'), resource ('color palette from a PNG'), and method ('median-cut quantization'). It explicitly distinguishes itself from sibling tools like create_document and open_document by specifying 'WITHOUT creating a document' and contrasting with open_document.

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 explicit when-to-use ('Use this to pull a palette from a reference image') and when-not-to-use ('use open_document when you also want its pixels'). This directly guides the agent in selecting between 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?

No annotations are provided, so the description must disclose behavioral traits. It explains the key difference between contiguous=true/false. However, it does not mention that the tool modifies the document in place, whether it respects undo, or any side effects like symmetry handling. It lacks comprehensive transparency 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: two sentences, no filler. It front-loads the core action ('Flood fill from a seed pixel') and immediately explains a critical behavioral toggle. 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 has 10 parameters, 4 required, and no output schema, the description is inadequate. It does not explain return values (e.g., success indication, render), error conditions, or interaction with layers and frames. The user would need external knowledge to invoke it confidently.

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

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

Schema coverage is 80%, so the baseline is 3. The description adds meaningful context for the 'contiguous' parameter by explaining its effect ('recolors every pixel that matches the seed color'), which goes beyond the schema's 'Default true'. For other parameters, the description adds no new semantics, but the key parameter is clarified.

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

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

The description clearly states 'Flood fill from a seed pixel' with a specific verb (flood fill) and resource (pixels). It also explains the effect of the 'contiguous' parameter, distinguishing the tool's basic behavior from siblings like 'replace_color' or 'set_pixels'. The purpose 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 on when to use this tool versus alternatives such as 'replace_color' or 'set_pixels'. There is no mention of prerequisites, common patterns, or when not to use it. The description only states what it does, not when or why.

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 discloses the hue-shift behavior (cool shadows, warm highlights) and implies appending rather than replacing. However, lacking annotations, it does not cover side effects on existing palette, required permissions, or error conditions.

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 efficiently convey the core purpose and behavioral trait. No filler; front-loaded with the verb 'Append'.

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 and no output schema, the description explains the high-level effect but omits parameter details, return values, and error scenarios. It is adequate but not fully comprehensive for an agent to use reliably.

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 only hints at the base_hex parameter via 'base color' and mentions no other parameters. With 60% schema coverage, the description adds little beyond what is in the schema, failing to explain steps, hue_shift, or name.

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

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

The description clearly states the tool appends a shading ramp around a base color, specifying dark-to-light progression and hue shifts. This verb-resource-action combination is distinct from sibling tools like 'shade' or 'set_palette_color'.

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

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

No guidance on when to use this tool versus alternatives. It does not mention prerequisites, limitations, or compare to related tools like 'shade' or 'dither_gradient'.

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

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

With no annotations, the description carries the full burden. It explains resampling, palette mapping, and layer/stamp placement. However, it omits details on error behavior (e.g., what happens if both png_base64 and path are provided), aspect ratio handling during resizing, or constraints like file format limitations beyond PNG.

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 efficiently cover the core action, input specification, processing steps, and key distinction from a sibling. No fluff, front-loaded with the essential verb and resource.

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 complex tool with 16 parameters and no output schema or annotations, the description adequately covers the main use case and important constraints. Minor gaps exist, such as not mentioning the role of the clip parameter or skip_transparent behavior, but overall it provides sufficient context for an AI agent to select and 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 coverage is 100%, so parameter descriptions are already detailed. The description adds value by explaining the overall workflow (resample, palette, write) and the as_stamp parameter's purpose, which goes beyond individual parameter descriptions. It also clarifies the mutual exclusivity of png_base64 and path.

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 imports an external PNG onto the canvas, specifies the two input methods (png_base64 or path), and distinguishes it from open_document by noting it drops pixels into the current canvas rather than creating a new document.

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

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

The description explicitly positions this tool for importing external PNGs onto the current canvas and contrasts with open_document. However, it does not provide exhaustive guidance on when to use alternatives like paste_stamp or other import methods, though it does mention as_stamp for stamp storage.

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 bears full responsibility. It names the Bresenham algorithm and explains no_doubles, but omits behaviors like default symmetry mode (implied by ignore_symmetry parameter), coordinate clipping (clip parameter), or any side effects. The transparent aspects are partial.

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 front-load the main action. No wasted words; every phrase adds value (e.g., 'Bresenham', 'no_doubles' explanation).

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

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

No output schema exists, yet the description does not mention return values. Despite 12 parameters and several required ones, the description covers only the no_doubles behavioral detail. It misses context on prerequisites, coordinate system, or interaction with other tools (e.g., symmetry). Completeness is low.

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 58%, so baseline 3. The description adds meaning for no_doubles ('removes L-shaped double pixels for pixel-perfect diagonals'), which is absent in the schema. However, it does not explain the core parameters x1, y1, x2, y2 (endpoints) or the meaning of index (palette index). It adds some value but not fully compensating for the schema's 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 clearly states 'Draw a Bresenham line', specifying the verb (draw) and resource (line) with a specific algorithm. This distinguishes it from sibling drawing tools like rect, ellipse, 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 explicit guidance on when to use this tool versus alternatives like set_pixels or rect. The no_doubles mention implies a use case for diagonals, but no context on when to avoid 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 provided, the description carries full burden. It discloses that findings are advisory and nothing is auto-fixed, implying read-only behavior. However, it does not explicitly state that no state changes occur.

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

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

The description is a single clear sentence followed by a bullet list of rules. It is front-loaded and concise with no wasted words.

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

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

For a tool with 4 parameters (including nested region) and no output schema, the description lacks details on the structure of returned findings and how region interacts. It provides basic behavioral context but is incomplete for complex 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 100%, so baseline is 3. The description does not add meaning beyond the schema; it only lists the rules that can be passed via the 'rules' parameter but does not elaborate on frame, region, or doc_id.

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 'Run pixel-art quality checks and return findings with a render circling them', listing specific rules. This verb+resource combination is distinct from siblings like lint_waive and lint_unwaive.

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 vs alternatives like lint_waive or lint_unwaive. The description only states that findings are advisory, but doesn't contextualize within the 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?

No annotations are provided, so the description bears full responsibility. It clearly explains the behavior: removes a specific waiver if id is given, otherwise removes all waivers for the document. Additional context like reversibility or permissions would improve 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?

The description is a single sentence of 18 words, efficiently packaging the main action and conditional logic. No unnecessary words.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the core functionality well. It explains both modes of operation. Mentioning return values or error cases would be a minor improvement.

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 50% (only doc_id described). The description adds meaning to waiver_id by stating it is the id of the waiver to remove, and clarifies the optionality (if no id, all waivers are removed). This partially compensates for the missing schema 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 action (remove), the resource (lint waiver/document), and the conditional behavior (by id or all). It distinguishes from siblings like lint_waive, which likely adds waivers.

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

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

The description explicitly covers two use cases (remove one waiver by id or all waivers for a document). It implies when to use each, but does not provide explicit when-not-to-use or alternative 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?

No annotations; description discloses persistence and counting behavior. Lacks details on side effects, reversibility, or error conditions, but covers core behavior adequately.

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 front-loaded with main action, then scope detail. No wasted words.

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

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

Missing output schema and description does not mention return values or error handling. For a mutation tool, some indication of success/failure would be helpful.

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 covers all parameters at 100%. Description adds meaningful context for the region parameter (scope logic) and note (why waived), improving beyond basic schema descriptions.

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

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

Clearly states it waives lint findings persistently, distinguishing from lint_unwaive (undo) and lint (find). Uses specific verb+resource and explains scope variation.

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 says when to use region for scoped waiving vs omitting for whole rule. Provides clear context but does not explicitly compare with lint_unwaive.

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 that documents from other sessions are included, which is a significant behavioral trait. However, it does not explicitly state that the operation is read-only or non-destructive, though that is implied by 'list'.

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

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

The description is a single, concise sentence that front-loads the core purpose and scope. No extraneous words or redundancy.

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

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

Given the tool has no output schema, the description should ideally indicate what the list contains (e.g., document names, IDs). It does not mention the return format, which is a minor gap. However, the tool is simple and low-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?

There are no parameters, and the schema coverage is 100% (empty properties). The description adds meaning by explaining what the list contains, which goes beyond the empty schema. Baseline for 0 parameters is 4.

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

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

The description clearly states the verb 'list' and resource 'documents', and specifies the inclusive scope (including from other sessions). It distinguishes from sibling tools like create_document or open_document by focusing on listing what already 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 implies usage for viewing all documents, but does not explicitly state when to use this tool versus alternatives like search or filtered listing. No exclusions or when-not-to-use guidance 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 full burden. It only discloses the mutual exclusivity constraint. It does not mention what happens if the ref_id already exists, error handling, file size limits, permission needs, or whether the operation is destructive.

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

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

Single sentence, 20 words, front-loaded with verb and resource, no redundant information. 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 description covers the main action and purpose, and references two sibling tools, but lacks details on error behavior, id uniqueness, path resolution, and output. For a storage tool with no output schema, more behavioral context would improve completeness.

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 67%, and the description adds little beyond what the schema already provides (mutual exclusivity is restated). The purpose clause ('for quantizing or side-by-side viewing') gives context but does not enhance parameter semantics.

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

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

The description clearly states the verb 'Store' and resource 'reference PNG', specifies that it is supplied via one of two mutually exclusive inputs (png_base64 or path), and identifies the purpose ('for quantizing or side-by-side viewing'), which distinguishes it from siblings like quantize_reference and view_reference.

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

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

The description implies usage context by mentioning the purpose and the mutual exclusivity of inputs, but does not explicitly state when to use this tool vs alternatives, nor does it provide guidance on when not to use it 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 full burden. It discloses key behaviors: non-transparent top pixels replace bottom pixels, and partial opacity is discarded. This provides useful transparency beyond the 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?

Two sentences, no filler. The core action and important behavioral details are front-loaded. 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?

The description adequately explains the merge operation's pixel behavior and opacity handling. No output schema exists, but the return value is likely implicit. For a simple tool, it is complete enough.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds no additional meaning beyond the schema, which already specifies the default for layer. Baseline 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 action 'Merge a layer into the one below it', specifying the verb and resource. It distinguishes from sibling tools like reorder_layer or remove_layer.

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

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

The description does not explicitly state when to use or avoid this tool. It implies usage for merging layers, but lacks guidance on alternatives or prerequisites, though for a straightforward operation it is acceptable.

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 does not disclose that the operation modifies the image, potential side effects (e.g., out-of-bounds clipping with clip parameter), or any destructive nature. The minimal description omits critical 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?

A single, 12-word sentence is extremely concise and front-loaded. Every word adds value.

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

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

For a tool with 8 parameters, nested objects, and no output schema, the description is too minimal. Missing behavioral details, usage examples, and interaction between 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 100%, so baseline is 3. The description adds no extra parameter context beyond what the schema provides.

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 'mirror' and the resource 'region', and the phrase 'in place across its own bounding-box axis' defines the scope. It distinguishes from sibling tools like move_region or shift_layer.

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

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

No guidance on when to use this tool vs alternatives. The description only states what it does without context 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?

Discloses append vs overwrite behavior and interpolation parameter t, but lacks details on error handling, side effects, or return value. Adequate but incomplete.

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

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

Two sentences with front-loaded purpose and compact details. No unnecessary words.

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

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

Covers key aspects but missing return value, error conditions, and prerequisites (e.g., palette existence). Adequate for simple tool but not thorough.

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 67% (4 of 6 parameters described). Description adds value by explaining t interpolation and into_index overwrite behavior, but does not describe the name parameter.

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

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

Description clearly states it blends two palette colors and stores the result, with specific details about interpolation. Distinct from sibling tools like set_palette_color or add_palette_color.

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 states it's for creating in-between shades via interpolation, implying use case. No explicit when-not-to-use or comparison to alternatives, but context is clear.

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

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

The description discloses that the old location is cleared, a key behavioral trait. With no annotations, the description carries the full burden. It does not mention side effects on layer/frame, undo history, or error handling, but the core mutating behavior is stated.

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

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

A single sentence of 9 words that directly conveys the core purpose. No superfluous content.

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

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

Given the tool's complexity (9 params, nested region object, no output schema), the description omits details like how to specify the region (rect/pixels/selection), error conditions, and return values. It is insufficiently complete for an AI agent to use reliably without additional 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 high (78%), so the schema already documents most parameters. The description adds no extra meaning to parameters beyond the schema. Baseline 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 verb 'Move' and the resource 'region', specifying the operation of moving by (dx,dy) and clearing old location. It distinguishes from sibling tools like copy_region and cut_region.

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

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

No guidance on when to use this tool versus alternatives like shift_layer or copy_region. No prerequisites or exclusions mentioned. Usage 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?

No annotations are provided, so the description must carry the burden. It discloses key behaviors: import, quantization, size limit, exclusivity of inputs. However, it doesn't mention error handling (e.g., if both or neither source given), whether the file must exist for path, or the return value after creation. Missing details lower transparency.

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

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

Two concise sentences: first states action and exclusive sources, second states constraints. No filler words. Front-loads the core purpose. 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?

The description covers input constraints adequately but omits output behavior (e.g., returns document ID?), error cases, and any side effects on existing documents. Given no output schema or annotations, more detail on success conditions would improve completeness.

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 descriptions cover 100% of parameters. The description adds value by summarizing the quantization behavior of max_colors and reinforcing exclusivity of png_base64 and path. However, the schema already explains each parameter well, so the description's added semantics are marginal. Baseline 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 specifies the action (import PNG as new document), the two exclusive sources, and constraints (quantizing, max_colors, max 256x256). It distinguishes this tool from siblings like 'create_document' (no import) and 'import_image' (likely no quantization or size limit).

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 states when to use (importing a PNG with quantization and size limit) and clarifies mutual exclusivity of the two sources. It doesn't explicitly mention when not to use or provide alternatives, but the constraints are clear enough for appropriate 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?

With no annotations provided, the description carries the full burden of explaining behavior. It explains the basic effect (1px border) and mode differences, but omits details such as whether the operation is destructive, permissions needed, or how it interacts with transparency. The description is adequate but lacks depth.

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

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

The description is concise, consisting of two sentences. It front-loads the main action and provides essential details without extraneous information.

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

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

Given the tool has 9 parameters including nested objects and no output schema, the description is too sparse. It does not explain the region parameter, clip behavior, or return format. Essential context for proper usage 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 input schema has 89% description coverage, so the baseline is 3. The description adds value by explaining the 'mode' parameter ('outside' draws into transparent pixels; 'inside' onto the shape's edge). Other parameters like clip, region, etc., are not elaborated beyond what the schema provides.

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 draws a 1px border around non-transparent pixels, specifying two modes ('outside' and 'inside'). It distinguishes the tool's action with a specific verb and resource, and differentiates between the mode options.

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 line, rect, or ellipse. It does not mention scenarios, prerequisites, or when not to use it.

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

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

With no annotations, the description carries full burden. It discloses key behavioral traits: writes to disk, no preview returned, variable sprite sizes with automatic cell sizing, and optional base64 return. However, it does not mention whether the document is modified or other 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?

Two concise sentences with no wasted words. The first sentence provides the core operation and order, the second adds crucial context about delivery nature and the lack of preview. 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 9 parameters with complex defaults and no output schema, the description adequately covers the overall behavior, output format, and key defaults. It could mention that sprites are frames from documents, but that is evident from the 'doc_id' and 'frame' fields in the schema. Missing explicit mention of row-major order impact on layout, but it's clear enough.

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 high (89%), so baseline is 3. The description adds value by explaining 'cell dimensions default to the largest sprite', 'transparent border', and 'transparent pixels between cells', which directly clarify parameters margin, spacing, cell_width, cell_height. This goes beyond schema descriptions.

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

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

The description clearly specifies the action ('Pack document frames'), the output ('transparent PNG sprite sheet'), and the order ('row-major'). It also distinguishes itself by stating 'This is delivery output and returns no preview image,' differentiating from possible preview tools among siblings.

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

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

The description lacks explicit guidance on when to use this tool versus alternatives like 'export' or 'split_sprite_sheet'. It only implies final delivery by stating 'delivery output' and 'no preview', but does not provide when-not-to-use or name alternative 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?

No annotations are provided, so the description carries full burden. It explains the character encoding and behavior of '.' as transparent, but does not explicitly state that the operation is destructive (overwrites pixels) or mention other behavioral traits like boundary handling.

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, both concise and front-loaded with essential information. It packs the entire character mapping and usage intent into a single sentence, with no redundant words.

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

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

Given the complexity (10 parameters, 4 required) and lack of output schema or annotations, the description covers the core functionality well. It explains the input format and key parameters, though it doesn't describe return values or error handling, which is acceptable for a write 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 coverage is 100%, so baseline is 3. The description adds significant value by explaining the grid text format (character mapping to palette indices) and the meaning of '.' and other characters, which goes beyond the schema's description of 'Rows of palette-index characters'.

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 'Bulk-write a region from grid text', specifying the verb (write), resource (region), and format (grid text with character mapping). It distinguishes from sibling tools like paste_stamp which likely paste image data.

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 says 'The workhorse for blocking in shapes', implying it is the primary tool for that task and suggesting when to use it. However, it does not explicitly state when not to use it or provide alternatives, but the sibling list offers other drawing tools.

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

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

With no annotations provided, the description fully bears the burden of disclosure. It transparently states that transparent pixels are skipped by default and that symmetry is ignored, explaining the rationale. It does not cover error handling or stamp existence validation, but the key behavioral defaults are well covered.

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

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

The description is extremely concise, using only three sentences to convey purpose, default transparency behavior, and key symmetry distinction. Every sentence earns its place with no redundancy.

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

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

Given the tool has 13 parameters and no output schema, the description is adequate but lacks details on failure modes, required parameters (x, y, name), and the effects of optional parameters like clip, frame, and render. It focuses on the most important behavioral traits but misses some contextual details.

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

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

The description adds value beyond the input schema by explaining the default behaviors for skip_transparent and ignore_symmetry, and emphasizes that flips and rotation are optional. With only 54% schema description coverage, it compensates by highlighting the most critical parameter behaviors.

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 pastes a named stamp with optional flips and rotation, directly indicating its primary function. It also distinguishes from siblings by noting the default symmetry behavior, making its specific use case 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 a hint about when to use this tool versus others by mentioning that it ignores document symmetry by default, contrasting with other tools. However, it does not explicitly name alternative tools or provide exhaustive when-not-to-use 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?

Discloses important behavior: renders on checkerboard, human-facing only, and that most clients show a single still, so it doesn't verify motion. No annotations to contradict.

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, front-loaded with the core purpose, then provides critical usage guidance. No wasted words.

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

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

Given no output schema, description adequately explains output (GIF) and includes important caveat about motion verification. Could mention return type but sufficient for intended use.

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 covers 100% of parameters with descriptions. Description adds no extra parameter meaning beyond 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?

Clearly states it renders animation as a GIF with checkerboard background. Differentiates from sibling view_frames by noting it doesn't verify motion.

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 states human-facing output only and advises using view_frames to check motion, providing clear when-not-to-use 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 full burden. It discloses downsampling, palette mapping, and optional layer writing, but does not clarify side effects (e.g., whether original reference is modified) or return value. Moderate transparency, but missing behavioral details.

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 (approximately 30 words), front-loading the core action and options. Every sentence provides value; no redundancy or fluff.

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 8 parameters, no output schema, and no annotations, the description covers the main functionality but lacks details on defaults for dither and max_colors, and does not explain the absence of to_layer. It is adequate but not thorough.

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 63%, and the description does not add significant meaning beyond the schema. For instance, width and height are only described with min/max, and palette options are already enumerated. The description adds no new semantics, so baseline score applies.

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

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

The description clearly states the action (downsample and map palette), the resource (reference), and the two palette modes ('document' or 'auto') with optional layer output. It effectively distinguishes the tool from siblings by specifying its unique quantization 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 outlines the two palette modes and optional layer writing, but does not provide explicit guidance on when to use this tool over alternatives like extract_palette or mix_palette_colors. Usage context is implied but not clearly stated.

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

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

No annotations provided; description does not mention document modification, coordinate handling, or whether changes are destructive. Minimal 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?

Single short sentence is concise, but lacks structure and detail. Could be expanded without losing conciseness.

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

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

With 12 parameters and no output schema, description fails to explain coordinates, return values, or side effects. Incomplete for a complex drawing 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?

Description only hints at 'filled' parameter; does not explain x, y, w, h, index, or other parameters. Schema has some descriptions but coverage is 58%.

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?

Description clearly states tool draws a rectangle, optionally filled or outlined. Distinguishes from sibling tools like line and ellipse.

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

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

No guidance on when to use this tool vs alternatives like flood_fill or outline. No prerequisites or context 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?

Without annotations, the description carries full burden but only states the action. It does not disclose that redo only works if there are undone edits, potential side effects, or state changes. This is insufficient for an agent to anticipate behavior.

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

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

The description is a single concise sentence with no wasted words. However, it could be slightly expanded to include key behavioral context without sacrificing conciseness.

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

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

For a simple tool with no output schema, the description omits important context like the prerequisite of having undone edits and the impact on document state. It feels incomplete given the richness of sibling 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 100% (all three parameters have descriptions). The tool description adds no additional context beyond the schema, so baseline 3 applies.

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

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

The description 'Redo previously undone edit(s)' is a specific verb+resource that clearly states the tool's action. It distinguishes from the sibling 'undo' by the word 'redo', making its purpose unambiguous.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies usage after an undo operation, but it does not mention prerequisites or alternatives. It meets the minimum viable standard.

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, and the description only says 'Delete a frame' without disclosing side effects (e.g., impact on other frames, permissions needed, or return value). This leaves significant behavioral ambiguity.

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?

Extremely concise but under-specified. While front-loaded, it lacks essential details about parameters and behavior, so it fails to earn its 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's simplicity (2 parameters, no output schema), the description is incomplete. It does not clarify the frame parameter's role or return behavior, lacking completeness for effective use.

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 50% coverage (only doc_id described). The description does not explain the 'frame' parameter beyond the schema's type and minimum, so it adds no semantic 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 'Delete a frame' clearly states the action and resource. It distinguishes from sibling tools like add_frame or reorder_frame, though it lacks context about what 'frame' means here.

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

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

No guidance on when to use this tool versus alternatives. The description does not specify prerequisites or when not to use it, making it purely factual without 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 full burden but only states the action and scope. It omits important behavioral traits such as undoability, permissions, or side effects on other layers.

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

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

The description is a single, front-loaded sentence with no wasted words, efficiently conveying the core action.

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

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

For a simple tool with two parameters and no output schema, the description is minimally adequate but lacks safety warnings or notes on irreversibility, which would be helpful for a destructive operation.

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

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

Schema coverage is 100% with clear parameter descriptions. The tool description adds no additional meaning about parameters beyond what the schema provides, so baseline 3 applies.

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

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

The description clearly states the verb 'Delete' and the resource 'layer', and specifies that it affects pixels on every frame, distinguishing it from sibling tools like 'add_layer' or 'rename_layer'.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., 'set_layer_visibility' or 'merge_down'), nor any when-not-to-use conditions.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors (remapping pixels, index shifting) but omits details like required permissions, reversibility, or side effects on other elements.

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

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

Two sentences with no redundant words. The core action and key behavioral nuance (index shift) are front-loaded.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It does not mention return values, error cases (e.g., index out of bounds), or prerequisites like palette size constraints.

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 significant meaning beyond the schema: it explains that `remap_to` is where existing pixels go and that higher indices shift down. The schema covers 100% of parameters with descriptions, but the description ties them together operationally.

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 'Delete' and resource 'palette entry', and specifies the remapping behavior and index shifting. This distinguishes it from sibling tools like `set_palette_color` or `swap_palette_indices`.

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 only implicitly states when to use (delete a palette entry) but provides no explicit guidance on when not to use it, prerequisites, or alternative tools (e.g., `replace_color` or `adjust_palette_color`).

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

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

No annotations exist, so the description carries full burden. It only states the rename action without disclosing behavioral traits like whether the layer must exist, return values, or side effects. Minimal transparency.

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

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

The description is extremely concise at one sentence. For a simple rename operation, this brevity is acceptable, but it comes at the cost of omitting helpful details. The single 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?

For a tool with three required parameters and no output schema, the description fails to explain constraints, error conditions, or behavior. Sibling tools provide context, but the description alone is incomplete.

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

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

With 33% schema description coverage, only doc_id has a description. The description adds no meaning beyond the schema for the three parameters (doc_id, layer, name). Parameters remain vague.

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 'Rename a layer.' clearly states the verb (rename) and resource (layer). It distinguishes from sibling tools like add_layer, remove_layer, and reorder_layer. However, it lacks context such as the document or layer specification.

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 reorder_layer or set_layer_visibility. The description does not mention prerequisites or common use cases.

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

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

No annotations provided, and the description does not explain side effects (e.g., whether moving shifts other frames, if indices are 0-based or 1-based, or if it's a swap). Lacks details on behavior.

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

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

Single concise sentence, front-loaded with purpose. No unnecessary words, but could add more detail without losing conciseness.

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

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

For a 3-parameter tool with no output schema, the description is insufficient. It does not convey the exact mechanics of the reordering (e.g., shift vs swap, index ranges). Leaves ambiguity.

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

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

Schema coverage is 33% (only doc_id described). The description does not explain 'from' and 'to' parameters (e.g., indices, constraints). Fails to compensate for low schema coverage.

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

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

The description clearly states the action (move), resource (frame), and target context (new position on timeline), distinguishing it from siblings like add_frame and remove_frame.

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

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

No guidance on when to use this tool versus alternatives (e.g., reorder_layer or other frame operations). Lacks context about prerequisites or constraints.

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 bears full burden. It does not disclose potential side effects (e.g., order of other layers), error handling (e.g., invalid target position), or whether the operation is undoable. Only minimal behavioral context is given.

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 of 13 words, extremely concise and front-loaded with the key action. No unnecessary information.

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

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

Given no output schema, no annotations, and 3 parameters, the description leaves many gaps: no return value, no error conditions, no undo behavior. For a layer reordering tool, more context is needed for proper invocation.

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

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

The description adds meaning by explaining the 'to' parameter as a position with 0=bottom, which the schema only specifies as integer minimum 0. However, it does not clarify the 'layer' parameter (e.g., whether it is a name or id). With schema coverage at 33%, the description partially compensates.

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 moves a layer to a new position in the stack, with '0 = bottom' clarifying the parameter. It distinguishes this from sibling tools like add_layer, remove_layer, or rename_layer which perform different operations.

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. There is no mention of when to use this tool, prerequisites (e.g., layer must exist), or alternatives among sibling tools like reorder_frame for frames.

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 adds some behavioral context (palette untouched, region restriction) but lacks details on side effects (e.g., pixel modification is permanent, undo behavior, or performance implications). Adequate but not thorough.

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

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

Single sentence efficiently conveys core purpose and optional region feature. No fluff, front-loaded with key action.

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

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

For a moderate-complexity tool (7 params, nested region, no output schema), the description covers the main operation and key option. Could mention that it modifies layer in place, but overall sufficient.

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 high (86%); description adds marginal value beyond schema. It contextualizes region restriction but does not elaborate on parameter meanings beyond what schema already provides.

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?

Description clearly states the tool replaces pixels of one palette index with another on a layer, specifies palette is untouched, and mentions optional region restriction. This distinguishes it from siblings like set_palette_color or swap_palette_indices.

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?

Description implies usage for color replacement without modifying palette, but does not explicitly state when to use vs. alternatives like swap_palette_indices or set_palette_color. No when-not or alternative references.

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 reveals important behaviors: content placement via anchor, transparent new area, and clearing saved selections. However, it does not disclose what happens when width/height is smaller than current canvas (e.g., cropping), nor any permissions or undo behavior.

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

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

Three sentences with no extraneous content. The most critical information is front-loaded: 'Resize the canvas'.

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 anchor behavior and selection clearing, but omits details on cropping when dimensions decrease, the render parameter, and return value. Given five parameters and no output schema, more detail is expected.

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 60%. The description mentions 'anchor' and 'transparent new area', which adds context but does not fully compensate for the missing parameter descriptions. The schema already describes anchor and render, but width/height lack descriptions; the description does not clarify them.

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 explicitly states 'Resize the canvas' which is a specific verb and resource. It distinguishes from siblings by detailing unique behaviors like anchor placement and clearing selections, which are not found in other sibling tools.

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

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

No guidance is provided on when to use this tool vs alternatives. There is no mention of prerequisites, when not to use, or comparisons to sibling tools like shift_layer or mirror_region.

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 full burden. It states the tool stores a named selection but does not disclose whether the operation is reversible, requires authentication, or has side effects like overwriting existing selections. This is insufficient for a save-like 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?

Single sentence, no wasted words. However, it could be slightly more detailed without becoming verbose. The front-loading is good as the verb 'Store' immediately conveys the action.

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

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

Description does not mention return values or confirmation, and the tool has a nested object parameter requiring explanation beyond the schema. Given no output schema, the description should clarify what happens upon success or failure. It is incomplete.

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 67%, with doc_id and region described. The description does not add any parameter-specific meaning beyond the schema. The 'name' parameter lacks a description, but the overall schema is moderately explanatory. Baseline 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 'Store a named selection that region parameters can reference later' clearly states the action and resource. It distinguishes the tool from siblings like copy_region or paste_stamp by specifying the saving for later reference, though it could be more explicit about the 'region parameters' context.

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

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

No guidance on when to use this tool versus alternatives is provided. The description implies it is used for saving selections for later reference, but does not explain when to prefer it over direct region definitions or other selection 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?

No annotations provided, so the description carries the full burden. It discloses randomness, determinism, and weights biasing. However, it does not explicitly state that it modifies the layer or whether it overwrites existing pixels, leaving some behavioral gaps.

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

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

The description is three sentences, front-loaded with the main action, then use cases and determinism/weights. Every sentence adds value 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?

With 11 parameters and no output schema, the description covers key points but lacks explanation of return values (e.g., render) and precise behavior of density. It is adequate but not fully comprehensive.

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

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

Schema coverage is 100% with detailed descriptions for each parameter. The main description adds minimal extra meaning ('weights biases which indices are picked'), so it meets the baseline but does not exceed.

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

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

The description clearly states the action ('scatter pixels') and the resource ('palette indices across a region'), with specific use cases (grain, noise, textures). It is uniquely distinguished from sibling tools like set_pixels, line, etc.

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 specific use cases ('for grain and noise: stone, dirt, wood texture') and notes determinism for reproducibility. It lacks explicit when-not-to-use or alternative tool comparisons, but the context is clear.

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

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

No annotations are present, so the description must fully disclose behavior. It only states the purpose without mentioning side effects (e.g., whether an invalid frame index creates a new frame or errors) or any state changes beyond setting the default 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 sentence that is front-loaded and contains no unnecessary words. It efficiently conveys the core purpose, though additional context could be added without harming conciseness.

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

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

Given the simplicity of the tool (2 parameters, no output schema), the description is minimally complete but lacks essential details like error conditions (invalid frame index), return value, or prerequisites (document must exist). For an agent to use it correctly, more 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?

The input schema covers 50% of parameters (doc_id has a description). The tool description does not add any further meaning to the parameters, such as clarifying that 'frame' is a 0-based index or the expected format for doc_id.

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 'Set the default target frame for editing tools' clearly identifies the action (set) and the resource (default target frame). It distinguishes the tool from sibling tools like add_frame or set_frame_duration that deal with frame management but with different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., when to change active frame, prerequisites like document existence). No when-not or context hints are given.

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

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

With no annotations, the description must disclose behavioral traits. It only states the basic purpose, omitting details like failure modes (e.g., invalid layer/document), side effects, or prerequisites. This leaves significant gaps for an agent.

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

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

Single sentence of 8 words, no redundancy. It is efficient, though could marginally expand to include a hint about what constitutes an editing tool without becoming overly long.

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 lacks contextual details about expected behavior, error states, or usage conditions. It feels incomplete for a tool with two required 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 coverage is 100% with descriptions for both parameters. The description does not add extra meaning beyond the schema, which meets the baseline but does not compensate for any 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 clearly states the action (set) and the resource (default target layer for editing tools). It distinguishes this tool from sibling tools like add_layer, remove_layer, set_layer_visibility, and set_active_frame.

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

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

The description implies usage before editing operations, but provides no explicit guidance on when to use versus alternatives, nor exclusion criteria. The context is clear but not fully elaborated.

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 fully disclose behavioral traits. It only states the action, omitting side effects (e.g., mutation, undoability, whether the document is modified in place). 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 very concise at one sentence, with no redundancy. However, it could be structured to include more information without sacrificing 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 complexity (3 required params, no annotations, no output schema), the description is incomplete. It lacks return value info, side effects, and any context that an agent would need to safely invoke 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 only 33% (only doc_id has a description). The description does not clarify the meaning of 'frame' (e.g., index, ID), nor does it explain the significance of the duration constraints beyond what the parameter name implies. Minimal added value.

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 'Set' and the resource 'how long a frame displays' with the unit 'ms'. It unambiguously defines the tool's function and distinguishes it from sibling tools like set_active_frame or add_frame.

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

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

No guidance is provided on when to use this tool vs alternatives, nor does it mention prerequisites (e.g., the document must exist, the frame must exist). The agent is left without context 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?

Description states lock/unlock effect but no annotations provided. Lacks details on side effects, permissions, or what 'against edits' means in practice (e.g., can the layer still be selected?). Minimal 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?

Single sentence is concise but under-specified. No wasted words, but lacks structure or additional context that would aid understanding without being verbose.

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

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

Given low complexity (3 params, no output schema), the description should explain more. Lacks return value info, clarification on boolean locked, and integration with sibling tools. Insufficient for correct agent 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 33% (only doc_id described). Description adds no parameter meaning beyond schema; e.g., 'locked' parameter not clarified (true=locked? false=unlocked?). Does not compensate for missing schema descriptions.

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

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

Description clearly states it locks or unlocks a layer against edits, with specific verb and resource. Distinguishes from siblings like set_layer_visibility (visibility) and set_active_layer (active layer).

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

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

No guidance on when to use vs. alternatives, no prerequisites or when-not-to-use. For example, does the layer need to exist? Should this be called only after adding a layer?

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

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

With no annotations, the description carries full burden but only states a brief mutating action. It does not disclose whether the operation is reversible, affects other layers, triggers side effects, or requires specific permissions, leaving significant behavioral traits unclear.

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

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

Single sentence, no redundancy, and the core purpose is front-loaded. However, the extreme brevity risks underspecification, but for a simple toggle it is appropriately concise.

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

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

Given no output schema, low schema coverage, and no annotations, the description is insufficiently complete. It does not explain return values, error states, or the exact behavior when a layer is already in the requested visibility state, which is critical 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?

Only 33% schema description coverage, and the description adds no parameter-specific meaning. The 'visible' boolean and 'layer' string are not elaborated (e.g., layer name vs ID, whether visible is a toggle or explicit set), so an agent must infer 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?

Description 'Show or hide a layer.' clearly states the action and resource. It distinguishes from sibling tools like set_layer_lock or add_layer by focusing on visibility toggling, but lacks specificity about the layer identification method.

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