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

No annotations are provided, so the description carries the burden; it does disclose that the tool scans the filesystem and defaults to workspace-assets, which implies a read-only, side-effect-free operation. However, it never states that nothing is mutated, nor whether the scan can be slow or is recursive.

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

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

One sentence, front-loaded with the action and the resource, with the destination directory and purpose following. Slightly overloaded with a four-item noun list ('images, icons, logos, and graphic assets'), but no wasted sentences.

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

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

For a one-optional-parameter read tool with no output schema and no annotations, the description covers what it does, where it looks, and what the results are for. Return structure is unspecified, but with no output schema that is a minor gap.

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

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

Schema coverage is 100% and the single optional 'directory' parameter is already documented as defaulting to workspace-assets. The description restates that default but adds no format, relative-vs-absolute path guidance, or recursion behavior 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?

States a specific verb+resource: scans and lists local graphic assets in the workspace-assets directory. The word 'local' and the directory scope help separate it from siblings like assets_list_stickers, assets_list_patterns, and assets_list_stock_pngs, though it never names them explicitly.

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

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

Usage is only implied by the trailing phrase 'ready to be placed onto the canvas' – the agent can infer this is the pre-step before adding local assets. There is no statement of when to prefer this over assets_list_stock_pngs or assets_load_from_path, and no exclusions.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the exact contents returned (the seven preset names), which is real behavioral value, but it never states that this is a read-only, side-effect-free enumeration or mentions any pagination/auth behavior.

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

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

A single front-loaded sentence with the verb and resource first and the enumeration following. Every token earns its place; there is no filler.

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

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

For a zero-parameter, no-output-schema listing tool, the description is largely complete because the enumeration substitutes for a return-value schema. The only missing piece is a pointer to the sibling that consumes these patterns.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond confirming the listing is unfiltered.

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

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

States a specific verb (Lists) and a precisely bounded resource (built-in geometric pattern and texture background presets), then enumerates the actual presets. An agent can tell it apart from canvas_set_pattern by name, but the description never names or contrasts with that sibling.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and the relevant alternative (canvas_set_pattern, which presumably applies one of these) is not mentioned. Usage is only implied: an agent lists presets to discover names before applying them.

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

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

No annotations are provided, so the description carries the burden. 'Lists' and 'built-in' imply a static, read-only catalog with no side effects, which is adequate behavioral signaling, but nothing is said about result size, pagination, or whether the listed assets are filtered by anything.

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

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

One front-loaded sentence with no preamble. It is slightly redundant in repeating 'available ... available for insertion', but that is a minor blemish on an otherwise efficient line.

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

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

With no annotations and no output schema, the description should ideally say what the listing returns (identifiers, names) and how it pairs with sticker_add. It conveys the catalog's nature but stops short of completing the picture for an agent that must then act on the results.

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

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

The tool takes zero parameters, so there is no parameter surface to document; the schema baseline of 4 applies. The description correctly adds no parameter claims.

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?

Specific verb ('Lists') plus resource ('built-in SVG stickers, badges, and vector elements'), which distinguishes it from siblings like assets_list_patterns, assets_list_stock_pngs, and assets_list_local. The distinguishing attribute is the built-in SVG nature of the assets.

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

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

Usage is implied by the phrase 'available for insertion' — an agent can infer this is the discovery step before sticker_add. However, no alternative sibling is named and no explicit when/when-not guidance is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, yet it only enumerates content categories. It does not state that this is a read-only catalog listing, whether results are paginated/filtered, or what form the assets come back in for placement.

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 front-loaded sentence with the verb first. It is somewhat adjective-heavy ('curated royalty-free', 'holographic') but nothing is padding in a way that harms selection.

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

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

For a zero-parameter read tool with no output schema, the description is minimally sufficient but omits how the listed assets connect to downstream tools such as element_add_stock or assets_load_from_path, which would help an agent complete the placement workflow.

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

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

The tool takes zero parameters, so there is nothing for the description to explain; baseline 4 applies. The description correctly does not invent parameter guidance that doesn't exist.

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 verb 'Lists' plus the resource 'free transparent 3D cutout assets' states exactly what the tool returns. The enumerated content types (cutouts, holographic spheres, flares, photography) implicitly separate it from siblings like assets_list_stickers and assets_list_patterns, though no sibling is named.

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 never says when to call this versus the other asset-listing siblings (assets_list_stickers, assets_list_patterns, assets_list_local) or elements_search. No prerequisites or workflow context is given beyond the vague phrase 'available for instant placement'.

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

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

With no annotations, the description carries the full burden and does disclose the meaningful behavior: it reads from local disk, encodes to Base64, and returns a data URL rather than a file handle. It does not mention failure modes (missing file, permission denied) or size/format limits, which is the remaining gap.

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

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

A single well-formed sentence that front-loads the verb and resource, then appends the return value. No filler, no restatement of the title, and the example is inline rather than a separate paragraph.

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

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

For a one-parameter read tool with no output schema, the description usefully specifies the return artifact (data URL), removing the biggest ambiguity. It is only slightly short of complete because 'any local image or graphic file' leaves supported formats and file-size constraints unspecified.

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

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

Only one parameter and schema coverage is 100%, so the baseline is 3; the description earns an extra point by supplying a concrete example path format ('C:/Users/name/Desktop/logo.png') and explicitly confirming relative paths are accepted, which is more actionable than the schema's generic wording.

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

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

