pedit

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 non-destructive, layer-scoped nature of the operation, but omits whether it targets an active project, what it returns, or any ordering/interaction constraints with the layers above it.

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

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

Three tight sentences with the core behavior front-loaded and no filler. Dense but readable, though the second sentence is slightly terse.

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

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

For a five-parameter, nested-object tool with no annotations, no output schema, and 0% schema coverage, the description covers the essential filter semantics but leaves project/name params and the return behavior undocumented. 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 0%, so the description must compensate and it partially does: it clarifies the relationship between 'type'+'params' and the 'effects' chain structure. It leaves 'name' and 'project' entirely unexplained, so it only covers half the surface.

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 concrete resource (an adjustment layer) and its defining behavior: filters that affect everything below it. The add_ prefix supplies the verb. It distinguishes the tool from siblings like add_effect by scope, though it doesn't name them directly.

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

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

It explains the two usage modes (single 'type + params' or a chained 'effects' array) and points to list_effects for discovery, which is helpful. However, it never says when to choose this over add_effect or a fill/effect tool, leaving the sibling-routing decision implicit.

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 disclose one real behavioral trait — filters render before the mask and styles after — but says nothing about required permissions, whether duplicates are allowed, what index controls, or what the call returns. For an unannotated mutation tool this is a substantial 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 no filler, and the core operation is front-loaded. The trailing parenthetical is compressed to the point of ambiguity ('filters before the mask') but it costs little space.

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?

Five parameters, 0% schema coverage, a nested object, no output schema, and no annotations — this is exactly the case where the description should be doing more. The ordering note is the only substantial contribution; effect type values, param contents, and post-mutation state are all 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 0% across five parameters, including a free-form nested 'params' object, so the description must compensate and largely does not. It hints that 'type' selects between filter and style categories but gives no enumerable values, no layer identifier format, no meaning for 'index' or 'project'.

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

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

The description states the resource (an effect on one layer) and distinguishes two kinds of effect (filters vs. styles with examples shadow/stroke/glow), but never states the verb 'add' explicitly and gives no sibling differentiation from update_effect, list_effects, or apply_look. An agent can infer intent, but the boundary against neighboring effect tools is not drawn.

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 statement of when to use this versus update_effect/remove_effect/move_effect or apply_look, nor any prerequisite (does a project need to be open? must the layer exist?). The only guidance is the ordering parenthetical, which is about rendering behavior, not tool selection.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose real geometry semantics (angle 90 = left->right, 180 = top->bottom; cx/cy as fractions; 0-based stacking via index). It is silent on whether this creates a new layer, how it interacts with the existing canvas content, and any permission or project requirements, which is a notable gap for a mutation tool.

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

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

Two tight sentences, front-loaded with the scope ('Full-canvas fill') and packed with notation instead of prose. It wastes no words, though the parenthetical angle/center details could be slightly clearer in ordering.

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 creator tool with no annotations and no output schema, the description is thin: it never says a new layer is created, what the return is, how name/project behave, or how index interacts with existing layers beyond the background hint. An agent could call it but would be guessing on several parameters.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate and only partially does: it explains angle, cx, cy, index, and implies kind via the fill-type list. color, color2, name, and project receive no explanation at all, and 'kind' is never explicitly named as the selector.

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 concrete verb and resource ('Full-canvas fill') and enumerates the fill variants it supports (solid, linear gradient, radial), so an agent knows what the tool produces. It does not, however, differentiate itself from the sibling set_fill, so the boundary between creating a fill versus modifying one is left 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?

There is a weak usage hint ('index=0 puts it at the bottom (a background)'), which tells the agent when to use a low index, but there is no guidance on when to choose add_fill over set_fill or add_shape with a fill. No prerequisites 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 burden, and it does disclose real behavioral traits: fit defaults to contain, fit is ignored when scale is given, missing x/y means centered, and above inserts directly above a named layer. However, it does not state whether this creates a new layer, permissions, 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?

Front-loaded purpose followed by dense parameter notes; nearly every clause carries information. No filler, though the parameter notes are somewhat terse shorthand.

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 covers source, positioning, fit/scale, and stacking, which is meaningful. Gaps remain around name, project, and layer-creation semantics, so it is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains path/asset sources, the fit enum values, scale overriding fit, x/y centering, and above. It still leaves name, project, and the interaction between x/y and scale undiscussed, so coverage is partial rather than complete.

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 from a file path or imported asset. It is reasonably distinguishable from sibling add_* tools (add_text, add_shape, add_fill) since 'image' is explicit, though it does not name them. Clear and specific.

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

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

The description gives parameter-conditional behavior (centering without x/y, above=<layer>) but no guidance on when to use this tool versus alternatives, nor when to prefer path over asset. 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 of behavioral disclosure, and it supplies none: it does not say which layer/selection receives the shape, whether a project must be open, whether the operation is undoable, or how shapes are named. It only offers input-format trivia (kind values, color hex), which belongs to parameter semantics, not 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 dense, front-loaded sentences with no filler; the kind enumeration and color-format note are both load-bearing. It is arguably too compressed for a 12-parameter tool, but nothing present 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 12-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, this is far short of sufficient. Critical gaps remain around defaults/optionality, the project parameter's role, stroke versus fill interaction, and what happens after the call - an agent would likely have to guess or trial-and-error.

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

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