States a specific verb (reads), a specific resource (any local image or graphic file on the user's computer), and the full transformation pipeline (Base64 encode -> data URL). This is clearly distinguishable from siblings like assets_list_local (which enumerates) and image_add (which places an image already in the project).

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 trailing clause 'for use in canvas' hints at the intent, but the description never states when to pick this tool over assets_list_local, image_add, or element_add_stock. No preconditions or exclusions are given, so the agent must infer the selection rule.

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

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

No annotations are provided, so the description carries the full burden. It implies a canvas mutation but never says whether strokes are undoable (history_undo exists), whether the eraser style deletes existing pixels, or in what order points are rendered. The default size of 14 and the destructive potential of the 'eraser' mode are undisclosed.

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

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

A single front-loaded sentence that leads with the action and then the modifiers. Efficient, though slightly run-on with the whitespace-glitched style list.

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

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

For a 5-parameter, zero-annotation mutation tool with no output schema, the description is thin. It omits destructive/undo semantics, coordinate space, and the eraser's effect on existing content—exactly the context an agent needs before invoking a canvas-altering 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 80%, so most parameters are documented in the schema. The description does add value by listing the four valid brushStyle values, whose enum lacks an inline description, but it adds no coordinate-format or opacity semantics beyond what the schema already states. 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?

States a specific verb+resource ('Executes freehand brush drawing on the canvas') and enumerates the brush styles, color, size, and path. It is clearly distinguishable from siblings like shape_add or text_add, though it never names them explicitly.

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

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

No when-to-use guidance and no comparison to alternatives such as shape_add, sticker_add, or image_add for putting marks on the canvas. The agent must infer that this is the freehand option from the name alone.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the blast radius ("all layers and objects", not a selection), which is the key piece of context for a clear-all operation, but it says nothing about reversibility, confirmation, or whether the canvas background/settings survive.

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 front-loaded sentence with no filler, and the scope qualifier ("all") appears before the resource. Nothing could be removed without losing meaning.

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

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

For a zero-parameter but destructive operation with no annotations and no output schema, the description needs to state reversibility and any save-first expectation. It covers what is deleted but omits exactly the safety context an agent needs before invoking it.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to add. Baseline 4 applies; the description correctly avoids inventing or implying any arguments.

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

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

States a specific verb (clears) and resource (all layers and objects on the canvas), so an agent immediately knows it is a destructive canvas-wide reset rather than a layer-level operation like layer_delete. It does not, however, contrast itself with related tools such as layer_delete or canvas_create_new, so it stops short of full sibling differentiation.

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

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

There is no guidance on when to use this versus layer_delete (targeted removal) or canvas_create_new (fresh canvas), nor any warning precondition such as saving the project first. The availability of history_undo as a sibling makes an undo/reversibility note conspicuously absent.

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 behavioral burden. It discloses only that the result is blank and can have a background color; it says nothing about side effects on an existing canvas (replace vs. add page), permissions, or whether the operation is reversible. For a creation tool with zero annotation coverage, this is a significant gap.

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

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

A single tight sentence with the verb and key attributes front-loaded and no wasted words. It is efficient, though arguably under-specified rather than maximally informative.

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

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

With all four parameters documented in the schema and no output schema required, the description is minimally adequate for a creation tool. However, absent annotations, it omits side-effect and return behavior that an agent would need to call it confidently alongside canvas_set_dimensions and canvas_set_background.

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%, with each parameter documented (width/height in pixels, isTransparent, hex/RGBA backgroundColor), so the schema does the heavy lifting. The description references dimensions and background color but adds no format or interaction detail (e.g. isTransparent overriding backgroundColor) beyond what the schema already states. 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?

States a specific verb (creates) and resource (new blank canvas) with the two key attributes it configures (dimensions, background color). It implicitly distinguishes itself from canvas_set_dimensions and canvas_set_background by emphasizing 'new blank,' but never names those siblings or explicitly contrasts the create-vs-modify distinction.

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

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

The word 'new' implies this is for initializing a fresh canvas, but there is no explicit when-to-use guidance or mention of alternatives like canvas_load_template (start from a template) or canvas_set_dimensions/canvas_set_background (modify an existing one). Usage is inferable but not 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 are provided, so the description carries the full behavioral burden. It does not disclose whether loading a template replaces or merges with existing canvas content, whether the action is undoable, or what permissions/preconditions are required for a clearly mutating operation.

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

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

A single front-loaded sentence with the verb and resource first, followed by illustrative examples. The examples are somewhat long but they earn their place by showing the identifier space; nothing is redundant.

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

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

For a simple one-parameter tool with no output schema, the description is minimally sufficient. However, the key behavioral question for an agent — whether the current canvas is replaced or preserved — is left unanswered, which matters for a mutation tool with 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 coverage is 100% and there is only one required parameter, so the schema already documents templateId adequately. The example identifiers ('social-launch', 'youtube-thumbnail', etc.) add mild value by hinting at the naming convention, but no enum or format rule is stated, so 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?

Names a specific verb and resource ('Loads a pre-designed layout template onto the canvas'), which is unambiguous and distinct from the sibling templates_list (which enumerates rather than applies templates). It stops short of explicitly contrasting itself with siblings like canvas_create_new or templates_list, so it falls just short of a 5.

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

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

No when-to-use or when-not-to-use guidance is given. The description never says where templateId comes from (presumably templates_list) nor when to prefer loading a template over canvas_create_new. Usage can only be inferred from the verb.

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

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

No annotations are provided, so the description carries the full burden. It discloses the mutation (setting background color or alpha transparency) but does not say whether it overwrites an existing background, whether it is undoable, or what permissions/state it requires.

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 core purpose sentence is front-loaded and tight, but the second sentence is a long, promotionally-toned NOTE that is mostly about other tools rather than this one. It has routing value for AI designers, yet it inflates the definition considerably.

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 two-parameter tool with full schema coverage and no output schema or annotations, the description covers the essential ground and adds cross-tool routing. Only the lack of overwrite/undo behavior keeps it from being fully complete.

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

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

Schema description coverage is 100%, so both parameters are already documented with hex format and boolean semantics. The description's phrase 'solid background color or enables alpha transparency' loosely maps to color/isTransparent but adds no format or constraint detail 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?

States a specific verb and resource ('Sets the solid background color or enables alpha transparency'), which cleanly separates it from the sibling tools canvas_set_gradient and canvas_set_pattern. An agent can tell immediately what this tool governs.

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 routes the agent away from this tool when a richer background is desired, naming concrete alternatives (image_add with { isBackground: true }, assets_list_patterns, assets_list_stock_pngs, assets_list_local). It gives clear context for selection but never states when this tool is the required choice over those alternatives.

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

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

With no annotations, the description carries the full behavioral burden for what is a mutation tool. It never states whether resizing crops, scales, or repositions existing layers, whether it requires any permission, or whether changes are reversible — all material for a destructive-ish canvas 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?

A single tight sentence with the core action front-loaded and the preset list as useful detail. No filler, though the parenthetical preset list borders on dense.

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-param zero-required mutation tool with no annotations and no output schema, the definition is only partially complete. It documents presets but omits the parameter-interaction rule (does preset override width/height?) and any behavioral effects on existing content.

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 schema already documents all three parameters, making 3 the baseline. The description adds preset names (Instagram Post, Story, etc.) that map dims to intent, but it leaves the critical preset-vs-width/height precedence rule unexplained.

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

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

States a specific verb (changes/sets) and resource (canvas dimensions), and concretely enumerates the preset options with their meanings. It is clearly distinguishable from sibling canvas mutators like canvas_set_gradient or canvas_set_background, though it never explicitly names an alternative.

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

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

No when-to-use guidance is offered: nothing tells the agent when to pass a preset versus explicit width/height, or whether this belongs with canvas_create_new for a new design. Usage is only implied by the tool name.

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

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

With no annotations, the description carries full behavioral burden. It does not say whether the gradient replaces the existing background, how it interacts with canvas_set_background/canvas_set_pattern, whether it is reversible, or what permissions are needed. Only the preset enumeration adds 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?

Two front-loaded sentences with the purpose stated first and parameter guidance second. Slightly redundant in re-listing the preset values that the enum already enumerates, but otherwise tight.

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?

Adequate for a mutation tool with fully documented params, but with no annotations and no output schema the description should disclose how the gradient interacts with the other canvas background tools and whether it overwrites existing content. That gap leaves an agent uncertain.

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

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

Schema coverage is 100% and each parameter already has a description plus an enum for preset, so the schema does the heavy lifting. The description restates the preset names and mentions colors/angle but adds no format or default details 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?

States a specific verb ("Applies") and resource ("gradient to the canvas background"), which scopes it distinctly from layer_set_gradient and canvas_set_background. It does not explicitly name those siblings, so an agent must infer the canvas-vs-layer distinction.

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

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

The description implies usage by explaining that you can pass a preset or custom colors/angle, but never states when to choose this over canvas_set_background, canvas_set_pattern, or layer_set_gradient. No explicit alternatives or exclusions are given.

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

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

With no annotations, the description carries the full behavioral burden. It does not say whether the pattern replaces an existing background, whether the operation is reversible (history_undo), or whether patternKey must originate from assets_list_patterns — all relevant for a mutation tool with zero annotation coverage.

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

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

A single efficient sentence with the action front-loaded and no filler. It is well-sized, though extremely sparse given the tool's role in a family of background-setting siblings.

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 low-complexity two-parameter tool with complete schema coverage and no output schema, the description is minimally adequate. It still omits the relationship to canvas_set_background/canvas_set_gradient and where pattern keys come from, which an agent would need 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 description coverage is 100%, so both parameters (bgColor hex, patternKey enum) are already documented in the schema. The description adds nothing about either parameter — no syntax hints, no note that bgColor is optional base color beneath the pattern. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource: 'Applies a patterned or textured geometric background to the canvas artboard.' An agent can tell it sets a pattern-based background. However, it does not distinguish itself from close siblings canvas_set_background or canvas_set_gradient, which all touch the same surface.

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

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

No when-to-use guidance and no alternatives named. The agent is not told when to choose a pattern over canvas_set_background or canvas_set_gradient, nor that valid pattern keys are discoverable via assets_list_patterns.

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 convey a meaningful trait by framing output as 'recommendations for fixing' rather than applying fixes, implying a non-destructive analysis operation, but it never states outright that the canvas is not modified, nor does it mention permissions, cost, or limits.

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 tight sentences with zero filler: the purpose and audit scope are front-loaded, followed by the return value. Every clause earns its place.

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

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

With no parameters, no annotations, and no output schema, the description is nearly self-sufficient: it names what is inspected and roughly what comes back. Its only gap is the missing clarification that the operation is read-only and does not itself apply any fixes.

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

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

The tool takes zero parameters, so the documented baseline of 4 applies. There is nothing parameter-level for the description to clarify or omit.

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

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

States a specific verb (audits), the exact target (the current active canvas), and enumerates the checks performed: text collisions, layer overlaps, boundary overflows. No sibling tool in the list performs an audit, so the agent can distinguish it immediately.

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

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

The phrase 'current active canvas' implies the scope and the natural use case (run it to inspect the active design), but there is no explicit when-to-use, when-not-to-use, or referral to any sibling tool such as a fix/alignment tool. Usage is implied rather than 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 are provided, so the description carries the full burden. It discloses that the asset is 'free copyright-free' stock, but says nothing about whether it network-fetches, whether it creates a new layer or replaces selection, what happens on failure, or any auth/rate-limit constraints.

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 front-loaded sentence with no filler; the resource and input modes come first. It is appropriately sized for the tool, though the trailing enumeration is slightly dense.

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

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

With no output schema and no annotations, the description is the only behavioral source, and it stops short of explaining the result (new layer?) or how scaleToWidth interacts with the fetched asset. It covers enough to identify the tool but not enough to call it confidently in edge cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's three modes (search query, image URL, asset key) roughly map onto the 'url' parameter's 'Direct image URL or search keyword' description, but the 'asset key' mode is not clearly represented in the schema, leaving a minor ambiguity rather than added clarity.

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

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

States a specific verb and resource ('Adds a ... stock image or cutout to the canvas') and enumerates three input modes. It is clear what the tool does, but does not distinguish itself from close siblings such as elements_search, assets_list_stock_pngs, or image_add.

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

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

The word 'directly' implies this places content on the canvas in one step, contrasting implicitly with searching first via elements_search and then adding. However, no explicit when-to-use/when-not or named alternative is given for the many sibling adders (image_add, sticker_add, svg_add).

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 notes the corpus size ('thousands') and that assets are copyright-free, which is useful, but says nothing about result pagination behavior, ordering, result limits, or what a call actually returns.

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

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

A single front-loaded sentence with a clear verb and no filler. The asset-type enumeration is somewhat long but earns its place by telling the agent what content is searchable.

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 3-parameter search with a fully documented schema and no output schema, the description covers what is searchable but omits return shape and pagination semantics. Adequate, though an agent must infer the result format.

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

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

Schema description coverage is 100%, so the schema already documents query, category, and page. The description confirms keyword search and category filtering but adds no format, syntax, or constraint details beyond that, 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?

States a specific verb ('Searches') and resource ('copyright-free stock photos, transparent PNG cutouts, SVG vector icons, trust badges, and backgrounds'), so an agent knows exactly what it returns. However, it does not name or differentiate itself from siblings like assets_list_stock_pngs or assets_list_stickers, so sibling routing is left to inference.

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

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

The description implies a browse-then-add workflow but never states when to use this tool versus assets_list_stock_pngs, assets_list_stickers, assets_list_patterns, or assets_list_local. No preconditions, no exclusions, no sequencing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing beyond the verb. It does not disclose whether omitted sliders are left untouched or reset, whether the change is destructive/undoable, or whether the layer must be an image layer — all critical for a mutation tool with 9 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?

A single front-loaded sentence that names the operation and scope immediately. The parenthetical enumeration of all eight sliders is somewhat redundant with the schema but is defensible as a quick capability summary.

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 9-parameter mutation tool with no annotations and no output schema, the description should at least explain partial-update behavior and side effects. It leaves the agent guessing about what happens to unset sliders and whether the change is reversible.

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%, with each slider's range documented in the schema, so the baseline is 3. The description only re-lists the same slider names already present in the schema and adds no range, default, or interaction 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?

States a specific verb ('adjusts') and resource ('color grading sliders on an image layer') and enumerates the eight affected properties, so the agent knows exactly what the tool touches. The word 'Manually' hints at a contrast with filter_apply_preset but the sibling is never named, so the differentiation is only implicit.

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?

'Manually adjusts' implies this is the hand-tuned alternative to the sibling filter_apply_preset, which is a usable usage signal. However, it never states when to choose this over applying a preset, nor any prerequisites such as the target layer needing to be an image 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 provided, the description carries the full behavioral burden and falls short: it does not say whether this is a destructive mutation, whether the preset stacks with or replaces existing filter values, whether an undo is needed, or what the response contains. The enumeration of preset names adds context about the operation's scope but not about its side effects or reversibility.

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

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

A single efficient sentence that front-loads the verb and resource. The parenthetical list of presets is useful but somewhat redundant with the schema enum, though it improves scanability.

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, no output schema, and only 50% schema coverage, the description is thin: it does not clarify side effects, reversibility, or interaction with filter_adjust_values. An agent could invoke it but lacks confidence about the resulting state of the layer.

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% (only layerId is documented as 'Image Layer ID'; presetName has an enum but no description). The description echoes the preset names via examples, which maps usefully to the enum but adds no syntax, formatting, or fallback guidance beyond what the schema already enumerates. Baseline 3 is appropriate when schema does most of the work.

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

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

States a specific verb (apply) and resource (aesthetic color grading preset) applied to an image layer, which clearly distinguishes it from siblings like filter_adjust_values (manual value adjustment) and image_crop/image_remove_bg (transformative ops). It loses a point only because it does not explicitly name a sibling to contrast with, though the enum of preset names strongly signals the intended scope.

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

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

The description implies usage — apply a preset to a layer — but offers no explicit when-to-use vs filter_adjust_values (for granular control), no prerequisites, and no note on whether applying a preset overwrites prior adjustments. Usage is inferable from the verb+resource pairing but not guided.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it doesn't say what happens if the redo stack is empty (no-op vs error), whether the redo is itself undoable, or whether it replays one change or a batch. Only the bare mutation semantics are conveyed.

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

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

A single short sentence with zero filler and the key concept front-loaded. It is efficient, though its brevity contributes to the behavioral gaps noted elsewhere rather than being a flaw of structure itself.

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

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

For a parameterless, single-action tool with no output schema, the description is minimally viable. However, the empty-stack behavior and undo interaction are exactly the details an agent needs to invoke it safely, and they are absent.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4; there is nothing for the description to disambiguate. Schema coverage is trivially 100%.

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?

Specific verb (Redoes) applied to a specific resource (the previously undone change). The word 'redo' inherently distinguishes it from its sibling history_undo, though the description never names that sibling or otherwise contrasts them explicitly.

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 versus history_undo, nor any stated precondition (e.g., that a prior undo must exist). The agent must infer usage entirely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that the move is one step back ('previous undo history state'), but says nothing about what happens if history is empty, whether the operation requires a prior edit, or whether it is reversible via redo. For a state-mutating tool with zero annotation coverage this is thin.

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

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

A single efficient sentence that front-loads the action and its effect 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 simple zero-param tool the description covers the core behavior, but with no annotations and no output schema it leaves the agent guessing about failure conditions (empty history) and the relationship to redo. Adequate but with clear gaps.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there are no argument semantics to clarify and the description correctly presents this as a no-argument action.

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

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

States a specific verb (reverts) and resource (canvas undo history state), which is clearly distinct from the sibling history_redo. It does not explicitly name redo as its counterpart, but the semantics are unambiguous enough for an agent to distinguish them.

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

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

No guidance on when to invoke this versus alternatives such as history_redo, nor any precondition (e.g., whether an undoable action must exist first). The agent must infer usage entirely from the verb.

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 supplied, so the description carries the full behavioral burden. It usefully discloses that src can be a local file path, a remote URL, or Base64, and that isBackground produces a full-bleed background rather than just a back-positioned layer. However, it says nothing about remote fetch behavior, local-file access constraints, or what happens on load failure.

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

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

Three sentences, no filler, with the core action stated first and the source-form detail immediately after. The second sentence is long but each clause adds usable information; nothing is redundant.

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 7-parameter mutation tool with no annotations and no output schema, the description covers src and isBackground well and defers the geometry parameters to the schema. It does not indicate what the call returns (e.g., a layer id) or any error/permission behavior, leaving a meaningful gap for an insert operation.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters; the baseline is 3. The description adds examples of accepted src formats and clarifies that isBackground yields a full-bleed background (vs. the schema's terse "sends layer to back"), which is modest extra value but not required for invocation.

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

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

States a specific verb and resource ("Adds an image layer to the canvas") that an agent can immediately separate from siblings like svg_add, sticker_add, shape_add, and text_add. The scope is unambiguous and front-loaded.

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

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

Gives clear usage context: it enumerates the three acceptable source forms (local path, public URL, Base64 data URL) with examples, and explains the isBackground shortcut. It never explicitly names when to prefer it over siblings such as assets_load_from_path or image_crop, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full behavioral burden and does not deliver: it never says whether the crop is destructive or reversible, whether it mutates the layer in place, or how the two modes interact (e.g. what happens if aspectRatio and cropX/cropY/cropW/cropH are supplied simultaneously). The mode-precedence ambiguity is a real behavioral risk an agent needs to know before calling.

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 front-loaded sentence with the two modes presented as a clear either/or. Every clause earns its place and there is no filler.

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

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

For a 6-parameter geometry mutation with no annotations and no output schema, the description omits critical information: precedence between the aspectRatio mode and the four crop-coordinate parameters, whether the operation is destructive, and what the layer state looks like afterward. The one-sentence description is not sufficient for an agent to call this tool 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 description coverage is 100%, so the schema already documents all six parameters, making 3 the baseline. The description only restates the aspect-ratio options already listed as examples in the schema and adds no semantics (e.g. units, whether cropX/Y are absolute or relative to the layer origin).

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

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

The description names a specific verb ('Crops') and resource ('an image layer') and enumerates the two operating modes (aspect-ratio presets vs. custom pixel coordinates). It does not distinguish itself from siblings like layer_transform or layer_align, which also manipulate layers, so it stops short of a 5.

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

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

There is no guidance on when to choose cropping versus layer_transform/layer_align, nor any statement of prerequisites such as the layer needing to be an image layer. Usage is only implied by the verb itself, which is effectively restating the purpose.

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

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

With no annotations, the description carries the full behavioral burden. It hints at the algorithm ('analyzing edges') but says nothing about whether the operation is destructive, reversible, undoable, or dependent on image content, all of which matter for a mutating layer 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?

A single tight sentence with the core action front-loaded and zero filler. It is efficient, though brevity here borders on under-specification.

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

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

For a one-parameter mutation tool with no annotations and no output schema, the description covers the action and method but omits behavioral essentials (reversibility, failure modes) and the sibling distinction. Adequate but with clear gaps.

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

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

Schema description coverage is 100% and the single layerId parameter is already documented in the schema. The description adds no additional meaning about the parameter (e.g. whether the layer must be a raster image), so the 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?

States a specific verb and resource ('background removal to an image layer') and adds method detail ('by analyzing edges'). However, it never distinguishes itself from the sibling image_remove_bg_magic, so an agent cannot tell which background-removal tool to pick without guessing.

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

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

No when-to-use guidance, no prerequisites, and no mention of image_remove_bg_magic as the alternative. The 'auto' vs 'magic' naming implies a distinction the description never resolves, leaving selection to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the algorithmic approach (sampling at click coords with tolerance/feather), which is genuinely useful, but says nothing about permissions, reversibility, what happens to the removed pixels, or which layer types are eligible.

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

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

A single sentence with no filler, front-loading the action and then the mechanism. Every clause (sampling, tolerance, feather) 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 5-param mutation tool with no annotations and no output schema, the description covers the mechanism but omits prerequisites (layer must be an image layer, required layerId), result behavior, and how it differs operationally from the auto variant. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so every parameter (x, y, feather, layerId, tolerance) is already documented in the schema with ranges and defaults. The description only restates tolerance and feather conceptually, adding no syntax or constraint detail 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?

States a specific verb and resource ('Performs Magic Wand background removal on an image layer') and names the mechanism (color sampling at click coordinates), which implicitly separates it from the sibling image_remove_bg_auto. An agent can tell what this does without opening the schema.

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

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

The description implies when this is appropriate (a Magic-Wand-style, point-sampled removal) but never states when to prefer it over image_remove_bg_auto or what preconditions exist. Usage is inferable from the mechanism, not explicit.

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

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

With no annotations, the description bears the full burden. It usefully clarifies that alignment is relative to the canvas artboard (not other layers), but omits whether the operation moves the layer, is reversible/undoable, or has side effects 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?

A single front-loaded sentence with no wasted words, appropriately sized for a simple two-parameter tool. It is terse but not padded.

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 stops short: it does not describe return behavior, undo semantics, or how the layer is identified. It leaves meaningful gaps an agent would want filled.

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

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

Schema coverage is only 50%, and layerId is documented merely as 'Layer ID' with no format hint. The description repeats the enum values already present in the schema and does not clarify the ambiguous center_h vs center_v abbreviations, so it adds little beyond the structured fields.

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 gives a clear verb+resource: 'Aligns an object to the canvas artboard', and specifies the alignment modes. It does not distinguish itself from positional siblings like layer_transform or layer_reorder, but 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?

There is no guidance on when to use this versus layer_transform, layer_reorder, or other positioning tools, and no prerequisites or context. Usage is only implied by the verb 'align'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Deletes' implies a destructive mutation, it does not state whether the action is reversible, whether it requires specific permissions, or what happens to related elements. This is a significant gap for a destructive operation.

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

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

The description is a single, front-loaded sentence with zero waste. It says exactly what the tool does and nothing more, making it 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?

For a simple tool with one fully documented parameter and no output schema, the description is minimally sufficient to know what it does. However, because there are no annotations, the description should do more to convey the destructive and potentially irreversible nature of the operation, which it fails to address.

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

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

The schema has 100% description coverage for the single parameter 'layerId' ('Layer ID to delete'), so the schema already fully documents the parameter. The description adds no additional meaning beyond what the schema provides, making the baseline of 3 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 states a specific verb ('Deletes') and resource ('a layer from the canvas'), making it easy to distinguish from sibling tools like layer_duplicate or layer_reorder. It does not explicitly name an alternative or scope boundary, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as canvas_clear or pages_delete, nor any prerequisites or conditions mentioned. The description only states what it does, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full behavioral burden. Stating that the copy lands on the canvas is useful, but it is silent on the duplicate's name, placement, selection state, whether layer properties/styles are copied, and what the call returns for chaining further edits.

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 short sentence with the action front-loaded and the outcome trailing it. No filler, though it is too terse to earn a 5 on structure.

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

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

For a one-parameter action this is minimally adequate, but with no output schema the description should say what comes back (e.g., the new layer's ID) since that determines whether the agent can act on the duplicate afterwards.

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% for the single layerId parameter, so the schema fully documents it. The description adds no format, ID-source, or constraint detail beyond the schema, which is the expected baseline for a fully documented param.

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?

Clear verb ('duplicates') plus resource ('layer') with the outcome stated (copy added to canvas). It is distinguishable from pages_duplicate by the word 'layer', though the description never acknowledges that near-identical sibling, so it falls short of a 5.

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

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

No guidance on when to duplicate versus pages_duplicate, canvas_create_new, or element_add_stock, and no prerequisites stated. Usage is only implied by the verb; the agent must infer the 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?

No annotations are provided, so the description carries the full burden. It implies mutation of the z-index stack but says nothing about permissions, whether reordering is reversible, error behavior for an invalid layerId, or the resulting state returned to the caller.

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 front-loaded sentence with no filler, though the parenthetical enum restatement is redundant with the input schema and slightly inflates the length.

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

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

For a simple two-parameter mutation with no output schema, the description covers the core action but omits failure modes, permission requirements, and confirmation of the post-reorder state. Adequate but with visible gaps.

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

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

Schema description coverage is 50% (layerId is only labeled 'Layer ID'), so the description should compensate. It does list the four action values, but this duplicates the schema enum without explaining what each one does (e.g., bring_forward = one step up), and layerId's format is never 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?

States a specific verb (reorders) and resource (layer in the visual z-index stack), and the parenthetical enumerates the four supported ordering actions. It is clearly distinguishable from siblings like layer_align or layer_transform, though it never explicitly names those alternatives.

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

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

No guidance on when to use this versus related tools (layer_align, layer_transform, studio_batch_actions), no prerequisites such as the layer needing to exist, and no note on whether it operates on one layer only. The agent must infer everything about invocation 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?

No annotations exist, so the description carries the full behavioral burden. It signals a mutation and a target constraint, but says nothing about whether an existing fill is overwritten, what happens if both 'colors' and 'preset' are supplied, or whether an undo step is created.

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 tight sentence with the action and target front-loaded. Zero 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 4-parameter mutation with no annotations, no output schema, and half its parameters undocumented, the description is too thin. The preset-vs-colors relationship and the effect on existing layer fill are the key missing pieces.

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 50% ('colors' and 'preset' are undocumented in the schema), and the description adds no meaning for 'colors', 'preset', or their interaction. Only 'layerId' is echoed back, which the schema already explains.

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

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

States a specific verb ('applies') and resource ('gradient fill') plus the target constraint ('an existing text or shape layer'). This implicitly distinguishes it from canvas_set_gradient, but it never names that sibling explicitly, so an agent must infer the scope difference.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives. The description implies the context (an existing layer must already exist) but gives no help choosing between this and canvas_set_gradient or filter_apply_preset.

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 and it falls short: it does not state that this is a mutation, whether it overwrites existing shadow values or merges them, what 'none' does, or that layerId is required. Only the preset list hints at behavior ('none' implies removal), which is minimal.

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

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

One compact sentence with the operation front-loaded, no filler. It is slightly dense by combining purpose and parameter list but each element earns its place given the schema.

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

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

For a no-annotation mutation tool with no output schema, the description should disclose mutability, overwrite semantics, and any constraints like layer type or missing-layer handling. None of these are present, leaving the agent under-informed about behavior.

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

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

Schema description coverage is 83%, so the schema already documents blur, color, offsets and enum for preset. The description adds the preset value names, which duplicates the schema enum, and restates the attribute list, adding little beyond the structured fields. 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?

Clear verb (adds/updates) plus resource (drop shadow on a layer), with the specific configurable attributes enumerated. It does not reference any sibling tool, but the domain is distinct enough from siblings like filter_apply_preset or layer_set_gradient that confusion is unlikely.

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

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

No when-to-use guidance, no prerequisites, no mention of when to prefer preset vs explicit parameters, and no pointer to alternatives such as layer_set_gradient or filter_apply_preset for other layer styling. Usage context is entirely left to inference.

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

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

With no annotations, the description carries the full behavioral burden and mostly does not. It says 'toggles,' which implies flipping state, while the schema exposes explicit boolean setters (visible, locked) — that ambiguity about flip-vs-set is left unresolved, and there is no mention of permissions, reversibility, or whether unspecified fields are preserved.

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

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

A single front-loaded sentence that lists the operations in a natural reading order with zero filler. Nothing could be removed without losing meaning.

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

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

For an unannotated mutation tool with no output schema, the description is thin. It never explains that only layerId is required and that the other three parameters act as optional partial updates, nor what happens when none of them are supplied — a meaningful gap for a state-setting 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 100%, so the baseline is 3. The description does map its three operations onto the visible, locked, and name parameters, adding modest semantic framing, but contributes no format, default, or interaction details 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?

States a specific verb+resource (layer state) and enumerates the three distinct operations it covers: visibility, lock state, and renaming. This clearly separates it from siblings like layer_reorder, layer_transform, or layer_delete, though it does not name any sibling explicitly.

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 layer_duplicate, layer_reorder, or layer_delete, and no prerequisites stated. The three operations are listed, but the agent must infer the calling context entirely.

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 disclosure burden. It conveys the read-only nature through 'Returns' and discloses return contents (IDs, positions, styles, hierarchy), which is useful. However, it says nothing about result size, ordering, or behavior on an empty canvas, so the behavioral picture is only 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?

A single front-loaded sentence that names the operation, scope, and returned fields with no filler. Every clause earns its place.

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

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

There is no output schema, so the description must describe return values, which it does at a high level (IDs, positions, styles). It stops short of indicating the structure or depth of the hierarchy an agent will receive, leaving the response shape partly unexplained.

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

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

The tool takes zero parameters, so per the baseline rule the description is not required to explain parameter meaning. The description does not add or detract here, warranting the baseline 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?

States a specific verb ('Returns') and resource ('complete hierarchical list of all objects/layers currently on the canvas') plus the fields returned. It distinguishes itself reasonably from listing siblings like pages_list and assets_list_stickers by scoping to canvas contents, though it does not explicitly name an alternative.

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

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

The phrase 'currently on the canvas' implies the read/list context and that it reflects live state, but there is no explicit when-to-use guidance, prerequisites, or named alternative. 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 carries the full behavioral burden. It implies mutation but does not state that only layerId is required (partial updates), whether provided values are absolute replacements, whether flips toggle or set state, or whether the change is undoable. For a mutating 8-parameter tool, this leaves key behavioral questions unanswered.

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 compact sentence that front-loads the verb and resource, then enumerates capabilities without padding. Efficient, though the enumeration is slightly dense with slash/comma lists.

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 8-parameter mutation tool with no annotations and no output schema, the description covers the parameter surface but omits the operational context an agent needs: partial-update semantics, absolute vs relative values, and return behavior. Adequate minimum, but with clear gaps.

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

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

Schema coverage is 88%, so the schema already documents nearly every parameter, including the blendMode enum. The description's operation list loosely maps to those parameters but adds no semantics beyond the schema (e.g., it does not clarify unit or relative-vs-absolute behavior for x/y/angle). 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 uses a specific verb ("Transforms") against a specific resource ("a layer") and enumerates the exact operations covered: move X/Y, rotate, flip, opacity, blend mode. An agent can tell what it does at a glance, though it never distinguishes itself from siblings like layer_align or layer_set_state that may also touch position, opacity, or blend mode.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives despite clear overlap with layer_align (position) and layer_set_state (opacity/blend mode). The agent must infer selection from the tool list alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a document mutation but says nothing about side effects, whether the current view is switched (that is only in the schema's switchNow), permissions required, or what the result looks like.

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 core purpose is front-loaded in the first sentence, which is good. The second sentence is largely promotional ('Ideal for...') and does not earn its place by helping an agent decide or invoke, so it dilutes the 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 6-parameter mutation tool with no annotations and no output schema, the description omits behavioral context entirely (side effects, view switching, cloning semantics). The parameter schema is complete, but the definition leaves the agent without the operational context this tool type needs.

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 all six parameters (title, width, height, bgColor, switchNow, copyCurrent) are already documented with defaults and examples. The description adds nothing beyond the schema, so the 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?

States a clear verb+resource: 'Adds a new page to the document.' This distinguishes it from siblings like pages_switch, pages_duplicate, and pages_delete by function. However, it never names those alternatives, so differentiation is inferred rather than explicit.

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

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

The second sentence ('Ideal for designing multi-page catalogs, product lookbooks...') is marketing-oriented use-case color rather than actionable when-to-use guidance. It gives no condition for choosing pages_add over canvas_create_new or pages_duplicate, and no 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the minimum-page constraint, but omits whether the deletion is reversible (a history_undo sibling exists), how errors on the last page surface, and what the response contains for a destructive mutation.

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

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

A single sentence with the core action front-loaded and the constraint in a parenthetical. No filler, no restatement of the name.

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

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

For a destructive, unannotated, no-output-schema tool the description is only partially complete: it covers the key precondition but leaves reversibility, failure behavior, and confirmation requirements unaddressed.

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% and the schema already documents the 0-based index semantics, so the description's 'by index' adds nothing beyond it. Baseline 3 is appropriate when the schema does the work.

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

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

States a specific verb (deletes) and resource (a page from the document), scoped by index. It is clearly distinguishable from siblings like pages_add, pages_switch, and pages_duplicate, though it never names an alternative explicitly.

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 parenthetical establishes a precondition (at least 1 page must remain), which implies when the call is invalid, but there is no guidance on when to delete versus duplicate, switch, or clear pages. Usage is inferred rather than 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses what content is copied and that the new page lands immediately after the source, but omits what is NOT copied, whether the new page becomes active, and what (if anything) is returned for chaining.

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 front-loaded sentence that states the action, the copied content, and the resulting position with no filler. Every clause earns its place.

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

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

For a simple one-parameter, no-output-schema tool, the description covers the essential behavior and outcome placement. It is close to complete, lacking only edge-case behavior such as the new page's active state or index of the duplicate.

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% and the single parameter's 0-based indexing and active-page default are already documented in the schema. The description adds nothing about the index, so the 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 gives a specific verb (duplicates) and resource (page) and enumerates what is carried over (text, shapes, images, styling) plus the placement of the result. This implicitly separates it from page-creation and layer-level siblings, though no sibling is named explicitly.

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

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

The description implies the use case (copy an existing page's content rather than start blank), but never says when to prefer it over pages_add or how it relates to layer_duplicate. No exclusions or prerequisites are stated, so usage is inferred rather than guided.

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

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

With no annotations, the description carries the disclosure burden. 'Returns' implies a read-only, side-effect-free operation, and the description usefully states the returned fields (titles, indices, dimensions, active status). However, it says nothing about ordering, pagination, or performance/rate characteristics.

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 front-loaded sentence with no filler; the enumerated return fields are the only elaboration and each 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 no-param, no-annotation tool with no output schema, the description compensates reasonably by naming the return fields. It falls short of fully specifying the return structure (e.g., format of dimensions, ordering of the list), so it is strong but not exhaustive.

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

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

The tool takes zero parameters, so the schema has no semantics to explain; per the baseline rule for 0-param tools, this dimension starts at 4. There is nothing parameter-related for the description to add.

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 gives a specific verb ('Returns') and resource ('the full list of pages in the current multi-page document'), then enumerates exactly what each entry contains. This clearly distinguishes it from the mutating siblings (pages_add, pages_switch, pages_duplicate, pages_delete).

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

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

Usage is implied by the nature of the operation—enumerate pages before switching, duplicating, or deleting one—but the description never states when to call it or names alternatives. It provides context but no explicit routing guidance.

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

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

With no annotations provided, the description must carry the behavioral burden. It adds useful context that the tool changes the 'active canvas view' state, which implies a state mutation that persists. However, it doesn't state whether the switch is reversible, what happens on invalid index/ID, or if it requires the page to already exist. Some behavioral value, but notable gaps for a stateless-annotated mutation.

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, well-structured sentence that front-loads the action and resource, then states the target and rationale. No filler or redundancy.

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

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

For a 2-parameter navigation tool with full schema coverage and no output schema, the description covers the core purpose adequately. However, given the absence of annotations, it should specify what happens on failure, whether the change persists, and whether pages must exist first, especially since siblings include pages_add and pages_list that imply page management workflows.

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 both parameters are already fully documented in the schema, including the 0-based indexing note and that pageId is an alternative. The description repeats that both 'page index' and 'page ID' are accepted but doesn't add format or precedence details beyond the schema. Baseline 3 is appropriate when schema fully documents parameters.

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

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

States a specific verb ('Switches') and resource ('active canvas view') plus the target ('a specific page index or page ID'), and it clarifies the downstream purpose ('so the AI agent can design on that page'). A reader can immediately distinguish it from siblings like pages_list or pages_add.

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

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

The description implies the usage context ('so the AI agent can design on that page'), which tells the agent this is a navigation prerequisite before designing on another page. But it does not explicitly say when to use index vs pageId, nor when to prefer this over alternatives. Usage is implied rather than 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 are provided, so the description carries the full burden. It usefully discloses a side effect beyond the schema by stating it 'triggers client-side download' and describes output quality ('print-ready, high-resolution'). However it omits where the file lands, whether an overwrite/conflict can occur, and any permission or rate considerations.

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 tightly constructed sentence that front-loads the core action and outcome with no wasted words. Everything stated earns its place.

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

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

With no output schema and no annotations, the description still covers the core action, variable scope, quality, and the download side effect, and all three parameters are self-documented. It is slightly thin on the destination/overwrite behavior of the triggered download, but otherwise complete for a low-complexity export 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 100%, with scale, allPages, and filename each fully documented (including DPI meanings for the scale enum). The description adds no parameter detail beyond what the schema already provides, so the baseline of 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?

States a specific verb ('Compiles') and resource ('all pages') with a clear outcome: a print-ready, high-resolution multi-page PDF plus a download trigger. It is not, however, differentiated from sibling export tools like studio_export_file or project_export_download, so an agent cannot tell from the text alone which exporter to pick.

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 parenthetical '(or active page)' implies a usage mode tied to the allPages flag, and 'print-ready' implies a use case. But there is no explicit when-to-use, when-not-to-use, or naming of the alternative export siblings, so the guidance 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 supplied, so the description carries full behavioral burden. It does disclose one meaningful trait – the download is triggered in the browser rather than written server-side – but says nothing about side effects on project state, permissions, or whether the design must be saved first.

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 front-loaded sentence with the action, target, and output options; no filler, no repetition of the title.

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?

Four parameters with sensible defaults, no output schema and no nested objects, so the description is the only guide. It covers the core intent but leaves the interaction between format and the other parameters, plus any project-state preconditions, unaddressed.

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%: quality and filename are documented in the schema, while scale and format are bare enums. The description enumerates the formats but does not explain that quality applies only to JPEG, what scale means, or whether filename should omit the extension as the schema states.

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?

Specific verb (Triggers...download) plus resource (current design) and enumerated output formats, so the agent knows exactly what it produces. It does not differentiate itself from the sibling studio_export_file, which plausibly overlaps, so it stops short of a 5.

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

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

No statement of when to prefer this over studio_export_file or pdf_export_catalog, no prerequisites, no note that it requires an open project in a browser context. The agent must infer the trigger condition entirely.

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 full behavioral burden. It states the persistence locations (local storage / cloud session) but does not disclose whether it overwrites existing state, requires authentication, has asynchronous behavior, or what happens on failure.

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

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

A single front-loaded sentence with no wasted words. The purpose and destination are conveyed 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?

For a simple zero-parameter save tool with no annotations or output schema, the description gives the basic purpose but omits usage context and behavioral details (e.g., local vs. cloud priority, side effects). It is minimally adequate but leaves clear gaps.

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

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

The tool has zero parameters, so the schema is complete by default. The description does not need to describe parameters, and per the scoring rule for 0 params the baseline 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?

States a specific verb 'saves' and resource 'current design project state' with persistence targets. It is clear what the tool does, though it does not explicitly differentiate itself from sibling tools like project_export_download or history_undo.

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

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

Provides no guidance on when to use this tool versus alternatives, no prerequisites, and no indication of expected conditions for saving. The agent is left to infer usage entirely.

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 usefully discloses the side effect that the export filename changes, but omits whether the rename persists automatically, whether project_save_local is required, and whether it is undoable. Some behavioral value, but significant gaps remain.

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 front-loaded sentence with zero waste. The effect of the operation is stated immediately with no filler.

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

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

For a simple single-parameter setter with no output schema and no annotations, the description covers the visible effect adequately but leaves open whether the change is persisted and how it relates to save/undo tools. Complete enough to invoke, not complete enough to predict state.

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% and the single 'title' parameter is already documented with an example in the schema. The description adds the fact that it becomes the navbar/export name, which is marginal value beyond the structured field. Baseline 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?

States a specific verb ('Renames') and resource ('active project title'), and even identifies the visible effects (top navbar, export filename). It does not explicitly distinguish itself from siblings, but no sibling competes for the same rename-title role, so an agent can identify it correctly.

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

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

There is no guidance on when to use this tool versus related ones (e.g., project_save_local, history_undo). Usage is only implied by the phrase 'Renames the active project title'; no prerequisites, exclusions, or alternatives are 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 are provided, so the description carries the full burden. It discloses supported styling features (fills, strokes, corner radius, opacity), but omits the coordinate/placement model, whether the new shape becomes selected or active, undo behavior, and what the call returns.

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

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

A single front-loaded sentence: verb and resource first, then the shape-type enumeration and supported style features. Nothing is wasted.

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 10-parameter creation tool with no annotations and no output schema, the description covers purpose and style options but says nothing about placement semantics or the returned shape identifier, which matters for subsequent shape_update_style calls. Adequate but with a clear gap.

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

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

Schema description coverage is 90%, so the schema already documents positions, dimensions, colors, stroke, and corner radius. The description merely restates that fills, strokes, corner radius, and opacity are supported, adding no format or default information 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?

States a specific verb (Adds) and resource (geometric shape to the canvas) and enumerates the exact supported shape types, which cleanly separates it from sibling inserters like text_add, image_add, svg_add, and sticker_add.

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

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

No when-to-use guidance and no alternatives named, despite several overlapping siblings (svg_add, sticker_add, element_add_stock, image_add). The description only describes capability, leaving the agent to infer selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the update is partial or full, whether unspecified properties are reset, what permissions or preconditions are required, whether the change is reversible, or what happens if the layer is not a shape layer.

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 that states the action and affected properties with no wasted words or unnecessary preamble.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description is incomplete. It omits partial-update semantics, error behavior, permission requirements, and return behavior, leaving the agent with little beyond the schema to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description lists the modifiable style categories, but adds no syntax, defaults, or constraints beyond what the schema provides (for example, opacity range is only in the schema).

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

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

The description states a specific verb ('Modifies') and resource ('shape layer'), and enumerates the style properties affected (fill, stroke, corner radius, opacity), which distinguishes it from sibling tools like shape_add and text_update_style. However, it does not explicitly name any sibling alternative or clarify scope beyond 'existing layer'.

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

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

The description implies usage by saying 'existing shape layer,' suggesting the tool is for already-created layers, but it provides no explicit when-to-use guidance, no when-not-to-use guidance, and no alternatives for related tasks such as changing text style or adding a new shape.

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 behavioral burden. It implies a canvas mutation but says nothing about whether the addition is undoable, what happens on an invalid key, whether coordinates are required, or what the call returns.

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

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

Two short sentences with zero padding, and the alias relationship is front-loaded. Every word earns its place.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description omits failure modes, undo behavior, and return shape. Naming it an alias of svg_add without summarizing that tool's contract leaves the agent to infer too much.

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 x, y, key, and scale are already documented in the schema, including key examples. The description adds no parameter syntax or format detail beyond that, so the baseline of 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?

States a specific verb and resource ('Adds a sticker or badge vector element to the canvas') and discloses the alias relationship to svg_add, which is genuinely useful routing info. It stops short of differentiating itself from the other asset-insertion siblings like element_add_stock or image_add.

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 'alias for svg_add' note implies it is interchangeable with that tool, which is weak but real usage guidance. It never states when to prefer sticker_add over svg_add, or when to reach for assets_list_stickers first to discover valid keys.

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 usefully discloses sequential execution order and that it returns a screenshot plus layer state, but omits critical batch semantics: what happens on partial failure (abort vs continue), atomicity, and any auth/rate constraints.

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 front-loaded sentence that packs purpose and return value with no wasted words. Efficient, though it crams two ideas (execution and return) without much room for nuance.

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, so the description correctly explains the return (screenshot + layer state). However, for a batch-of-actions tool with high complexity and zero annotations, the absence of failure/partial-success semantics leaves a meaningful gap.

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

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

Schema description coverage is 100%, so the schema already documents the 'actions' array and the 'action'/'params' fields. The description adds nothing about the parameter beyond restating that multiple actions are executed in order, which the schema already states.

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

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

States a specific verb and resource: executing a batch of canvas actions sequentially in one round-trip. It implicitly distinguishes itself from single-action siblings (text_add, shape_add) by being the batched path, though it never names them explicitly.

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

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

The phrase 'for rapid design creation' hints at when to reach for this tool, but there is no explicit when-to-use/when-not guidance or named alternative. The agent must infer that this replaces repeated individual canvas calls.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the two conditions being checked and the follow-up action (instructing the agent to open the URL), which is genuine behavioral context, but it says nothing about the return values or error 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?

Two tight sentences with no waste. The core check is front-loaded and the remediation follows immediately, so 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?

Zero parameters and no output schema, so the description is the only source of truth. It adequately explains what is checked and the remediation step, but omits any indication of the result format (e.g., connected vs. not) that an agent would want before branching on the outcome.

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

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

The tool takes zero parameters, so the schema provides nothing to document and the baseline of 4 applies. There is no parameter syntax or meaning that the description needs to compensate for.

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

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

States a specific verb+resource: checking whether Tuval Studio is open and connected to the WebSocket bridge, which is precise about what is being checked. It does not explicitly differentiate itself from siblings like studio_get_view or design_audit_layout, but 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?

It provides a conditional remediation directive (open the editor URL if not connected), which implies a pre-flight/connection-verification usage. However, there is no explicit guidance on when to call this versus alternatives, nor any stated prerequisites or when-not-to-use 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses formats and scale multipliers but says nothing about whether an existing file is overwritten, whether the target directory must exist, permission requirements, or failure behavior for a tool that writes to disk.

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 front-loaded sentence that leads with the action and target, then the format and scaling options. Efficient with no filler, though it is slightly dense.

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 and no annotations, so the description is the only behavioral source. It covers formats and scaling but omits the quality parameter's effect and, more importantly, what the tool returns (e.g. written path or status) and overwrite/error behavior for a disk-writing 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 50%, with scale and format self-documenting via enums and quality/outputPath documented inline. The description adds genuine meaning beyond the raw enum by labeling scale values (1x, 2x Retina, 3x Print 300DPI, 4x Ultra HD), clarifying the resolution intent.

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

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

The description states a specific verb and resource ('Exports the current graphic to a local image file on the host machine') and enumerates supported formats. It is clear but does not explicitly distinguish itself from the closely related sibling project_export_download (local file vs download), leaving the agent to infer the boundary.

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

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

There is no when-to-use guidance and no named alternative. The agent is not told when to prefer studio_export_file over project_export_download or pdf_export_catalog, which are the obvious overlapping siblings.

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

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

With no annotations, the description carries the full burden. It does disclose what is captured (live canvas plus layer hierarchy) and the return format (image), which is useful, but says nothing about whether the operation mutates state, latency/rate limits, or whether it is safe to call repeatedly. Adequate but thin for an unannotated tool.

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

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

Two tight sentences with zero filler; the core action is front-loaded and the return value follows immediately. Nothing could be cut without losing 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?

For a one-parameter capture tool with no output schema, the description tells the agent what comes back (an image) and what it depicts, which is the essential missing piece. It stops short of noting side-effect safety or how scale relates to output fidelity, but no critical invocation detail is absent.

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% and the single 'scale' parameter is documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond the schema — it never explains how scale affects the capture or the image resolution.

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 gives a specific verb ('captures') and resource ('current live canvas graphic and layer hierarchy'), plus the return type (an image). It is clearly distinguishable from export-oriented siblings like studio_export_file by framing the output as a visual for AI critique, though it never names a sibling explicitly.

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

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

The phrase 'for visual inspection and critique by vision AI models' implies the intended use case (design review / visual QA), but there is no explicit when-to-use vs when-not, and no guidance on choosing this over studio_export_file or design_audit_layout.

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 behavioral burden. It implies a canvas mutation but says nothing about what happens when both 'key' and 'svg' are supplied, when neither is supplied (all 7 params are optional), or about layering/placement 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?

Two sentences, front-loaded with the action and resource before the key enumeration. The key list is lengthy but earns its place by supplying values absent from the schema.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description covers the input dual-mode but omits mutual exclusivity rules, defaults behavior, and what adding actually does to the canvas. Adequate but with clear gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by enumerating 11 valid built-in key values, compensating for the fact that the 'key' parameter has no enum in the schema. It still leaves the key/svg mutual exclusivity implicit.

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

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

States a specific verb and resource (adds an SVG vector graphic/sticker/badge to the canvas), which is clear. It partially overlaps with the sibling sticker_add by calling out 'sticker' as a target, but does not explicitly differentiate itself from that sibling, so it doesn't reach a 5.

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

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

There is no guidance on when to use svg_add versus the closely related sticker_add, shape_add, image_add, or element_add_stock siblings. The reader can infer the SVG-specific context, but no conditions or alternatives are named.

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

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

No annotations are provided, so the description carries the full burden. It implies a non-destructive read ('Lists all'), but says nothing about what is returned (IDs, names, previews), whether the result feeds canvas_load_template, or any pagination/limits. That is a meaningful gap for a discovery tool with zero structured behavioral coverage.

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 front-loaded sentence with the verb first. The 12-item style enumeration consumes most of the sentence and is more inventory than selection guidance, but it stays within one sentence and does convey scope.

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

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

For a zero-parameter, no-output-schema listing tool the description is close to adequate, but it omits the key connective detail: what the listed items look like and how they relate to canvas_load_template. The agent knows what it gets, not what to do with it.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate and the baseline is 4. No parameter-level claims are made or needed.

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

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

States a specific verb (Lists) and resource (pre-designed templates) plus the scope of coverage (all professional design styles). It is clear what the tool returns, though it never explicitly distinguishes itself from the sibling canvas_load_template, which consumes the same template set.

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 contains no when-to-use statement, no prerequisites, and no mention of the obvious alternative canvas_load_template. The browse-then-load workflow is only inferable from the tool name, not from the description text.

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

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

No annotations are provided, so the description carries the full burden. It says the tool 'adds' a layer, implying mutation, but does not disclose whether the new layer is selectable, how it stacks relative to existing layers, whether it can be undone via history_undo, or what happens when x/y are omitted beyond the schema's 'center by default' note.

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 front-loaded sentence with the action first. The parenthetical font enumeration is somewhat expendable since the schema already documents fontFamily, but it does not bloat the definition badly.

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

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

With 11 parameters, no annotations, and no output schema, the description is thin for a creation tool. It omits behavior on success/failure, interaction with the active canvas/page, and how the created layer relates to layer_align, layer_reorder, or history_undo.

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 82%, above the threshold where the schema already documents parameters well. The description only echoes font family examples that fontFamily already lists, adding a marginally wider set of font names but no new semantic detail.

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

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

States a specific verb and resource: 'Adds a typography text layer to the canvas.' This clearly separates it from siblings like text_update_style (modify existing) and shape_add (different element type), though it never names those siblings explicitly.

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

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

No when-to-use or when-not-to-use guidance. An agent must infer that this creates a new layer versus text_update_style, which restyles an existing one, and there is no mention of prerequisites such as needing an active canvas or page.

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

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

No annotations are provided, so the description carries the full burden. It implies mutation of an existing layer but does not say whether omitted properties are preserved, what happens if layerId is not a text layer, or whether the change is undoable — significant gaps for a mutation tool with zero annotation coverage.

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

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

One tight sentence with the addressing key front-loaded and zero filler. It is arguably too terse for a nine-parameter mutation tool, but there is no waste.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description omits partial-update semantics, error conditions, and undo behavior. It is not adequate to call this tool confidently beyond the happy path.

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 89%, so the schema already documents all nine properties with units and allowed values. The description only names layerId, adding nothing beyond the schema; the baseline of 3 applies when the schema does the heavy lifting.

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

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

States a specific verb ('Updates') and resource ('typography properties of an existing text layer'), with the addressing key (layerId) called out. An agent can distinguish it from text_add (creates) and shape_update_style (different resource), though the description never explicitly names those 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?

No guidance on when to use this versus text_add (for new text) or shape_update_style. The phrase 'existing text layer' implies a prerequisite but no alternatives, exclusions, or context are stated.

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