Schema description coverage is 0%, so the description must compensate for all 12 parameters. It does add real meaning for kind (rect/ellipse/line/polygon), radius (rounded corners), points (relative to x,y), and color format (#rrggbbaa for transparency) - but h, w, x, y, name, project, stroke, and stroke_width remain entirely undocumented in both places.

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

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

The description names the resource ('vector shape') and enumerates the supported kinds, but never states the action verb - it reads as a reference note on shapes rather than 'adds a shape to the project.' It also does not distinguish this tool from the sibling set_shape, so an agent cannot tell create-from-scratch apart from modify-existing without opening both schemas.

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

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

There is no when-to-use guidance and no mention of alternatives, despite siblings add_text, add_image, and set_shape occupying adjacent territory. The agent is left to infer that this is the tool for drawing new vector primitives.

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 font choices, line-wrapping behavior for max_width, and centered placement when x/y are omitted, but omits whether it always creates a new layer, how the layer is named, or any side effects/return value.

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?

Very brief and front-loaded, with the core resource statement first and parameter hints compact. The fragment 'Text layer.' is minimal but not wasteful; the font list earns its length by enumerating options.

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 15-parameter creation tool with no annotations, no output schema, and zero schema descriptions, the description is far too incomplete. It covers only font, wrapping, and centering, leaving most styling and project/name parameters and lifecycle behavior 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?

Schema description coverage is 0% for 15 parameters, so the description must compensate. It explains font values, max_width wrapping, and x/y centering, but leaves bold, size, color, align, italic, line_spacing, stroke_width, stroke_color, name, and project entirely undocumented.

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

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

The description names the resource ('Text layer') and, combined with the add_text name, makes clear this creates a text layer rather than modifying one. It does not explicitly distinguish from set_text or add_shape, so sibling differentiation is absent.

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 behavioral cues ('max_width>0 wraps lines', 'Without x/y it is centered') and a follow-up step ('then align_layer to place it'), which implies usage but never states when to choose add_text over set_text or other add_* tools. Context is implied rather than explicit.

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

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

With no annotations, the description carries more burden. It usefully discloses that API keys are never accepted here and that default=true is consumed by backend='auto', but it omits side effects, persistence, permissions, and what a no-service 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?

The description is compact and front-loads the core resource and operations. The parenthetical service/task lists are dense but functional, and the API key caveat 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 configuration tool with no annotations, no output schema, and 0% schema description coverage, the description is only moderately complete. It covers parameters and some auth behavior but leaves return shape, persistence, and side effects 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?

Schema description coverage is 0%, so the description must compensate. It names all four parameters in context, gives the nested models shape as {task: model}, explains default semantics, and lists candidate service names, adding substantial meaning beyond the bare schema.

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

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

The description clearly identifies the resource as online AI services and explains the two modes: listing readiness/tasks/models, and setting a service's models, url, or default. It does not explicitly distinguish itself from sibling tools like ai_status or generate_image, 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?

The description explains how to use the service parameter (set models/url/default) but gives no guidance on when to call this tool versus siblings such as ai_status or generate_image. There are no exclusions or alternative-routing instructions.

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 itself. It implies a read-only status query (no side effects are suggested), but never states whether it probes services live, whether it can be slow or require network/key configuration, or that results may be cached or stale.

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 answer ('What AI is available here') and then lists the categories. Dense but every clause adds a distinct piece of information about the returned content.

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

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

With no output schema and no annotations, the description effectively documents the return value by enumerating the categories reported, including the 'online.ready: service -> tasks' shape. It is adequate for a simple read-only status tool, though the exact result format and meaning of 'the default one' remain slightly vague.

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 (empty object schema), so there is nothing for the description to clarify beyond what the schema shows. Baseline 4 for a parameterless tool.

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 clearly that the tool reports which AI capabilities are available (background removal, inpaint backend, ComfyUI, online services, default), which is a specific information resource. It does not, however, distinguish itself from the similarly-named sibling ai_services, so an agent may hesitate between the two.

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

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

The description only enumerates what the tool returns; it gives no when-to-use guidance, no prerequisites, and no comparison to the closely related ai_services or comfy_settings siblings. An agent must infer that this is a discovery/pre-flight call.

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 implies a mutation of the layer transform but says nothing about permissions, undo behavior, whether it errors on a missing layer/project, or what happens to margin when h/v are null.

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 dense sentence with the core action front-loaded followed by the enum shorthand and the null rule. Efficient, though the compressed notation is slightly cryptic for a reader unfamiliar with the tool.

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

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

For a mutation tool with no annotations, no output schema, and five parameters at 0% schema coverage, the description is too thin. It omits how the target layer is identified, the role of project, and any failure or side-effect 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 coverage is 0% and there are no enums, so the description adds real value by enumerating h (left/center/right), v (top/middle/bottom) and explaining margin units (px) plus the null semantics. However, the required `layer` parameter and `project` parameter are never mentioned, leaving two of five parameters undocumented.

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

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

States a specific verb and target (align a layer to the canvas), which is distinct from transform/move siblings like set_transform or move_layer. It is clear what the operation does, though it never explicitly contrasts itself with 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?

There is no guidance on when to align versus using set_transform or move_layer for precise positioning, nor any stated preconditions (e.g. an open project or a selected layer). Alignment intent is only implied by the name and phrasing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only, non-mutating analysis operation (it returns numbers about existing state), which is a reasonable inference, and notes it can operate on a layer or box sub-region. But it doesn't state whether it requires an open project, whether the image must be loaded, or how results are returned. Adequate but incomplete for a zero-annotation 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 dense sentence that front-loads the resource ('Numbers about the image') followed by the measurable outputs and a usage cue ('Measure before correcting'). No wasted words, though the opening phrase is a bit informal for a tool description.

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

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

For a three-parameter tool with 0% schema coverage and no annotations, the description leaves too much unspecified: what the 'project' parameter means, what format 'box' takes, whether the output is structured metrics or a report, and what 'layer' refers to (name, id, index). The output schema is absent, so the description should at minimum characterize return values, which it only partly does by listing metric names.

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

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

Schema coverage is 0% — none of the three parameters (box, layer, project) are described in the schema. The description mentions 'one layer, or a box' which hints at two of the three params but adds no format, type, or default information, and never mentions 'project' at all. With zero schema coverage, the description should compensate more thoroughly.

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 capability: returning measurements (brightness, contrast, clipped shadows/highlights, saturation, color cast, sharpness, dominant colors) about an image, layer, or box. It's distinct from sibling tools like describe_image (presumably descriptive text) and auto_enhance (which would apply corrections). However, it describes categories of output rather than naming the action cleanly — 'Numbers about the image' is informal.

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 closing phrase 'Measure before correcting' gives clear usage guidance — use this diagnostic tool prior to enhancement/correction operations like auto_enhance or match_color. It doesn't name those alternatives explicitly, but the sequencing guidance is actionable and distinguishes it from mutation tools among siblings.

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

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

No annotations are provided, so the description carries the full behavior burden. It discloses the two application modes (layer vs adjustment layer), which is meaningful, but says nothing about permissions, whether the look is destructive, or what the default does to existing layers beyond 'on top'.

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, front-loaded with the verb and resource, with the two modes clearly indicated. 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 3-param mutation tool with no annotations, no output schema, and 0% schema coverage, the description should explain parameter roles and whether the operation is destructive. Currently it leaves the agent to infer how 'layer' and 'project' behave.

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

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

Schema description coverage is 0% with 3 params and no descriptions. The description does not explain what 'name', 'layer', or 'project' refer to, that 'name' is required, or that 'layer' selects one-layer mode and its absence triggers the adjustment-layer default. This is a real gap for an apply operation.

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+resource: 'Apply a look' with two placement behaviors (adjustment layer on top, or effects on a single layer). This distinguishes it from sibling 'list_looks' and the add_*/set_* edit tools, though it doesn't explicitly name siblings.

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

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

The description implies when to use each mode (default top-level vs per-layer), giving some implicit guidance. However, no explicit when-to-use/when-not and no reference to alternatives like applying effects manually.

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 filters are 'editable' and can be applied as an adjustment layer or effects, which is useful behavioral context, but says nothing about whether changes are reversible, whether existing adjustments are overwritten, permissions, or the return format. For a mutation tool with zero annotations, that leaves significant gaps.

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

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

Two compact sentences, front-loaded with the operations performed. The parenthetical about adjustment layers is a bit dense but not wasteful.

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-annotation, zero-schema-coverage mutation tool with no output schema, the definition omits parameter meaning, reversibility, and interaction with siblings. What is present is true but too thin to call the tool correctly.

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

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

Schema description coverage is 0% for all three parameters. The description never explains 'layer', 'project', or the numeric 'strength' (scale, direction, 0-1 vs 0-100?). With fully undocumented parameters, the description must compensate and does not.

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 the operations (levels, white balance, vibrance, contrast) with a verb 'measure and correct', so the resource is clear. But it does not distinguish itself from nearby siblings like apply_look, match_color, or analyze_image, and the name 'auto_enhance' alone doesn't map cleanly to the listed corrections.

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 indication of when to prefer this over apply_look or match_color. The phrase about 'normal, editable filters' hints at role but offers no selection criteria or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It clearly discloses key behavior: all operations are all-or-nothing, they count as one undo step, and look=true returns a preview, but it omits details such as permission requirements, rate limits, or error handling beyond the all-or-nothing guarantee.

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

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

The description is extremely concise and front-loaded, stating the core atomic-batch behavior first and then adding the preview detail. Every sentence contributes directly to understanding or using the tool.

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

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

For a batch tool with nested calls, no output schema, no annotations, and 0% schema description coverage, the description covers the main atomicity and format concerns. It still leaves gaps around the project parameter, allowed nested tools, and what is returned when look is false.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the required ops format with an example and clarifies that look=true returns the preview, but it does not mention the project parameter at all.

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

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

The description clearly states that this tool batches many edits into one call with one undo step, and provides the expected ops format. It distinguishes itself from individual edit tools, though it does not explicitly name or contrast with sibling alternatives.

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

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

It implies the tool should be used when multiple edits need to be atomic and undone together, which is useful guidance. However, it does not explicitly state when not to use it or name any alternative tools for single edits or sequential operations.

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

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

No annotations exist, so the description carries the full disclosure burden. It says the editor is stopped but says nothing about whether unsaved project state is discarded, whether it errors when no editor is open, or what happens to running background services referenced by siblings such as ai_status — significant gaps for a tool that terminates a UI session holding in-progress design work.

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 action and the object are both in the first few 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 trivial zero-parameter teardown tool with no output schema, the definition identifies the exact resource being closed and its origin. The only missing piece is the side effect on unsaved editor state, which the absence of annotations leaves undisclosed.

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 nothing to document and the description needs no parameter explanation; the baseline of 4 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 ('Stop') and resource ('the web editor'), and explicitly scopes it to the editor instance created by open_ui, which cleanly distinguishes it from every sibling except its counterpart.

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 reference to 'started with open_ui' implies the prerequisite pairing and the context in which the tool applies, but there is no explicit when-to-use statement, no exclusions, and no note about re-opening or state loss.

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 dual read/write nature via the bare-call returning current settings, implying that supplying args mutates configuration. It omits persistence semantics, whether changes take effect immediately, error behavior if the URL is unreachable, and any auth requirements.

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 the primary purpose front-loaded and the edge-case behavior trailing. No filler, though the extreme brevity contributes to the coverage gaps noted elsewhere rather than being purely a strength.

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?

A five-parameter configuration tool with no annotations, no output schema, and 0% schema description coverage needs a much richer description than one sentence. Missing are what the call returns when args are supplied, whether the URL is required for any operation, and units/meaning for cfg and steps.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. It loosely implies the url ('point pedit at a ComfyUI') and names checkpoint/upscaler, but cfg and steps are never explained, leaving two parameters entirely undocumented anywhere.

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 identifies the resource (ComfyUI connection plus its checkpoint/upscaler settings) and an implicit verb (point/choose), so the tool's domain is discernible. However, jargon like 'Point pedit at a ComfyUI' is opaque and it never states plainly that this configures the AI backend, nor distinguishes itself from siblings like ai_services or upscale.

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?

'Without args: current settings' gives one concrete usage pattern (read-only when called bare), which is a real hint. But there is no guidance on when to use this versus the other AI/config siblings, no prerequisites (e.g. must a ComfyUI be running?), and no mention of when not to call it.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits: the coordinate unit (document px) and that layers are kept whole / the operation is undoable without loss. However, it omits what happens to layer content that extends beyond the crop box, whether the crop is destructive outside undo history, and whether any project context is required.

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 filler; the core action and its scope are front-loaded before the layer/undo reassurance, which is exactly where an agent needs it.

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 mutation tool with no annotations and no output schema, the description covers units and layer preservation but leaves the geometry semantics and the project parameter undocumented. Adequate as a minimum, but not complete enough to call the tool confidently from the description alone.

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

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

Schema coverage is 0% for 5 parameters, so the description must compensate, yet it only clarifies the unit ('document px') for the box. It says nothing about the meaning of width/height (e.g. positive-only), the origin convention, or the optional 'project' parameter.

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

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

Specific verb+resource ('Crop the canvas') with a qualifying detail ('to a box (document px)'), so the operation is unambiguous. It does not name the nearby siblings resize_canvas/expand_canvas, but the distinction between cropping, resizing, and expanding is implicit in the wording.

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 mention of alternatives such as resize_canvas or expand_canvas, even though these three siblings all change canvas dimensions. The agent must infer the crop-vs-resize distinction on its own.

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 non-destructiveness ('Does not change the document') and the backend/credential requirement ('online with a key, or Ollama'), but is silent on cost, latency, rate limits, and the shape of the returned text.

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

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

Two tightly written sentences, front-loaded with the mechanism and the operations, followed immediately by the non-destructiveness guarantee. No filler, though it could be marginally clearer in routing.

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 mean the description should cover more: five parameters at 0% coverage, unclear return format for a text-generating tool, and no guidance on the backend parameter's 'auto' default. It is adequate but under-specified for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It conceptually references three params (layer, box, question) by mapping them to behaviors, but leaves backend and project completely unexplained and gives no value syntax for box/layer.

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: image-to-text via a vision model that 'describes the picture, a layer or a box, or answers question about it.' This is clear and concrete, but it does not differentiate from the many AI siblings (analyze_image, review_image, edit_image), leaving overlap unaddressed.

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 offers partial context by noting the backend can be 'online with a key, or Ollama,' and clarifies it 'does not change the document.' However, it never explains when to choose this over analyze_image or review_image, so usage selection is left to inference.

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

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

With no annotations, the description carries the full disclosure burden, and it does reveal one useful trait: the copy is placed directly above the source layer. However, it says nothing about whether the duplicate inherits the name, what happens on name collisions, or that this mutates project state.

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 key behavioral detail front-loaded and zero filler. It is efficient, though borderline too terse for a three-parameter mutation tool.

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

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

For an unannotated mutation tool with three undocumented parameters and no output schema, the agent lacks the naming rules, project scoping, and return information needed to invoke it reliably. The placement detail alone is not enough.

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

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

Schema description coverage is 0% for three parameters. The description only implies the 'layer' argument (the thing being copied) and gives no meaning for 'name' (duplicate's name?) or 'project' (target project context?). It fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Copy a layer'), which clearly separates it from siblings like move_layer, remove_layer, and rasterize_layer. It lacks any explicit sibling differentiation or scope statement, but the action itself 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 add_image, add_text, group_layers, or copying via other routes. The parenthetical only describes post-condition placement, not context for choosing the tool.

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

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

With no annotations, the description carries the full burden, and it does disclose a genuinely useful behavioral trait: the result is a NEW layer above with the same mask/place while the original stays below (non-destructive editing). It says nothing about permissions, rate limits, or what the backend parameter changes, so behavior beyond compositing is opaque.

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 tight clauses, front-loaded with the operation and its scope, then strength semantics, then the compositing result. Each sentence earns its place; only minor density in the parenthetical examples could be trimmed.

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-adjacent AI tool with no annotations and no output schema, the description covers the core workflow and non-destructive result but omits the meaning of seed/backend/project, the relationship to the inpaint sibling, and any indication of what comes back.

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

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

Schema coverage is 0%, so the description must compensate. It adds real meaning for strength ('low keeps it, high reinvents it'), box ('a box of the picture'), and layer (implied by 'redo an image layer'), but leaves seed, backend, and project wholly undocumented in both places.

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+resource ('redo an image layer... following the prompt') and anchors the genre with 'Image-to-image', which distinguishes it from text-to-image siblings like generate_image. It does not, however, explicitly contrast itself with the very similar sibling inpaint, so the boundary between the two remains for the agent to infer.

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 framing and concrete prompt examples ('make it winter', 'watercolor style'), and the scope options (layer / box / whole picture) hint at when each mode applies. There is no explicit statement of when to choose edit_image over inpaint, generate_image, or remove_background, and no 'when not to use' guidance.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one important structural side effect: the fill lands on 'a new top layer masked to them,' so the agent knows the layer stack changes. It says nothing about permissions, cost/latency of the generative path, reversibility, or failure modes.

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

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

Two tight sentences, front-loaded with the action and mechanism, then the mode switch. Parentheticals are dense but each clause carries information; 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 an 8-parameter tool with no annotations and no output schema, the description covers the core behavior and the prompt-mode decision but leaves backend/seed/project and any return-value expectations unaddressed. Adequate but with clear gaps given the complexity.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and only partly does. It explains the semantic split for prompt vs. no-prompt and implies the four side parameters, but seed, backend, and project are left entirely undocumented.

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

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

States a specific verb (expand) plus resource (canvas) and clarifies the mechanism: pixel padding on each side filled with generated content on a new masked top layer. It is distinguishable from resize_canvas and crop_canvas by implication, though it never 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?

It explains the two operating modes well ('No prompt = classic fill (fine for sky, walls, plain backgrounds); with prompt or an AI service = generative'), which is real guidance for choosing behavior. However, it gives no guidance on when to pick expand_canvas over the neighboring resize_canvas/crop_canvas tools, nor any prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the write action and that transparent=true preserves alpha (png/webp) and box exports a region, but says nothing about overwrite behavior, permission/format constraints on path, or what happens to an existing file.

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 tight sentences, front-loaded with the core action before the usage constraint and parameter notes. No filler, though the parenthetical format list is slightly peripheral.

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 file-writing tool with no annotations and no output schema, the description covers the essential action and the most consequential flags but omits return/overwrite semantics and the role of scale, quality, and project. 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?

With 0% schema description coverage across 6 params, the description must compensate but only covers transparent (alpha retention) and box (region export), plus implicitly path. It leaves scale, quality, and project completely undefined, so half the parameters have no semantics anywhere.

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 ('Write the image file') and resource (image file, with enumerated formats), which is clearly distinct from siblings like project_save or preview. It does not explicitly name a sibling it replaces, but the write-to-disk action 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?

Gives an explicit when-to-use constraint ('ONLY when the user asks for it'), which meaningfully guards against unsolicited exports. It does not name an alternative tool or describe when another export path is appropriate, 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?

No annotations are provided, so the description carries the full burden and does not deliver. It doesn't say whether the operation is destructive, whether flattened content is recoverable via undo, whether hidden layers are deleted or preserved, or whether original layers 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?

It is a single short fragment, so there is no waste, but it reads as a truncated sentence ('All visible layers into one image layer') missing a subject or verb, which hurts front-loading and clarity.

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

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

For a destructive-sounding mutation tool with no annotations, no output schema, and undocumented parameters, the description is far too thin. It omits scope, side effects, and how the single project parameter is resolved.

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

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

One parameter, 'project', with 0% schema description coverage. The description never references the project parameter or clarifies whether an active document is used by default; it neither names nor explains the one input.

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

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

States a specific action (flatten visible layers into one image layer), which distinguishes it from siblings like merge_down or rasterize_layer by noting 'visible layers'. The phrasing is terse but the verb+resource is clear.

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

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

No indication of when to use this versus merge_down, rasterize_layer, or group_layers, despite several closely related siblings. The word 'visible' implies non-visible layers are excluded but this is never stated as 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 present, so the description carries the full disclosure burden. It usefully reveals that output is added as a new layer and that generation runs either locally (ComfyUI) or via a remote service, but it omits side effects on the document, auth/key requirements for online backends, latency, cost, and failure behavior for what is clearly a mutating operation.

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

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

A single front-loaded sentence with dense parenthetical detail and no filler. Very efficient, though the parenthetical backend list is long enough that readability could suffer slightly.

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

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

With 8 parameters, 0% schema description coverage, no annotations, and no output schema, the description should do substantially more. It covers the core generation concept and two parameter families but leaves critical parameters and all behavioral/authorization context unaddressed, so it is only marginally sufficient for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real value by enumerating backend values and fit options (cover/contain) that the schema leaves as bare strings, and implies 'prompt'. But it is silent on seed, width, height, negative, and project — half of the 8 parameters remain undocumented anywhere.

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 ('Text-to-image') plus the mechanism and output placement ('placed on a new layer'). This inherently distinguishes it from siblings like add_image (imports an existing image) and edit_image/inpaint (transform existing content) without needing to name them.

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

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

Implies usage by naming backends (backend=openai, gemini, stability, openrouter, replicate) and fit modes, so an agent can infer how to select among them. However, there is no explicit when-to-use guidance, no when-not-to-use, and no routing to alternatives such as inpaint or edit_image for modifying existing content. Usage is implied, not directed.

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 resulting group's traits (own opacity, blend defaulting to pass_through, mask, effects, and that adjustments inside a non-pass-through group are scoped to the group), but omits reversibility, required permissions, and the return/result of the operation.

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

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

Two sentences, front-loaded with the action, and the second sentence adds substantive semantic detail rather than filler. No wasted words, though the behavioral sentence could be trimmed.

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?

A mutation tool with no annotations, no output schema, and 0% parameter coverage. The description explains group behavior but leaves the two non-layer parameters undocumented and gives no indication of the result or whether the operation is undoable.

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

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

Schema description coverage is 0% for 3 parameters (name, layers, project). The description only echoes the 'layers' argument and its same-level constraint; it adds nothing about what 'name' or 'project' do, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource: 'Put layers (same level) into a new group.' An agent can tell this is the grouping operation versus the sibling 'ungroup', though the description never names or contrasts that 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as 'ungroup'. The only hint is the parenthetical 'same level' constraint on the layers, which implies a usage condition but doesn't articulate one.

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

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

With no annotations, the description carries the full burden and discloses meaningful behavior: the output lands on a NEW layer with a soft mask that can be moved, faded, or deleted like any layer, plus that generative backends call ComfyUI or an online service. It omits cost/permission/connection requirements for the online services and async behavior.

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

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

Three dense sentences, front-loaded with the core action and mode-selection logic, then output behavior. Nearly every clause carries information, though the parameter notation is compact enough to be slightly terse.

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, no-output-schema tool, the description covers behavior and the most important inputs but leaves four parameters (seed, ellipse, feather, project) and any return/error semantics unexplained. Adequate but with clear gaps an agent would need to infer.

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

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

Schema description coverage is 0%, so the description must compensate and does so for box (format and px units), mask_path, points, size, prompt, and backend. However, seed, ellipse, feather, and project are left entirely undocumented in both schema and description.

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

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

States a specific verb+resource ('Remove an object / fill an area') and distinguishes itself from siblings like remove_background, edit_image, and paint_stroke by naming the two operating modes (remove vs. generative fill). An agent can tell what it 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?

Clearly routes between the two modes: 'No prompt = remove (classic fill)' vs. 'With prompt = generative fill', and names concrete backends (openai, gemini, stability). It lacks explicit comparison to sibling tools like edit_image or generate_image, so it stops short of full when/when-not 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 must carry the full behavioral burden. It usefully discloses the two output shapes (brief one-liners vs full parameters), which implies a read-only lookup, but says nothing about permissions, whether the catalogue is scoped to the current project, 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 clipped sentences, zero waste, and the mode split is front-loaded. Every clause carries information an agent needs to call the tool correctly.

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 returns - and it does for both modes. For a one-optional-parameter listing tool this is nearly sufficient; only the lack of sibling/scope context keeps it from being complete.

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

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

Schema coverage is 0% for the single optional name parameter, so the description must compensate - and it does, precisely: omitting name lists all effects with one-liners, supplying it returns that effect's parameters. The semantic difference between the two modes is fully explained.

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?

"Effect catalogue" names the resource and the two modes make clear that it lists effects and can drill into one. It is a noun phrase rather than a verb+resource statement, and it never distinguishes itself from the closely related sibling list_looks.

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

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

The description explains the two invocation modes (with/without name) which is genuine conditional guidance. It stops short of any tool-selection guidance, e.g. when to use list_effects vs list_looks or add_effect/update_effect.

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 and discloses almost nothing: it does not say whether the call is read-only, what it returns, how many looks exist, or whether IDs are needed downstream. Only the weak implication that it feeds apply_look adds any behavioral context.

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

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

Six words, front-loaded, zero filler or repetition of the tool name. It is efficiently sized, though the terseness borders on under-specification rather than pure conciseness.

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

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

With no output schema and no annotations, the description should at least convey the return shape (e.g. that it yields identifiers consumable by apply_look). That critical link between the two tools is left entirely implicit for a tool whose only purpose is to supply that input.

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 zero parameters, so the baseline is 4; there is nothing the description needs to disambiguate. It correctly mentions no args.

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

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

The description names the resource (ready-made looks) and links it to the sibling apply_look, which is the main thing an agent needs to place it. But it is a noun phrase with no explicit verb, so the 'list' action is only inferable from the tool name.

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?

Mentioning apply_look implies this is a prerequisite/enumeration step before applying a look, but it never states when to call it, when not to, or what to do with the results. No explicit sequencing 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 disclose meaningful traits: mode semantics, that points are in document pixels, that it works on any mask, and the side effect that a mask-less layer silently gets a new paint mask. It omits whether existing mask content is replaced or blended, how opacity/hardness affect the result, and any auth/undo 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?

Two dense sentences with the core operation front-loaded, followed by scope and the auto-mask side effect. No filler; every clause carries 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?

Seven parameters, none documented in the schema and no annotations or output schema, so the description is the only source. It covers the two required parameters and mode, but leaves five optional brush/targeting parameters undocumented, which is thin for a 7-parameter paint tool.

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

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

Schema description coverage is 0%, so the description must compensate. It documents two of seven parameters well (mode as hide/reveal, points as [[x,y],...] in document px), but size, hardness, opacity, layer, and project are left entirely unexplained, including the units for the brush 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?

Clear specific verb+resource: 'Paint on a layer's mask', with mode hide/reveal and the polyline input format named. It distinguishes itself from set_mask/update_mask/remove_mask implicitly by being a freehand paint operation, but never explicitly contrasts with the sibling paint_stroke or the mask-management tools.

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

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

The parenthetical 'refine an AI cut-out' gives one concrete usage scenario, which implies when this tool is appropriate. However, there is no guidance on when to prefer update_mask/set_mask over painting, nor any exclusion or prerequisite, so 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 and falls short. It does not disclose whether the operation is destructive or reversible, whether colors are permanently baked into the layer, how the amount parameter modulates the effect, or what permissions/project context are needed 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 an illustrative parenthetical and no wasted words. It is efficient, though arguably too sparse given the undocumented parameters and missing behavioral context.

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

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

For a 4-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It omits parameter meanings, reversibility, and any indication of what the operation returns or how to scope it to a project.

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

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

Schema coverage is 0%, so the description must compensate, but it only implicitly covers layer and reference. The amount parameter (default 1) and project parameter are entirely undocumented, leaving the strength/scope of the matching effect undefined.

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 (match a layer's colors and tones to another layer) with a concrete example of the scenario. It is clear what the tool does, though it does not distinguish itself from related siblings like apply_look or auto_enhance that could also alter color.

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

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

The parenthetical example ('a pasted subject vs the background') implies the typical compositing use case, giving implied usage context. However, there is no explicit when-to-use guidance, no exclusions, and no routing to alternatives such as apply_look or auto_enhance.

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 disclosure burden and does not meet it. It never says the operation is destructive (the source layer ceases to exist), whether the result is undoable, what happens when the target layer is the bottom-most or has a different blend mode, or whether the merged layer inherits the lower layer's properties.

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 no repetition of the tool name. It is efficient, though the terseness comes at the cost of the content gaps noted elsewhere rather than being a model of economical completeness.

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

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

For a destructive layer operation with no annotations, no output schema, and 0% parameter coverage, the description leaves critical questions unanswered: destructiveness, undo behavior, layer-identifier format, and the role of the optional project parameter.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters and does not. 'layer' is only implicitly referenced as the thing being merged, with no indication whether it is a name, ID, or index, and 'project' is entirely unmentioned.

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+resource ('merge a layer') plus a directional qualifier ('into the one below') that separates it conceptually from flatten and group_layers. It is clear what the operation does, though it never explicitly contrasts itself with those sibling tools.

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

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

There is no statement of when to use this over flatten, group_layers, or rasterize_layer, and no prerequisite (e.g. at least two layers must exist, which layer pair is affected). The agent must infer everything about selection context 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 provided, so the description carries the full disclosure burden. It contributes the useful fact that ordering is semantically meaningful, but says nothing about whether the move is reversible (undoable), what happens to displaced effects, or permission requirements 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 short sentence with the key constraint front-loaded in parentheses; nothing is wasted, though the extreme brevity contributes to the parameter ambiguity noted above.

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

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

For a four-parameter mutation tool with zero schema coverage, no annotations, and no output schema, the description is under-specified. At minimum the index/to pairing and layer scoping needed explanation; the description supplies none of 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?

Schema description coverage is 0%, so the description must compensate for all four parameters. It never explains what 'index', 'to', 'layer', or 'project' mean, leaving the agent to guess which argument is the source position and which is the destination.

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 (reorder) and resource (effects), and the parenthetical example clarifies what reordering means operationally. It is clearly distinguishable from add_effect, update_effect, and remove_effect by the 'reorder' action, 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?

The 'order matters' note implies this tool is for sequencing effects, but there is no explicit when-to-use guidance or mention of alternatives such as remove_effect + add_effect to achieve the same result. Usage is inferable 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 provided, the description carries the full behavioral burden. It discloses genuinely useful semantics the schema lacks (allowed 'to' values, index 0 = bottom, the 'root' sentinel for ungrouping), but says nothing about required layer state, permissions, failure modes, cross-project moves, or whether the reorder is reversible (undo is a separate sibling).

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 dense sentence with the primary action front-loaded and the parameter modes unpacked in semicolon-separated clauses. No filler, no restating of the name or 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?

For a five-parameter mutation tool with no annotations, no output schema, and no enum definitions in the schema, the description covers the core mechanics but omits the 'project' parameter entirely, doesn't identify what 'layer' accepts, and gives no return-value or error context. 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 0% and there are no enums, so the description must compensate — and it does substantially for three of the five params: it enumerates the valid 'to' values, explains 'index' origin (0 = bottom), and defines 'into' including the 'root' sentinel. It leaves 'layer' (name vs ID?) and 'project' (current vs named project?) undocumented, keeping it short of a 5.

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 (reorder/move a layer) and explains the two operation modes: positional reordering within a list and relocating into/out of a group. It is distinguishable from siblings like group_layers, ungroup, and align_layer, though it never names or 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?

The description implies when each parameter mode applies (to=up/down/top/bottom vs index vs into=<group> vs into="root"), which is useful operational guidance. However, it gives no context for choosing move_layer over alternatives such as set_transform or group_layers, and doesn't clarify what happens if 'to' and 'index' are both supplied.

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 it does disclose one genuinely useful trait: the editor edits the same in-memory document with live updates rather than a copy. It says nothing about blocking behavior, whether an URL/port is returned, editor lifetime, or auth needs, which are the remaining behavioral questions for an open-a-UI 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; the parenthetical carries the key distinguishing trait. Only the unexplained 'project' param hints that something relevant was left unsaid.

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 no annotations, no output schema, and zero parameter documentation, the description is too thin. An agent cannot tell what port does, what project selects, or what happens after the editor opens.

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

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

Schema coverage is 0% for two parameters, so the description must compensate and it does not — neither 'port' nor 'project' is mentioned. Worse, the 'project' parameter sits oddly against the claim of opening 'THIS document', with no explanation of how the two relate.

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 (Open) and resource (web editor) and pins the target as 'THIS document', which meaningfully separates it from the sibling project_open (open a project from disk). It never names that sibling, however, so the differentiation is implicit rather than spelled out.

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?

'same in-memory document, live updates' implies when this is appropriate — you want a live view of the document already loaded — but there is no explicit when-to-use or when-not-to-use guidance and no reference to alternatives like project_open or close_ui. Usage is inferable, 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?

With no annotations, the description carries the full burden and does well: it discloses that the paint layer is auto-created if missing (a side effect), that erase=true destructively removes prior strokes of that layer, and that clone stamp copies from everything below the layer. It omits undo/redo interaction, permissions, and return behavior, but the destructive semantics are clearly surfaced.

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?

Dense but front-loaded: the core stroke definition comes first, then mode-specific overrides. Every sentence adds information, with no filler or restatement of the tool name.

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

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

For a 10-parameter mutation tool with no annotations and no output schema, the description does solid work on behavior and the trickiest parameters but leaves several numeric/appearance parameters (opacity, hardness, layer, color) unexplained. Adequate but short of complete for this complexity.

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

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

Schema description coverage is 0% across 10 parameters, so the description must compensate. It usefully clarifies the non-obvious ones — points as [[x,y],...] in document px, erase, source, heal — but leaves size, color, layer, opacity, hardness, and project entirely undocumented, roughly half the surface.

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 — a brush/paint stroke defined by a polyline of document-px points on a paint layer — and names the operational variants (erase, clone stamp, heal). An agent can tell it apart from mask_stroke by the 'paint layer' target, though that sibling rivalry is implied rather than stated.

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

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

It explains mode selection (erase=true, heal=true, source=...) which is effectively intra-tool usage guidance, but offers no when-to-use/when-not guidance relative to siblings like mask_stroke, add_shape, or add_fill. Usage is implied through the parameter semantics rather than directed.

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 read/render operation and describes the visual output, but never states that it is non-mutating, whether it consumes compute/credits, whether it can be slow, or in what form the image is returned. The render verb tells the agent what comes back but not the operational traits.

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

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

It is three tight sentences with the core purpose front-loaded before the parameter notes. The terse notation (box=[x,y,w,h], layer=<id>, grid=true) is efficient, though it is compressed enough to read as notes rather than prose.

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, no output schema, and 0% schema coverage across five parameters, the description leaves real gaps: the meaning of width and project is never stated, and there is no indication of the return payload despite there being no output schema to fall back on. It covers the interesting visual parameters but not enough for an agent to call the tool confidently in all cases.

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

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

Schema description coverage is 0%, so the description must compensate, and it does document three of five parameters with non-obvious detail: box as [x,y,w,h] in document pixels, layer as a single-layer solo, and grid as a 10% overlay labelled in document px. However, width (default 1024) and project are entirely unexplained in both schema and description.

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

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

The description states the tool produces the rendered raster preview via the imperative 'LOOK at the result: the real rendered image,' which distinguishes it from the AI-analysis siblings (analyze_image, describe_image, review_image) that operate on images rather than render them. It names no sibling explicitly, so differentiation is implicit rather than stated.

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 or when-not-to-use guidance. The agent is told what box, layer, and grid do, but nothing indicates when a preview is the right call versus export_image, analyze_image, or review_image, or whether it must be preceded by other state-changing 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 burden, and it does add real behavioral facts: path triggers autosave after every edit, and background accepts 'transparent'. It omits other important traits such as what happens to the current document, whether this replaces existing state, 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?

Front-loaded with the core action in three words, then a dense but compact enumeration of options. Every clause adds usable information 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 document-creation tool with no annotations and no output schema, the description covers sizing, saving and background well, but leaves open the return value, the default behavior of 'name', and any interaction with the existing project or UI 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 0%, so the description must compensate, and it does for most parameters: it enumerates valid preset values, explains width/height, clarifies that from_image derives canvas size from the photo, and explains path/autosave and background='transparent'. Only 'name' is left undocumented.

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

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

The first sentence gives a clear verb and resource ('Create a document'), and the remainder enumerates the concrete sizing/saving options. It is distinguishable from project_open and project_save by intent, though it never explicitly names those siblings as alternatives.

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

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

The description explains the three mutually exclusive ways to define canvas size (preset list, width/height, from_image), which is genuine usage guidance for the parameters. However, it never states when to use project_create versus project_open, nor any precondition such as whether the UI must be open.

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 return shape (layers top-first, ids, boxes, effects, masks), which implies a non-mutating query, but it never explicitly states read-only behavior, permissions, or cost/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?

Very compact: one clause listing return contents plus one sentence on the detail flag. Front-loaded and free of filler, though the telegraphic style leaves the verb implicit.

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 does some heavy lifting by enumerating returned fields, but it leaves the 'project' parameter undocumented and does not fully define the detail modes, so an agent lacks enough to call it confidently in all cases.

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

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

Schema description coverage is 0%, so the description must compensate. It only partially explains 'detail' ('full' adds all params) and says nothing about the 'project' parameter or what 'normal' (the default) returns versus 'full'.

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

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

The description names the resource (document state) and enumerates the fields it returns: size, layers with ids, boxes, effects, masks. An agent can tell it is a read/query tool for the current document, though it never states an explicit verb and does not distinguish itself from siblings like analyze_image or describe_image.

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

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

There is no guidance on when to call this versus alternatives such as project_settings, preview, or analyze_image, and no prerequisites are stated. The only usage hint is the incidental note that detail='full' adds all params.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one genuinely useful trait: a photo opens as a new unsaved document sized to the image. It says nothing about what happens to the currently open document, whether unsaved changes are lost, error behavior on a missing/invalid path, or whether a .json must be pedit-produced.

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, front-loaded with the primary action and the secondary case in parentheses. Nothing is wasted, though the parenthetical aside is slightly crammed.

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 file-opening tool with no annotations and no output schema, the description covers the input types and one side effect, but leaves open the fate of the current document and failure modes, which are the details an agent most 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?

Schema coverage is 0% and the sole parameter 'path' has no schema description, but the prose indirectly clarifies what the path should point to (a pedit .json document or an image file), which is real semantic value. It still omits format details such as absolute vs relative paths or supported image extensions.

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 (open) and the accepted resources (.json document or photo), which is enough to separate it from project_create and project_save. It does not, however, distinguish itself from the closely named sibling open_ui, so a small ambiguity remains.

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 or when-not-to-use guidance and no mention of alternatives such as project_create for new documents or open_ui. The agent must infer from the sibling list when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the .json format and a save-as condition, but says nothing about overwrite behavior, required permissions, side effects, or what happens when path is omitted.

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 front-loaded and very brief: 'Save the document (.json). With path: save as.' Both sentences earn their place. The second sentence is a fragment and slightly telegraphic, but there is no wasted prose.

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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too sparse. It omits project semantics, return behavior, overwrite behavior, and permission requirements.

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

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

Schema description coverage is 0%, so the description must explain both parameters. It adds meaning for path ('save as') but gives no information about the project parameter, leaving half the parameters undocumented.

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

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

States a specific verb and resource: 'Save the document (.json).' This distinguishes it from siblings like project_open and project_create. It does not explicitly contrast with alternatives such as export_image, 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?

The only conditional guidance is 'With path: save as,' which explains path behavior but not when to choose this tool over siblings like export_image or project_create. No prerequisites, exclusions, or alternative tools 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 behavioral burden, yet it discloses nothing: not whether it mutates, whether it requires an open project, whether changes persist, or what it returns. The fragment mentions 'transparent' being allowed for background, which is the only behavioral hint, and it 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?

Brevity here reflects under-specification rather than information density; the text is a fragment with no front-loaded purpose statement. It is short but does not earn its place as a usable definition.

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, no output schema, and 0% parameter coverage, the description is the only information source and it is a four-word fragment. For a tool with four parameters that likely mutates project state, this is wholly inadequate.

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

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

Schema description coverage is 0%, so the description must compensate, but it only names three of the four parameters (name, background, dpi) and omits 'project' entirely. It adds one useful constraint ('transparent' allowed for background) but leaves types, formats, and defaults undocumented.

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

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

The description is a bare noun phrase listing settings fields ('Document name, background color, dpi') with no verb, so it never states what the tool actually does. It neither says whether project_settings reads or writes configuration, making it effectively a restatement of the tool name rather than a purpose statement.

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

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

There is no guidance about when to use this tool versus siblings like comfy_settings or project_info, and no prerequisites or exclusions are mentioned. An agent has no basis to choose this tool over alternatives from the description alone.

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

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

With no annotations, the description carries the behavioral burden. It does disclose that effects and mask are baked into the result, which is useful information about what gets consumed. However, it never states that the operation is destructive/irreversible or what happens to the original layer's editable properties.

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 operation and its scope stated immediately. No filler or redundancy; every clause carries 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 destructive mutation tool with zero annotations, no output schema, and 0% parameter coverage, the description is thin. It omits irreversibility, permissions, the fate of the mask/effects after conversion, and the secondary parameter, leaving gaps an agent needs before safely 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?

Schema description coverage is 0%, so the description must compensate. It usefully constrains the 'layer' parameter to text/shape/paint layer types, adding meaning beyond the bare string schema. But the optional 'project' parameter is entirely undocumented.

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

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

States a specific verb (rasterize) and resource (a text/shape/paint layer with effects and mask), so the agent understands it converts a layer to pixels. It differentiates somewhat from bulk siblings like flatten/merge_down by scoping to a single layer, though it doesn't name them.

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

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

No explicit when-to-use or when-not-to-use guidance. It doesn't mention alternatives like flatten (whole document) or merge_down (combine two layers), leaving the agent to infer when rasterizing a single layer is appropriate.

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

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

No annotations provided, so the description bears full behavioral burden. It states the redo action but omits whether it mutates state, whether it can be repeated, what happens if no undone edit exists, or if it requires confirmation. For a no-annotation mutation tool, this is insufficient.

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. It is appropriately sized for a simple command, though the brevity reflects gaps in content rather than optimal conciseness.

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

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

With no annotations, no output schema, and an undocumented parameter, the description is incomplete. It does not explain the 'project' parameter or the dependency on a prior undo operation, leaving the agent to guess.

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 single 'project' parameter has 0% schema description coverage. The description does not mention the parameter at all, so it fails to compensate for the missing schema documentation. An agent cannot tell what 'project' means or whether it is required.

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

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

States a specific verb 'redo' and resource 'last undone edit', making the operation distinct from sibling 'undo'. However, it does not explicitly name the sibling or distinguish when to use redo vs undo, so it's clear but lacks 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?

No when-to-use guidance, no mention of prerequisites (e.g., must have an undone edit), and no alternative tools named. Usage is only implied by 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?

With no annotations, the description carries the full burden, and it does disclose meaningful behavior: the mask is non-destructive ('the photo stays intact'), keep=background inverts the result, and backend=stability switches to an online service (implying a network dependency). It does not say whether an existing layer/project is required, whether the operation is undoable, or what happens to prior masks.

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?

Dense and front-loaded: the core outcome leads, then the inversion rule, then model and backend notes. Every sentence carries information, though the telegraphic style with '=' shorthand reads more like notes than prose.

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

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

For a 5-parameter tool with no annotations and no output schema, the description covers the concept, model options and the online/local backend split, but leaves the required 'layer' and 'project' parameters and the post-call layer state unexplained. 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 0%, so the description must compensate, and it only covers three of five parameters (keep, model with concrete model names, backend). Required parameter 'layer' and 'project' receive no explanation, nor do the accepted values for keep beyond 'background'.

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 concrete outcome: an AI-driven cut-out rendered as a layer MASK while 'the photo stays intact', which an agent can distinguish from generic mask siblings like set_mask or update_mask. It doesn't explicitly name an alternative sibling, but the AI-cutout framing is specific enough to route 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?

Usage is implied rather than stated – there is no explicit 'use this when / not when' or named alternative among the mask tools. It does give selection guidance for two parameters (model choice, backend=stability for online processing), which partially compensates.

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 discloses almost nothing. 'Remove' implies a destructive, likely irreversible mutation, but it says nothing about whether removal shifts subsequent effect indices, requires the effect to exist, or needs project 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?

One short, front-loaded sentence with no filler or redundancy. It is efficiently written, though brevity here edges toward under-specification rather than crispness.

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 0% parameter coverage, the description is far too thin. An agent cannot determine what 'index' means, whether the operation is reversible, or what happens to remaining effects after removal.

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

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

Schema coverage is 0% for all three parameters. The description implies 'layer' but never defines what 'index' refers to (presumably an effect-list position) and omits the 'project' parameter entirely, leaving required parameters undocumented in both schema and prose.

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 (remove) and resource (effect) with the scope constraint (from a layer), so an agent knows what operation this performs. It does not differentiate from adjacent siblings like remove_mask, remove_layer, or list_effects/add_effect, but the core 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?

The description gives no when-to-use or when-not-to-use guidance and names no alternatives. An agent must infer from the name alone whether this is the right tool versus update_effect or move_effect.

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, and it does add one valuable trait: the deletion is undoable/reversible. It omits other relevant behavior such as whether child layers, masks, or effects are removed with the layer, and whether any permission is required.

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 waste; the verb and resource lead, and the reversibility note is a compact qualifier. 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 mutation tool with two undocumented parameters, no annotations, and no output schema, this is too thin. It should state the layer identifier convention, the role of 'project', and the side effects on masks/effects.

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

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

Schema description coverage is 0%, so the description must compensate for both 'layer' and 'project' parameters, and it does not. It never clarifies how the layer is identified (name vs id) or what the optional project scoping does.

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 ('Delete') and resource ('layer'), so the agent knows exactly what the tool does. It does not, however, differentiate itself from adjacent siblings like remove_mask, remove_effect, or ungroup, which an agent could plausibly confuse.

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 prerequisite, and no mention of alternatives such as remove_mask or merge_down. The parenthetical '(undoable)' hints that redo/undo can reverse it but does not route the agent between tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether removal is destructive or reversible, what happens if the layer has no mask, error/auth conditions, or what the operation returns. For a mutation tool this is a significant gap.

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

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

A single tight, front-loaded sentence with no padding. It is efficient, though the brevity leaves the tool under-specified rather than fully 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 no annotations, no output schema, and 0% parameter coverage, the description is too thin. It should at minimum clarify destructive/reversibility behavior, the layer identifier expectations, and the role of the optional project parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It implies the `layer` parameter but adds no format, accepted identifier type, or meaning, and the optional `project` parameter is never mentioned at all.

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

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

States a specific verb (remove) and resource (a layer's mask), which implicitly distinguishes it from siblings like set_mask, update_mask, mask_stroke, and remove_layer. It is clear on its own, though it does not explicitly name or contrast with 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 when-to-use guidance is provided and no alternatives are named. An agent must infer when mask removal is appropriate (vs. set_mask, update_mask, or remove_layer) entirely on its own.

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. 'then go on' faintly signals a non-blocking, no-confirmation call, but it says nothing about whether the report persists, requires any permissions, or produces a response. For a tool with zero annotation coverage this is a substantial 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 economical sentence with the action front-loaded and no filler. The trailing 'then go on' is slightly cryptic but compact rather than verbose.

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

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

With no annotations, no output schema, and 0% schema coverage across 3 parameters, the description would need to explain field intent and the effect of logging. It instead covers only the 'kind' values, leaving an agent unable to fill 'title'/'details' confidently or know what happens after the call.

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

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

Schema description coverage is 0%, so the description must compensate. It supplies the accepted values for 'kind' (bug, scomodo, sbagliato, manca, lento), which the schema does not, but leaves 'title', 'details', and 'tool' entirely undocumented in both places.

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 'Log' plus the object 'what is broken/clumsy/missing' states a clear purpose, and no sibling tool competes with it (all siblings are image-editing operations). The parenthetical 'kind' list also hints at the issue taxonomy, though the mixed Italian/English terms are not explained.

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?

'then go on' implies this is a fire-and-forget action that does not interrupt the workflow, which is the only usage context given. There is no explicit when-to-use vs when-not-to-use guidance and no alternatives to choose between, so 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?

With no annotations, the description carries the full behavioral burden. It discloses one important trait (content is not scaled, only the canvas changes) and hints at anchor behavior, but says nothing about required permissions, whether the operation is reversible, what happens to layers/artboards outside the new bounds, or how the current project is selected.

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 terse sentences, front-loaded with the action and the key constraint, with no filler. The trailing ellipsis in the anchor list is a minor sloppiness that leaves the reader unsure whether the enumeration is complete.

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, no output schema, and 0% parameter description coverage, the description is far too thin. An agent cannot determine units, default anchor behavior, permission requirements, or how this differs from sibling canvas/resize operations.

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

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

Schema description coverage is 0%, so the description must compensate. It partially documents 'anchor' by listing example values (center, top, bottom_left, ...), which is genuinely additive since the schema has no enum, but the list is truncated and never explains what an anchor does. Width/height units (pixels vs. percent) and the 'project' parameter are entirely undocumented.

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

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

States a specific verb+resource ('Change canvas size') and immediately adds the key differentiator 'without scaling content', which separates it from resize_image. However, it does not name the closest siblings (crop_canvas, expand_canvas) or explain how it differs from them, so the agent must still 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 explicit when-to-use or when-not-to-use guidance, and no sibling is named. The clause 'without scaling content' hints at the differentiator from resize_image but does not tell the agent when to pick this over crop_canvas or expand_canvas, which are adjacent in the sibling list.

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, so the description carries the full behavioral burden. It usefully discloses that proportions are preserved and only one side need be passed, but says nothing about units, what happens if both width and height are supplied, whether the change is undoable, 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?

A single tight sentence with the operation front-loaded and the constraint trailing. No filler, though the colon-fragment style is terse to the point of being cryptic about 'pass one side'.

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, no output schema, and 0% schema description coverage, the description should do more. It covers the core aspect-ratio behavior but leaves the project parameter, units, error/edge cases, and the relationship to resize_canvas and upscale unresolved.

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

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

Schema coverage is 0% across three parameters. The description compensates for width/height by stating 'pass one side', implying mutual exclusivity, but adds nothing about units or the 'project' parameter. That leaves a significant semantic gap on a 3-param tool.

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 (scale the whole document, canvas and content) and adds the scope that distinguishes it from a canvas-only operation. It doesn't name the sibling it is contrasted with (resize_canvas, upscale), so differentiation is inferable 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 phrase 'whole document (canvas and content)' implies when to use it versus resize_canvas, but no alternative is named and no when-not guidance is given. With resize_canvas, crop_canvas, expand_canvas, and upscale all present, the agent is left to infer the routing.

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

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

With no annotations, the description carries the full burden. It does disclose that output is a set of warnings and that each warning points to the fixing tool, plus an indirect state note ('Not done while it warns'). But it omits permissions, cost, whether it mutates the document, and what the review 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?

Short and front-loaded with the check description, which is good. However the trailing 'Not done while it warns' is cryptic and the ellipsis leaves the issue list open-ended, adding ambiguity rather than economy.

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 diagnostic tool with no annotations, no output schema, and an undocumented parameter, the description conveys what is checked and that warnings name fixers, but leaves the return shape, the project parameter, and the meaning of the final sentence 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?

There is one parameter ('project') with 0% schema description coverage, and the description says nothing about it or whether omitting it targets the active project. For low schema coverage the description is expected to compensate, and it does not.

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 (check) and resource (the document) and enumerates the concrete issues it looks for: off-canvas/low-contrast text, layers outside, blown highlights, upscaled images. The purpose is distinguishable from sibling analysis tools like analyze_image or describe_image, though it doesn't explicitly contrast itself with 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 statement of when to reach for this tool versus siblings like analyze_image or preview. The clause 'each warning names the tool that fixes it' hints at a remediation workflow but gives no explicit when/when-not condition, and 'Not done while it warns' is too opaque to count as guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Change' implies a mutation, but the description says nothing about required permissions, reversibility, whether a fill layer must already exist, or the effect on gradient stops and other layer settings.

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

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

The single sentence is technically concise with no wasted words, but this is under-specification rather than conciseness. For an 8-parameter mutation tool it is far too terse to be front-loaded with useful 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?

An 8-parameter mutation tool with no annotations, no output schema, and 0% parameter documentation is left almost entirely unexplained. The description does not give an agent enough to call it correctly.

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

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

All 8 parameters (cx, cy, kind, angle, color, color2, layer, project) have 0% schema description coverage, and the description explains none of them. Nothing indicates what kind accepts, what cx/cy mean, or how color2 interacts with color for gradients.

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 verb and resource ('Change a fill/gradient layer'), which is enough to place it next to siblings like add_fill. However, it never clarifies scope: whether it edits an existing fill layer, what properties are changed, or how it differs from add_fill or set_layer beyond the verb.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as add_fill (to create a fill) versus set_fill (to modify one). The agent must infer the selection rule from the tool name alone.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It explains clip semantics and that groups also pass through, but does not state that this is a mutation tool, what happens to omitted properties, whether changes are destructive or reversible, or what permissions are required.

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 fragmented list rather than a structured sentence, and it opens with property names instead of a purpose statement. The long blend-mode enumeration is necessary because the schema lacks an enum, but the overall structure is dense and not front-loaded with the core action.

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

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

For an 8-parameter mutation tool with no annotations, no output schema, and no schema descriptions, the definition is incomplete. It does not identify the required layer target, explain the project parameter, clarify update semantics for omitted fields, or describe return behavior, leaving key gaps for correct invocation.

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

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

With 0% schema description coverage and 8 parameters, the description compensates substantially by documenting many updatable fields, including opacity range 0..1, clip meaning, lock/visibility, and an extensive blend-mode enum. It still omits meaning for the layer and project parameters, but it adds significant value beyond the bare schema.

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

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

The description is a list of layer properties rather than a clear verb+resource statement. An agent can infer that set_layer updates layer attributes, but there is no explicit 'set' or 'update' verb and no differentiation from siblings such as set_transform, set_text, set_shape, or move_layer.

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

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

No when-to-use guidance is provided. The description does not say when to choose set_layer over related tools like move_layer, set_transform, group_layers, or set_mask, nor does it state any exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose real traits: white = visible mask semantics, the document-px coordinate space, image path alignment, and hide_all initialization. It stops short of saying whether an existing mask is replaced, what permissions are required, or how density interacts with the result.

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

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

The mask semantics are front-loaded before the mode enumeration, and nearly every clause carries a format, unit, or behavioral detail rather than filler. It reads as one dense run-on string, but no sentence 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 9-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description covers the primary modes well but leaves invert/density and the set-vs-update-vs-remove relationship unexplained. Adequate as a minimum viable definition, not complete.

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

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

Schema coverage is 0%, so the description must compensate and it partially does: it defines the kind modes, the box=[x,y,w,h] document-px format, the path requirements (grayscale/alpha, aligned to content), the feather unit (px), and hide_all semantics. Four of nine parameters — layer, project, invert, and density — get no explanation, and density in particular is non-obvious.

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 centers on "Layer mask (white = visible)" and enumerates the mask kinds (rect/ellipse/image/paint), so an agent can infer this configures a layer mask. However, the action verb is never stated and there is no differentiation from the tightly related siblings update_mask, remove_mask and mask_stroke, leaving the exact purpose only implied.

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

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

It gives mode-level guidance — paint is paired with mask_stroke, hide_all=true starts fully hidden — which is useful conditional context. But it never states when to choose set_mask over update_mask or remove_mask, so the core when-to-use decision is left to inference.

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

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

With no annotations, the description carries the full burden. It does disclose one genuinely non-obvious behavior: setting fill/stroke to 'none' removes them, which is destructive context an agent needs. However it omits whether unspecified properties are merged or replaced, permissions, and what the response contains.

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 destructive behavior parenthetically front-loaded. No wasted words, though the brevity reflects under-specification as much as efficiency.

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

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

For a 10-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, one sentence is far from complete. Merge semantics, required layer behavior, and the meaning of most parameters are missing.

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

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

Schema coverage is 0% across 10 parameters, so the description must compensate. It only clarifies fill/stroke semantics and implies layer; h, w, kind, points, radius, project, and stroke_width remain entirely undocumented in both schema and description.

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

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

States a specific verb and resource ("Change a shape layer"), which is clearly distinct from the sibling add_shape (create). An agent can tell this mutates an existing shape. It does not, however, say which aspect of the layer is changed beyond fill/stroke, leaving the scope of the operation somewhat open.

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 add_shape, set_fill, set_transform, or paint_stroke. The only conditional given is an inline note about 'none', not a usage rule. No prerequisites or exclusions 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 disclosure burden and largely fails it. It does not say whether unspecified properties are preserved, whether the change is reversible (undo), what errors occur on a non-text layer, or how project scoping works.

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 that front-loads the action and resource with no filler. However, given the 13-parameter surface, the extreme brevity edges toward under-specification rather than discipline.

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 13-parameter mutation tool with no annotations and no output schema, the description leaves most behavioral and parameter context unstated. It is not sufficient to let an agent invoke the tool correctly without schema inspection.

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

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

Schema coverage is 0% for 13 parameters, so the description must compensate but only gestures at two vague families ('text or style'). It adds no meaning for bold, font, size, align, color, stroke_color, stroke_width, line_spacing, max_width, italic, layer, or project.

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