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 that a new Text Layer is created in the active document, but does not state whether it requires an open document, what happens on undo/redo, where the layer is positioned, or any other mutation side effects.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately sized for its purpose and immediately communicates the core action.

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

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

For a mutation tool with no annotations, 7 parameters, and no schema descriptions, the description is too thin. It mentions creating a Text Layer in the active document but omits parameter details, prerequisites, and side effects. The presence of an output schema reduces the need to describe return values, but the description remains incomplete 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?

The input schema has 7 parameters with 0% description coverage, and the tool description adds no parameter meaning. It does not explain text, x_px, y_px, color_hex, font_name, font_size_pt, or justification, leaving the schema titles and defaults as the only available clues.

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 (Create) and resource (Text Layer) with scope (active document) and type (vector typography). It is clear what the tool does, though it does not explicitly differentiate itself from the sibling photoshop_create_layer tool.

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

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

The description implies the tool is used to add text to the active document, but gives no explicit guidance on when to use it versus alternatives such as photoshop_create_layer or how it relates to other layer tools. 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 behavioral burden. It discloses the -100 to 100 range and implies an active layer must exist, but says nothing about permissions, reversibility, whether the operation is destructive, or whether an active document/layer is required. For an unannotated mutation tool this is a notable 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 that front-loads the operation and folds the value range in without waste. Every element earns its place.

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

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

With no annotations, 0% schema description coverage, and no output-schema explanation needed, the description is too thin for a mutation tool. It omits sibling differentiation, prerequisites, and any behavioral context, leaving meaningful gaps for an agent to fill by guesswork.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It names both fields and supplies the (-100 to 100) range that applies to each, which adds real meaning beyond the bare titles and defaults. It still omits any explanation of the default-0 behavior or the effect of negative vs positive values.

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

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

States a specific verb (Adjust) and resource (brightness and contrast of the active layer), so the agent knows exactly what operation runs. It does not, however, distinguish itself from tone-manipulation siblings such as photoshop_auto_contrast, photoshop_adjust_curves_auto, or photoshop_auto_levels.

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 several siblings (auto_contrast, adjust_curves_auto, auto_levels) that overlap in intent. The agent is left to infer when this manual adjustment is preferable to the automatic ones.

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, yet it says nothing about whether this is a destructive pixel edit, whether it can be undone, or whether it creates an adjustment layer instead. The only behavioral hint is the implicit target scoping.

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 no filler and the operation front-loaded. It is efficient, though arguably too terse to be maximally useful.

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

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

The output schema relieves the description of explaining return values, but for a pixel-modifying adjustment with no annotations a note on destructiveness or reversibility would make it complete.

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

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

The tool takes zero parameters and the schema has full coverage, so there is nothing for the description to compensate for; the baseline for a no-parameter tool 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 ('Apply') plus a named operation ('Auto Curves') and the precise target ('the active layer'), which cleanly separates it from siblings like photoshop_auto_levels and photoshop_auto_contrast.

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 'active layer' implies the precondition that a layer must be selected, but there is no guidance on when to prefer this over photoshop_auto_levels, photoshop_auto_contrast, or photoshop_adjust_brightness_contrast, nor any exclusion.

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, yet it only says 'adjust'. It does not disclose whether the change is destructive to pixels or creates an adjustment layer, whether it is undoable, what valid ranges are, or how the active layer is determined. This is a mutation tool with essentially no behavioral disclosure.

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

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

A single efficient sentence with the verb and target front-loaded and no filler. It is appropriately sized, though the brevity contributes to the missing behavioral and parameter detail elsewhere.

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

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

An output schema exists, so return values need not be explained, but for a mutating adjustment tool with zero annotations indeed the description should cover destructiveness, scope, and parameter ranges. None of that is present, leaving the agent unable to call it correctly.

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

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

Schema description coverage is 0% and no annotations exist, so both structured fields and prose are silent. The description names the three parameters (matching the schema keys) but gives no ranges or units, which is critical for hue (-180..180 vs 0..360) and saturation/lightness (percentage vs -100..100). It adds almost nothing beyond the schema.

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

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

States a specific verb (adjust) plus the three resources (Hue, Saturation, Lightness) and scopes them to the active layer, which an agent can distinguish from siblings like photoshop_desaturate or photoshop_adjust_brightness_contrast. It does not explicitly name those alternatives, so it stops short of a 5.

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

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

There is no when-to-use guidance and no mention of related tools such as photoshop_desaturate (a special case of saturation adjustment) or photoshop_create_adjustment_layer (a non-destructive variant). The agent must infer selection entirely from tool names.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the tool's name. It does not say whether the filter is destructive or applied as a smart filter, whether it needs an active/selected layer, that all ten parameters default to 0 (making a no-arg call a likely no-op), or any permission/undo implications of this mutation.

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

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

A single front-loaded sentence with no filler; the verb and resource lead immediately. Nothing is redundant or padded.

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

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

For a 10-parameter mutation tool with no annotations, the description is far too thin: half the parameters are unnamed, no behavioral or prerequisite context is given, and nothing explains how the integer scales behave. The presence of an output schema removes the need to describe return values, but that alone does not offset the other 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% – the schema only supplies titles and integer/number types with default 0. The description names 5 of the 10 parameters (exposure, clarity, dehaze, temperature, vibrance) but omits tint, shadows, contrast, highlights, and saturation, and gives no ranges, units, or sign conventions (e.g. whether exposure is in stops or how -100..100 scales work).

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

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

States a specific verb (Apply) and resource (Adobe Camera Raw Filter) and enumerates representative controls, so the agent knows it is a tone/color filter operation. It does not, however, distinguish itself from overlapping siblings such as photoshop_adjust_brightness_contrast or photoshop_adjust_hue_saturation, which share exposure/contrast/saturation concepts.

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

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

No when-to-use or when-not-to-use guidance is given. With several sibling adjustment tools available (auto_levels, auto_contrast, adjust_curves_auto, adjust_hue_saturation), the agent is left to infer which one applies, and no prerequisites (e.g. an open document) are stated.

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

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

No annotations are provided, so the description carries the full burden. 'Apply' implies a mutation, but the description never states whether the operation is destructive or non-destructive, whether it requires the layer to be rasterized/smart object, what happens with no active layer, or whether it can be undone. Only the barest behavioral signal is present.

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 that is front-loaded with the action and resource, with no filler. It is efficient, though its brevity contributes to the gaps elsewhere.

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

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

An output schema exists, so return-value explanation is not required, but with zero annotations and 0% schema coverage for the required parameter, the description leaves the agent without behavioral or parameter information necessary 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?

The schema has 0% description coverage for the single required parameter 'radius', and the description does not compensate at all — it never explains units (pixels?), acceptable range, or how radius affects the blur. With undocumented parameters, the description should have carried this, but 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 (Apply) and resource (Gaussian Blur filter) and names the target of the operation (the active layer). An agent can distinguish it from selection, layer-management, and other filter siblings by name, but the description does not explicitly contrast it with alternatives such as photoshop_apply_camera_raw_filter.

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

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

No guidance is given on when to use this tool versus other filter or adjustment tools, nor any prerequisites (e.g., a layer must be active, a selection may need to exist). The single sentence implies usage but states no conditions or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but doesn't disclose whether existing layer styles are replaced or merged, whether the operation is undoable, permission/auth requirements, or what the return value is. With has_output_schema=true, return formatting is partially covered, but mutation semantics remain unstated.

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. It is efficient but perhaps too terse for a 7-parameter mutation tool, leaving no room for required context.

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

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

Given 7 parameters, zero annotations, 0% schema coverage, and no usage guidance, the description is materially incomplete. The existence of an output schema reduces some burden, but an agent cannot confidently invoke this tool without more information about parameter interactions and mutation behavior.

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

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

Schema description coverage is 0%, so the description must compensate, but it only names two of seven parameters (stroke, drop_shadow) without explaining the relationship between them and the five dependent parameters (shadow_size, stroke_size, shadow_opacity, shadow_distance, stroke_color_hex). Defaults exist in schema but meaning and interaction are unexplained.

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

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

States a specific verb (Apply) and resource (Layer Styles / FX), and gives concrete examples (Drop Shadow, Stroke). The scope is narrowed to 'the active layer,' which distinguishes it from sibling layer tools. It loses the top score only because it doesn't explicitly differentiate from adjacent effect-adjacent siblings like adjust_* tools.

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

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

No when-to-use, when-not-to-use, or prerequisites are given. An agent must infer that the active layer must be set beforehand, and there is no guidance on how this relates to other layer tools. Only the 'active layer' phrase implies context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It identifies the target (active layer) but says nothing about whether the change is destructive, whether it is undoable, whether it requires a pixel layer versus a smart object, or what permissions/state are needed.

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

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

A single short sentence with the action and target front-loaded and zero wasted words. Appropriate for a no-argument command.

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

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

The presence of an output schema removes the need to explain return values, and the tool is simple with no parameters. Still, for a parameterless mutation with no annotations, the description omits any behavioral context an agent would want before firing it.

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

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

The tool takes no parameters, so the schema-grounding baseline of 4 applies. There is no parameter detail the description could or should add.

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

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

The description uses a specific verb ('Apply') plus resource ('Auto Contrast') and target scope ('active layer'), so an agent immediately knows the operation. However, it does not differentiate from close siblings like photoshop_auto_levels, photoshop_adjust_curves_auto, or photoshop_adjust_brightness_contrast.

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 indication of when to choose Auto Contrast over the related auto/curve/level tools, nor any stated prerequisites or exclusions. The agent is left to infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the mutation target (the active layer) but nothing about whether the change is destructive or undoable, what happens with no active layer, or whether it errors on adjustment layers. For a no-annotation image mutation, this is a notable 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 short sentence with the target front-loaded and zero filler. Nothing could be trimmed without losing meaning.

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

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

An output schema exists, so return values need not be explained, and the zero-parameter schema is trivially complete. However, with no annotations and no sibling routing, the description leaves the mutation's risk profile and usage context unstated, which is thin for a destructive editing operation.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the schema coverage baseline of 4 applies. The description's mention of the active layer is the only implicit input, and it is stated.

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

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

The description names a specific verb and effect ("Apply Auto Levels") plus the target ("the active layer"), which is enough to distinguish it from sibling selection tools. It does not, however, distinguish it from the closely related photoshop_adjust_curves_auto or photoshop_auto_contrast, so sibling differentiation is left to the agent.

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 Auto Levels versus auto_contrast or curves_auto, nor any stated prerequisite such as needing a pixel layer selected. The agent must infer usage purely from the tool name.

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

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

With no annotations, the description carries the full burden of disclosure, and it says almost nothing: it does not state that pixel content is destructively modified, whether the operation is undoable, or what happens if no selection is active. For a mutation tool with zero annotation coverage, more 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 filler. It is appropriately sized for the tool's simplicity, though it is on the terse side rather than fully economical-plus-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?

The tool has no parameters and an output schema exists, so return values need no explanation. However, the operational preconditions (a non-empty selection) and the destructive nature of the fill are missing, which leaves the definition only minimally adequate.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; per the baseline, a parameter-free tool scores 4. The description correctly does not invent parameter discussion.

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 ('Fill the active selection') plus the mechanism ('using Content-Aware Fill'), so it is distinguishable from generic fills. It stops short of explicitly differentiating itself from the closely related siblings photoshop_generative_fill_ai and photoshop_smart_remove_distractions, which is the one ambiguity an agent faces here.

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

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

Mentioning 'the active selection' implies a selection must exist first, but there is no explicit when-to-use guidance, no statement of the alternative (generative_fill_ai) and no condition that selects between them. The agent must infer usage purely from the name.

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

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

No annotations exist, so the description carries full burden. It doesn't state whether this requires an active selection to exist, what happens if no selection is present, whether the operation is destructive or reversible (undoable), or any side effects. Only the basic action is described.

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

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

Single, efficient sentence that front-loads the action and resource. No wasted words.

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

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

For a selection-modifying operation with no annotations and an output schema that presumably captures return values, the description omits prerequisites (active selection), edge cases (no selection, pixels too large), and behavioral traits an agent would need to call it correctly.

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

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

Schema description coverage is 0% and the single parameter 'pixels' is undocumented in the schema. The description implies the parameter controls the contraction distance, adding minimal semantic value over the parameter name.

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

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

States a specific verb ('Contract') and resource ('active selection') with a clear direction ('inwards by specified pixels'). It distinguishes itself from the sibling 'photoshop_expand_selection' by direction, though it doesn't name it explicitly.

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

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

No guidance on when to use this versus alternatives like photoshop_expand_selection or photoshop_feather_selection. The direction is implied but no explicit selection criteria or context is provided.

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

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

With no annotations, the description carries the full behavioral burden. It does not disclose side effects (e.g., what happens to existing layer styles/smart filters), that it is destructive to the prior layer type, permissions requirements, or failure conditions when no layer is active.

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

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

A single front-loaded sentence with no waste; the action and the target of the action come first.

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 output schema exists so return values need not be explained, but for a mutation tool with no annotations the description omits preconditions, side effects, and error behavior, leaving meaningful gaps for an agent invoking it.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing parameter-wise the description needs to compensate for.

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

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

States a specific verb ('Convert') and target resource ('active layer or selected layers') plus the resulting form ('Smart Object'), which is distinctive among the sibling layer operations. It does not explicitly contrast itself with any sibling, but the purpose is unambiguous.

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

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

No guidance on when to use this versus alternatives (e.g., rasterization, duplication) and no prerequisites stated, such as needing an active layer or a layer selection. The agent must infer the preconditions itself.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does disclose one meaningful trait: the adjustment is non-destructive. That is a genuine differentiator versus the sibling *_adjust_* tools. However, it says nothing about whether a document must be open, which layer the new layer is inserted above, or any permission/undo implications.

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 core action first and the valid type options in parentheses. No filler, no redundancy, nothing that fails to earn 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?

An output schema exists, so return values need not be explained, and the description covers what is created plus the type options. But with no annotations and no parameter documentation, an agent still lacks document-state prerequisites and placement behavior for a tool that mutates the layer stack.

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 schema alone documents neither parameter. The description usefully enumerates the valid adj_type values (curves, hue_saturation, levels, brightness_contrast, vibrance), which is real added value. It says nothing about the 'name' parameter, so compensation for the coverage gap is only partial.

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 (create) and resource (Adjustment Layer) and parenthetically enumerates the supported adjustment types, so the agent knows exactly what gets produced. It does not, however, distinguish itself from the many sibling adjustment commands (adjust_brightness_contrast, adjust_curves_auto, auto_levels, etc.), so the reader must infer the difference from the word 'non-destructive'.

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. In a sibling set containing five sibling adjustment tools plus an entire layer-creation family, the description never says to prefer this layer-based approach over the direct pixel adjustments or how it relates to photoshop_create_layer. Usage is only implied by the word 'non-destructive'.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It does not say whether the new layer becomes the active/selected layer, where it is inserted in the stack, what happens with no document open, or whether the operation is undoable, and it omits the blend_mode behavior entirely.

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. Its brevity is efficient, though it is arguably too terse for a mutation tool with three undocumented parameters.

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 output schema exists so return values need not be explained, but this is a mutation tool with no annotations, 0% parameter documentation, and an omitted parameter. The description does not supply enough context for an agent to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate, but it only names two of the three parameters and ignores blend_mode. It adds no semantics such as the valid opacity range (0-100) or the accepted blend mode values, leaving the schema's bare 'number' and 'string' types unexplained.

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

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

The description states a specific verb and resource ('Create a new art layer'), and 'art layer' is a meaningful Photoshop term that partially separates it from sibling layer-creation tools like photoshop_create_adjustment_layer and photoshop_add_text_layer. However, it never explicitly states that distinction, so the agent must infer it.

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 photoshop_create_adjustment_layer, photoshop_add_text_layer, or photoshop_duplicate_layer, nor any prerequisite such as an open document or an active selection. The agent gets no routing help at all.

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. 'Delete' implies a destructive, irreversible mutation, but the description doesn't state whether the action requires confirmation, whether it's recoverable via undo (photoshop_undo exists as a sibling), or whether it fails when no layer is active. It adds almost no behavioral context beyond the verb.

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

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

A single short sentence with zero waste, front-loading the verb and the object. Appropriately sized for a zero-parameter 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?

An output schema exists so return values needn't be explained, but with no annotations and a destructive operation, the definition leaves key facts unstated: it's irreversible without undo, it requires an active layer, and it fails on an empty layer stack. That's insufficient context for a mutation 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?

The tool takes zero parameters, so parameter semantics are a non-issue; baseline 4 applies. The description correctly implies the target is the 'currently active layer' rather than an ID.

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

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

States a specific verb and resource ('Delete the currently active layer'), clearly distinguishing it from siblings like create_layer, duplicate_layer, and set_layer_visibility. It's clear what the tool does, though the phrasing is minimal.

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 when not to use it, no prerequisites (e.g., that a layer must be active/selected first), and no reference to alternatives like reordering or modifying visibility instead.

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

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

No annotations are provided, so the description carries the burden; it states the mutation ('desaturate layer') but says nothing about reversibility, whether it is destructive, or which layer is affected if none is active. Has an output schema so return values need not be explained.

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 says exactly what the tool does in the minimum 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?

For a zero-param mutation with no annotations and an existing output schema, the description is adequate but thin: it omits whether the operation is destructive, requires an active layer selection, or can be undone, which an agent might need to know.

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?

Tool takes zero parameters, so there are no parameter semantics to explain; baseline 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 (desaturate) and resource (active layer) plus the resulting effect (black and white). An agent can distinguish it from siblings like photoshop_invert or photoshop_adjust_hue_saturation.

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 the target as the 'active layer', which implies the layer must be selected first, but gives no explicit when-to-use or when-not-to-use guidance or alternatives (e.g., vs. hue/saturation adjustment).

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 conveys the core effect (the active selection is removed), but does not state what happens when no selection exists (no-op vs error), whether it applies to any selection type, or whether it is undoable.

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 three-word sentence with zero filler, front-loading the action and the target. For a no-argument, single-effect tool this is appropriately sized.

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 output schema exists, so return values need not be explained, and with no parameters and no annotations there is little left to cover. The only meaningful gap is the no-active-selection edge case, which keeps it from a 5.

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

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

The tool takes zero parameters, so there is no parameter meaning for the description to add; the schema and description are consistent. Baseline 4 applies 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 a specific verb (deselect) and resource (active selection) in a way that is unambiguous and easily distinguished from siblings like photoshop_invert_selection or photoshop_select_all. It does not explicitly name or contrast with any sibling, which keeps it 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 purpose implies when to use it (when a selection should be cleared), but there is no explicit guidance, no mention of prerequisites, and no reference to alternatives such as re-selecting or inverting. Adequate but leaves the agent to infer the trigger condition.

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

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

No annotations exist, so the description carries the full burden and falls short. It doesn't state whether a document must be open, what happens if the named layer doesn't exist, whether the duplicate is placed above the original, or whether the source layer is left untouched.

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

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

One front-loaded sentence with no filler, and the key scope ('or active layer') is parenthetical rather than buried. It is arguably under-specified, but that is a completeness problem rather than a conciseness one.

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 output schema exists so return values needn't be described, but with zero annotation coverage, two undocumented parameters, and no failure or prerequisite information, the description leaves too much for the agent to infer before calling.

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 disambiguate the two parameters — but it only covers 'new_name' via 'optional new name' and never explains what 'name' selects. An agent cannot tell from this text whether 'name' is the source layer or an alternate naming field.

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 ('duplicate') plus resource ('layer'), with the default target clarified as the active layer. It is distinguishable from create_layer or merge_visible_layers, though it never names a sibling explicitly.

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

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

There is no when-to-use guidance and no comparison to the obvious alternatives (create_layer, select_layer_by_name). The parenthetical '(or active layer)' implies a default target but doesn't say when to pass a name instead.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that this runs arbitrary, unsandboxed code with unrestricted access to the document, that effects may be irreversible, or that errors inside the script are surfaced however they are. 'Full JSON serialization' hints at return handling but nothing else about behavior or safety.

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, so nothing is wasted. However, for a tool that executes arbitrary code, one terse sentence is arguably under-specified rather than genuinely concise, and the trailing 'full JSON serialization' clause is vague.

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 output schema exists, so return values need not be explained. But for an arbitrary-code-execution tool with zero annotations, the description omits safety posture, sandboxing, side effects, and failure behavior — the exact context an agent needs before invoking it.

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

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

Schema coverage is 0% for the single 'script' parameter, so the description must compensate. It does add real value by naming the required dialect (ES3 ExtendScript), which the bare 'Script' string schema does not, but it says nothing about expected script structure, return conventions, or how results are serialized back.

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 (Execute) and resource (raw ES3 ExtendScript code inside Photoshop), which clearly separates it from the dozens of narrow sibling operations like photoshop_flatten_image or photoshop_apply_gaussian_blur. It stops short of saying it is the general-purpose escape hatch when no dedicated tool fits, so it is clear but not fully differentiated.

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

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

There is no guidance on when to reach for raw JSX versus the ~45 purpose-built sibling tools, nor any prerequisites, warnings, or exclusions. An agent must infer on its own that this is the fallback for operations no sibling covers.

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

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

No annotations provided, so the description carries the full burden. It says selection expands but doesn't state what happens if no selection is active (error?), whether it requires an open document, whether the operation is undoable, or how it interacts with feathering. Minimal behavioral context 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?

One sentence, front-loaded with the verb and resource, zero waste.

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

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

Output schema exists so return values need not be explained. However, with no annotations and no error/precondition info, the description is minimally complete for a mutate-selection tool that requires an active selection.

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%, but the single parameter 'pixels' is semantically simple. The description says 'outwards by specified pixels' which adds the direction and unit meaning beyond the bare schema. Baseline 4 for zero params doesn't apply since there is one param; with 0% coverage a 3 reflects adequate but not rich specification (no range, no negative-value behavior).

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

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

Names a specific verb (expand), resource (active selection), and direction/unit (outwards by specified pixels). Clearly distinguished from sibling photoshop_contract_selection which does the opposite.

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 describing what it does, but gives no explicit when-to-use context or reference to the sibling contract/feather tools which are the natural alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: it does not say whether the file is overwritten if file_path exists, whether the document is modified, or what permissions/state are required. The presence of an output schema covers return values, but the write-to-disk semantics remain 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?

A single, front-loaded sentence with no filler and no redundancy. It is efficient, though the brevity shades into under-specification rather than disciplined conciseness.

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

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

For a 3-parameter export tool with zero annotation coverage and no schema descriptions, the one-line description is far too thin. An agent cannot determine what quality controls, whether the export overwrites, or how this differs from save_document.

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 only partially does: it clarifies that format_type accepts PNG or JPEG, but says nothing about file_path or the quality parameter (default 90, presumably JPEG-only). The quality parameter is left completely 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?

States a specific verb (export) and resource (the active document) plus the output formats (PNG or JPEG), which is more informative than a bare name restatement. It does not, however, distinguish itself from the sibling photoshop_save_document, which an agent could easily confuse with this operation.

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 photoshop_save_document, nor any mention of prerequisites such as having an open/active document. The agent must infer the use case entirely from the name.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not say what happens when no selection is active, whether the operation is undoable, how it interacts with the selection's hard/soft edge, or what the returned result contains, despite being a mutation of document 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?

One compact sentence with the effect and its unit front-loaded; nothing is wasted. It is terse enough that a bit more behavioral context could have been added without bloat.

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 output schema exists, so return values need no explanation, and a one-parameter tool does not require much. Still, for an unannotated mutation tool the description leaves the preconditions and result of feathering unaddressed.

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

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

Schema coverage is 0%, so the description must compensate for the single 'radius' parameter. It adds the unit ('pixels'), which the schema does not, but omits any bounds, sign, or default expectations (e.g., Photoshop's typical non-negative range).

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 ('feather') plus resource ('edge of the active selection') and the effect unit ('by radius pixels'). It is clear what the tool does, but it does not distinguish itself from closely related siblings like photoshop_expand_selection or photoshop_contract_selection, which also alter selection geometry.

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

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

No when-to-use or when-not-to-use guidance and no alternatives named. The phrase 'active selection' weakly implies a selection must already exist, but the description never states the prerequisite or the sibling choice (expand/contract for hard edges vs feather for soft edges).

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the end state (one background layer), but does not state that this is destructive/irreversible, whether hidden layers are included, or whether it depends on the document being in RGB/unsupported modes. Those gaps matter for a destructive document mutation.

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

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

A single front-loaded sentence with no filler. It states exactly what happens and stops, which is the right size for a zero-parameter 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?

An output schema exists, so return values need not be explained, and there are no parameters to document. However, for a destructive, irreversible-sounding operation with no annotations, the description should minimally flag the destructive nature of the action, which it omits.

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?

Zero parameters, so the baseline is 4. The description adds nothing beyond the schema, but there is nothing to add, and the schema description coverage is 100%.

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

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

Specific verb ('flatten') + resource ('all layers') with an explicit outcome ('into a single background layer'). An agent can distinguish this from the sibling photoshop_merge_visible_layers, which only merges visible layers rather than flattening all of 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 when-to-use guidance, no prerequisites, and no mention of the obvious alternative photoshop_merge_visible_layers, which is the closest sibling and the key routing decision for an agent. Usage is only inferable from the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. 'Autonomously triggers' hints at an external Firefly call but says nothing about credit/network requirements, that the operation replaces the selected pixels (destructive), or that it may run asynchronously despite the wait_completion parameter.

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 or repetition. It is efficient, though the brevity here reflects under-specification rather than deliberate 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?

An output schema exists, so return values needn't be described, but for a prompt-driven, non-idempotent generation tool with zero annotations and 0% parameter coverage the description is far too thin. It omits the prompt requirement, the async/wait semantics, and any prerequisite about having an active selection.

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 not. Neither key parameter is explained: the prompt parameter (no mention that generation is prompt-driven or that it defaults to empty) and wait_completion (no mention of blocking vs async behavior). Only the implicit 'active selection' context is added.

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

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

States a specific verb (triggers) and resource (Adobe Firefly Generative Fill) and scopes it to the active selection, which distinguishes it from photoshop_generative_remove_ai and photoshop_content_aware_fill reasonably well. It stops short of explicitly naming how it differs from those adjacent siblings, so it falls short of a 5.

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

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

No when-to-use guidance is given. It does not tell the agent to prefer this over photoshop_content_aware_fill, nor that photoshop_generative_remove_ai is the right sibling for removing objects, nor that a selection must already exist. Usage is only implied by the phrase 'active 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses the AI engine (Firefly) and that removal is autonomous, but says nothing about whether it requires an active selection/mask, whether it mutates the current layer destructively, permission/network requirements for Firefly, or latency. For a destructive image-editing mutation tool, this is a notable 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, efficient sentence that is front-loaded with the action and resource. No waste.

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

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

With no annotations, an opaque nested 'regions' parameter, zero schema coverage, and sibling tools that overlap in function, the one-line description is not sufficient for an agent to call this accurately. The presence of an output schema slightly reduces the burden on return-value description but does not offset the missing input and behavioral detail.

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 2 parameters, one required and nested (regions as array of integer arrays). The description adds no meaning about the format of 'regions' (coordinates? bounding boxes? polygon points?) or what feather_px controls. It fails to compensate for the complete lack of schema documentation.

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

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

States a specific verb (removes) and resource (regions) plus the underlying engine (Adobe Firefly Generative Fill). It is largely distinguishable from siblings like photoshop_content_aware_fill, though it doesn't explicitly contrast with the sibling photoshop_generative_fill_ai or photoshop_smart_remove_distractions.

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

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

No guidance on when to use this over alternatives like photoshop_content_aware_fill or photoshop_smart_remove_distractions, which occupy adjacent use cases (removing/distraction removal). Only implied usage from the verb 'removes'.

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

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

With no annotations, the description carries the full disclosure burden. It usefully states the tool acts on the active document and requires no arguments, but says nothing about failure behavior (e.g., no document open) or permission/auth needs for a read against a live Photoshop instance.

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

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

One sentence, front-loaded with the verb and resource, with the field list in a compact parenthetical. No filler or redundancy.

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

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

An output schema exists, so return values need no explanation, and the zero-parameter signature is fully covered by the single sentence. The only gap is the read-only/error semantics left unstated, which is minor for such a simple inspection 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?

Zero parameters, so there is no schema surface to compensate for; baseline is 4. The description still adds value by naming the categories of metadata returned, which is beyond what an empty schema conveys.

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

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

Names a specific verb (Get) and resource (metadata about the currently active Photoshop document) and enumerates the returned fields (dimensions, color mode, layer count, active layer). It implicitly separates itself from photoshop_list_documents by scoping to the 'currently active' document, though it never names 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?

Usage is only implied – an agent infers it should call this when it needs document state before acting. There is no explicit 'use this before X' guidance and no distinction from photoshop_list_documents or photoshop_get_layers, both of which overlap in the metadata space.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does disclose the read-only nature and the scope (active document), but it does not state what happens if there is no active document, whether the operation is safe/non-mutating, or any rate limits. It stops short of explaining the return shape even though an output schema exists.

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, well-structured sentence with no filler. It front-loads the action and then enumerates the returned fields efficiently. Every word earns its place.

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

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

Given the tool's simplicity (no parameters, has output schema), the description is largely complete for its scope. It clearly states what is returned, and the output schema covers the return format. The only minor gap is not explicitly stating that the operation is read-only, which would be useful context absent annotations.

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

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

There are zero input parameters, so the baseline is 4. The description correctly does not need to explain parameters, and it does not waste space on them. The slight deduction is for not leveraging the description to clarify the tool has no required inputs, which could help an agent confirm invocation.

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

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

The description states a specific verb ('Get') and resource ('layers') and enumerates exactly which layer attributes are returned (list, visibility, opacity, blend modes, pixel bounds). It is clearly distinguishable from read siblings like photoshop_get_document_info, though it does not name an alternative.

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

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

The description implies that this is a read-only inspection and that it operates on 'all layers in the active document', which implicitly sets context (no layer selection needed). However, there is no explicit when-to-use or when-not-to-use guidance, and no mention of alternatives such as photoshop_get_document_info for document-level metadata.

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 return format but does not state that the operation is read-only, whether it requires an active selection, or what happens if no selection exists. With zero annotation coverage, this is a notable 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?

One sentence, front-loaded with verb and resource, and no wasted words. It efficiently conveys the essential 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 simple zero-param getter with an output schema, the description covers purpose and return format. It omits prerequisites (e.g., an active selection) and error behavior, but the output schema can carry return details, so it is mostly complete.

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

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

The tool takes no parameters (schema coverage 100% for zero params), so there is nothing for the description to clarify. Baseline 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 (Get) and resource (pixel bounds of the current selection) and even specifies the returned tuple format [left, top, right, bottom]. This is unambiguous and clearly distinguishes it from sibling selection-manipulation tools.

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

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

No explicit when-to-use or alternative guidance is given, but the phrase 'of the current selection' implies the tool is for querying an existing selection's extent. Usage is implicit rather than documented.

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

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

With no annotations, the description carries the full behavioral burden and does well: it describes a multi-step internal process (AI selection, layer placement, haze gradient, relighting), which informs the agent about side effects and complexity. It doesn't mention permissions, performance cost, or reversibility, but the process transparency is strong for a creative tool.

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

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

The description is front-loaded with a clear purpose statement followed by numbered steps and a parameter list. It is a bit verbose (the step list could be trimmed), but every sentence conveys useful information and the structure is easy to parse.

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

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

Given a 4-parameter tool with no annotations and an output schema (which handles return values), the description provides sufficient process and parameter detail for an agent to invoke correctly. The only gap is usage guidance relative to alternatives, which is covered under usage_guidelines.

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 supply parameter meaning. It explains each parameter's role and gives ranges/defaults for opacity parameters ('Opacity percentage (0-100)'), and clarifies 'warm_foreground' as warming non-sky foreground subjects. This adds substantial value beyond the bare-named schema properties.

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

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

The description clearly states a specific verb ('replaces and harmonizes') and resource ('sky'), then enumerates the exact pipeline steps. It is distinguishable from siblings like photoshop_select_sky (which only selects) and photoshop_match_lighting_and_tone (generic relighting).

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 what the tool does but provides no guidance on when to use it versus alternatives such as photoshop_select_sky combined with manual compositing, or photoshop_match_lighting_and_tone. No context, 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?

No annotations are provided, so the description carries the full behavioral burden. It mentions the target ('active layer'), which implies a prerequisite, but it does not disclose whether the operation is destructive, whether it is reversible via undo, what happens if no layer is active, or whether it affects layer masks or selections.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and the target, which is appropriate for a zero-parameter command.

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 output schema exists, so return values need not be explained. However, with no annotations and no usage guidance, the description is only minimally complete for a mutation tool: it names the target layer but omits behavioral details such as reversibility, prerequisites, and side 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?

The tool has zero parameters, so per the scoring guidance the baseline is 4. The description does not introduce parameter semantics beyond what the empty schema already communicates.

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: 'Invert colors' of the 'active layer.' It is clear enough to distinguish from unrelated siblings, but it does not explicitly differentiate itself from the similarly named sibling photoshop_invert_selection, which is a closely related alternative.

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

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

There is no guidance on when to use this tool versus alternatives such as photoshop_invert_selection or photoshop_desaturate. The description only states what the tool does, leaving the agent to infer usage context and exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says what happens to 'the active selection' but not what occurs when no selection exists, whether the operation is undoable, or which document it affects — meaningful gaps for a state-mutating tool with zero annotation coverage.

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

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

A single, front-loaded sentence with no filler. Every word earns its place and the action is immediately clear.

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 output schema exists so return values need no explanation, and the operation is simple with no parameters. However, with no annotations and no stated precondition or failure behavior, the description is only minimally adequate for a tool that mutates editor 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?

The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies since no parameter semantics are needed.

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

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

States a specific verb ('Invert') and resource ('the active selection'), which cleanly distinguishes it from the sibling photoshop_invert (color inversion). However, it does not explicitly name that sibling or otherwise contrast itself, so sibling differentiation is only implied by the object noun.

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 alternatives such as photoshop_deselect or photoshop_select_all, and no stated precondition (e.g., an existing selection is required). The agent must infer all usage context.

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

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

No annotations are provided, so the description carries the burden. 'List' strongly implies a read-only, side-effect-free operation, but the description never states this explicitly, nor does it mention whether the result is limited to the active document or all open ones beyond the phrase 'all open documents'. For a zero-parameter read tool the risk is low, so a 3 is fair.

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 verb and resource with no filler. Every clause (open documents, IDs and names) 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?

An output schema exists, so return values needn't be explained, yet the description helpfully notes that IDs and names are returned. For a zero-param, low-complexity listing tool this is nearly sufficient; the only gap is routing versus photoshop_get_document_info.

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

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

The tool takes zero parameters, so the baseline is 4 per the rubric. There is nothing for the description to disambiguate, and it correctly avoids inventing options that don't exist.

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

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

States a specific verb (List) and resource (open documents in Photoshop) plus the returned fields (IDs and names). It's clearly distinguishable from most siblings like photoshop_delete_layer or photoshop_flatten_image, but it doesn't address the potential overlap with photoshop_get_document_info, which also surfaces document metadata.

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

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

Usage is implied by the name and description — an agent can infer this is the entry point for enumerating open documents before acting on one. However, there is no explicit when-to-use statement and no mention of the get_document_info alternative for detailed per-document metadata.

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 burden. It discloses global scope ('entire composite') but nothing about whether the operation is destructive, applies to a layer or the merged result, respects selections, or can be undone. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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 output schema exists, so return values are covered, but with no annotations, undocumented parameters, and no usage context, the definition leaves the agent short of what it needs to invoke this tool confidently.

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

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

Schema description coverage is 0% for all three parameters. The description's mention of 'contrast' and 'color vibrance' loosely hints at contrast_amount and saturation_boost but gives no ranges, units, or defaults, and target_mood (with its default of 'vibrant_daylight') is never referenced 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 (harmonizes) and the resources it affects (lighting, contrast, color vibrance) with an explicit scope of 'the entire composite'. This distinguishes it reasonably from per-channel siblings like adjust_brightness_contrast, though it never names those alternatives.

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

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

No when-to-use guidance, no prerequisites, and no mention of when this should be preferred over adjust_brightness_contrast, auto_contrast, auto_levels, or harmonize_sky. The agent must infer usage 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 behavioral burden. It omits that this is a destructive, structure-destroying operation on the layer stack, whether it can be undone, and what happens to hidden layers — significant gaps for a mutation tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler, which is appropriate for a no-argument tool. It is arguably too terse given the missing usage and destructive-behavior context, but there is no wasted text.

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

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

The output schema exists, so return values need not be explained, and there are no parameters to document. Still, the description leaves the destructive nature and the visible-vs-all-layers distinction unstated, which is exactly the context an agent needs before collapsing a layer stack.

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

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

The tool takes zero parameters, so per the baseline there is nothing for the description to clarify; the schema fully covers the (empty) input contract. No parameter-level value could be added.

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

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

States a specific verb and resource ('merge all visible layers into one composite layer'), so the action is unambiguous. However, it does not differentiate itself from the closely related sibling photoshop_flatten_image, which an agent could easily confuse with this one.

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

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

No guidance on when to use this versus alternatives — most notably photoshop_flatten_image, which also collapses layers. The description never explains the visible-only scoping constraint that is the whole point of choosing this tool over flatten.

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 description must carry full behavioral burden. It states the action clearly and the source (filesystem) and destination (Photoshop). But it doesn't disclose whether this creates a new document, whether it fails on unsupported formats, what permissions are needed, or error behavior.

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

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

Single concise sentence that front-loads the action and key context. No wasted words.

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

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

Output schema exists, so return value details aren't needed. For a simple file-opening tool with one parameter, the description covers the essential purpose. It could add minor details about supported formats or document creation behavior, but is largely complete for an agent to invoke 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?

Only one parameter, and the description says 'from the filesystem' which implies file_path is a filesystem path (vs URL or other reference). Schema description coverage is 0% but with only one clear parameter, the description provides adequate semantic framing.

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 resource (image file from filesystem into Photoshop). Distinguishes itself from siblings like photoshop_list_documents and photoshop_create_layer since it is the only tool that opens files from disk into the application.

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

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

Usage is implied by the name and description but no explicit when-to-use vs alternatives guidance. For example, it doesn't clarify relationship to photoshop_list_documents or whether it opens into a new document vs active document. But given the tool's specialized nature among siblings, basic context is clear.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses nothing beyond the basic action: no mention that it mutates document state, what happens when the redo stack is empty, whether it operates on the active document, or any interaction with the undo history.

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

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

A single short sentence with the action front-loaded and zero filler. Nothing could be removed without losing meaning.

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

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

For a zero-parameter tool with an output schema, the description need not explain return values, and the core action is covered. The one remaining gap is the dependency on a prior undo and the empty-redo-stack behavior, which would help an agent avoid a pointless 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is no parameter semantics to add, and the description correctly makes no claims about arguments.

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

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

States a specific verb (Redo) and a specific resource (the last undone action in Photoshop), so an agent knows exactly what it does. However, it never names or references the sibling photoshop_undo, which is the tool an agent must reason about to decide 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?

Usage is only implied: an agent can infer this should follow an undo, but the description never states when to use it, when not to (e.g., nothing has been undone), or how it relates to photoshop_undo. No prerequisites or alternatives 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether saving overwrites the original file, requires an open document, prompts for format when a new path is given, or what happens on failure. For a mutation tool with zero annotation coverage this is a notable 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?

One front-loaded sentence with no wasted words. It is efficient, though the brevity contributes to the behavioral gaps elsewhere.

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

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

An output schema exists, so return values need not be explained. However, for a document-mutating tool with no annotations, the description omits essential context such as overwrite semantics, format handling, and prerequisites, leaving it only minimally sufficient.

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

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

Schema coverage is 0%, so the description must compensate. It does: it tells the agent file_path is optional and represents a 'new path', correctly clarifying the in-place-save default versus save-as behavior that the schema alone (nullable string, default null) does not convey.

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

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

States a specific verb and resource ('Save the active document') and distinguishes itself from photoshop_export_as by scope (active document in place vs export). Nothing beyond that differentiates it explicitly from siblings, but the 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?

The phrase 'optionally specifying a new path' implies a save-in-place default, but there is no explicit when-to-use guidance versus photoshop_export_as (which also writes to disk in another format). Usage is inferable but not stated.

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

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

With no annotations present, the description carries the full behavioral burden. It states the action but does not disclose that this replaces any existing selection, whether it requires an open document or active layer, or any other side effect — meaningful omissions for a selection-state mutation.

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

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

A single short sentence with the action front-loaded and zero filler. Nothing could be removed without losing the 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?

An output schema exists, so return values need not be described, and the zero-parameter surface is fully covered. The only gap is behavioral context about how this interacts with an existing selection.

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 and the schema coverage is 100%, so there is nothing for the description to clarify; a 4 is the appropriate baseline for a no-parameter 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 specific verb and resource ('Select entire canvas area'), and the scope word 'entire' implicitly separates it from siblings like photoshop_select_rectangle and photoshop_select_ellipse. It does not, however, explicitly name or contrast with any alternative, 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?

There is no guidance on when to use this versus photoshop_select_rectangle, photoshop_select_ellipse, or its inverse photoshop_deselect. Usage can only be inferred from the tool name; nothing about prerequisites or sequencing is stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that feathering is optional, but says nothing about the coordinate frame/units, whether the current selection is replaced, or which document/layer is affected. For a selection-mutating 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 front-loaded sentence with no waste, but it is terse to the point of under-specification rather than being right-sized for a 5-parameter tool with an output schema.

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

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

An output schema exists, so return values need not be described. However, for a selection-mutating tool with zero annotation coverage and 0% schema description coverage, the description leaves coordinate semantics and selection-state behavior completely 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% on 5 parameters, and the description compensates for almost none of them: left/top/right/bottom are never explained (bounding-box corners in pixels?), and 'optional feathering' merely restates that the schema field is not required with a default of 0.

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 ('Create an elliptical selection'), which is more informative than the bare tool name. The distinction from photoshop_select_rectangle is implied by 'elliptical' but never made explicit, so it falls short of full sibling differentiation.

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

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

There is no guidance on when to use this versus photoshop_select_rectangle, photoshop_select_all, or photoshop_deselect, and no note on whether an existing selection is replaced or added to. Only the elliptical shape is implied as the selection criterion.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the immediate effect ('make it active') but omits critical details such as what happens if the name is not found, whether it works across documents, or whether it clears previous selections.

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 concise sentence that front-loads the action and outcome. Every word earns its place with no redundancy.

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

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

For a simple one-parameter tool with an output schema, the description is almost adequate. However, without annotations and with zero parameter description, it leaves key behavioral questions unanswered, missing full completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It names the parameter's purpose ('by name') but does not specify whether the name is case-sensitive, must match exactly, or supports wildcards. Modest value added over the schema's bare 'name' field.

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 ('Select') and resource ('a layer by name') and clarifies the outcome ('make it active'). It is clear, though it does not differentiate this tool from similar selection siblings like photoshop_select_all.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., layer must exist) or refer to any sibling tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says a rectangular selection is created and feathering is optional, but omits whether an existing selection is replaced, coordinate origin, units, feather units, and whether an active Photoshop document 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 that states the action, resource, coordinate order, and optional parameter with no wasted words.

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

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

Although an output schema exists and return values need not be described, the combination of no annotations, 0% schema description coverage, and a mutation-style selection tool means critical invocation details are missing, including coordinate system, selection interaction, and feather units.

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%, but the description compensates partially by stating the coordinate order [left, top, right, bottom] and noting that feathering is optional. It still leaves units, coordinate space, inclusive/exclusive bounds, and feather semantics unexplained.

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

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

States a specific verb ('Create') and resource ('rectangular pixel selection'), and even gives the coordinate order [left, top, right, bottom]. However, it does not explicitly distinguish this tool from sibling selection tools such as photoshop_select_ellipse or explain when a rectangular selection is preferable.

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

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

Provides no when-to-use guidance, no prerequisites (e.g., active document), and no alternatives. The agent must infer usage entirely from the tool name and 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?

With no annotations, the description carries the full behavioral burden, and it only notes that detection is AI-based and automatic. It does not say whether the result replaces an existing selection, what happens when no sky is detected, whether it needs an active document or internet access, or how long it takes.

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, restatement of the title, or redundant phrasing. 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?

An output schema exists, so return values need not be explained, and with zero parameters the schema side is trivially covered. However, for a no-annotation AI tool the description omits failure behavior (no sky found) and whether the operation is destructive to an existing selection, leaving real gaps.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param tool is 4. The single sentence does not waste space inventing parameter semantics that do not exist.

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

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

States a specific verb ('detect and select') and resource ('the sky region') in one sentence, and the resource itself distinguishes it from siblings like photoshop_select_subject, photoshop_select_all, and photoshop_select_rectangle. An agent can route to it without opening any 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?

Usage is only implied: the description tells you what it selects, so an agent can infer it is for sky-targeted selections, but it names no alternatives (e.g. select_subject, harmonize_sky) and gives no preconditions such as requiring an open document containing sky. No explicit 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 carries the full behavioral burden and does not meet it. It does not say whether the operation replaces any existing selection, whether it requires a raster/pixel layer or works on smart objects, what happens when no subject is detected, or whether the operation is undoable.

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 its mechanism are stated immediately and nothing needs trimming.

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 output schema exists, so return values need not be explained, and one optional boolean parameter is a small surface. Still, for an unannotated AI-driven mutation of the selection state, the description omits the behavioral facts (selection replacement, layer requirements, failure mode) an agent would want 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 description coverage is 0% and the single parameter (sample_all_layers, boolean, default true) is never mentioned. The description adds no meaning about what sampling all layers does versus sampling only the active layer, so an agent must guess from the parameter name alone.

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

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

States a specific verb+resource: it detects and selects the primary subject(s), and names the underlying mechanism (Adobe Sensei AI). That clearly separates it from geometric selectors like photoshop_select_rectangle or photoshop_select_all, though it offers no explicit differentiation from the very similar photoshop_select_sky.

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

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

Usage is only implied by the name: an agent can infer you call this when you want the main subject isolated rather than a geometric or sky selection. There is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as photoshop_select_sky.

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 0-100 range, which is useful, but says nothing about permission needs, what happens if the named layer is missing or duplicated, or whether the change is undoable. For a mutation tool with zero annotation coverage this is a notable 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?

One tight sentence with the action front-loaded and the constraint parenthetical immediately following. Nothing is wasted.

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

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

An output schema exists, so return values need no explanation, and the tool is simple with only two required params. Still, failure modes and the active-document precondition are absent, leaving the agent to guess at edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning for both params: opacity is a percentage bounded 0-100, and name is a by-name layer identifier rather than an index or ID. However, it omits case sensitivity, duplicate-name behavior, and whether decimals are accepted.

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 (set), resource (layer opacity), and the identifying key (by name), which cleanly distinguishes it from siblings like photoshop_set_layer_visibility and photoshop_select_layer_by_name. It does not explicitly name a sibling it must not be confused with, but the purpose is unambiguous.

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

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

The description gives no when-to-use context, no prerequisites (e.g., a layer must exist or be selected), and no routing guidance relative to the many layer-related siblings. The agent must infer all of this.

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 falls short: it does not say what happens if the named layer does not exist, whether the change is reversible, whether it affects the active selection, or any permission requirement. Only the mutation intent is conveyed.

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

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

A single short sentence with the action and target front-loaded; nothing is wasted, though it is terse to the point of under-specification.

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

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

An output schema exists, so return values need not be described. However, for a mutation tool with zero annotation coverage and undocumented parameters, the description leaves out behavioral caveats an agent would want 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 description coverage is 0%, so the description must compensate. It does map both parameters reasonably ('by name' -> name, 'show or hide' -> visible boolean), but adds no format details such as whether the name is case-sensitive or must match exactly.

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 pair (show/hide) and resource (layer), plus the lookup key ('by name'). This clearly separates it from siblings like photoshop_set_layer_opacity, though it does not name any sibling explicitly.

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

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

There is no guidance on when to use this versus alternatives such as photoshop_set_layer_opacity, nor any prerequisite (e.g., that the layer must exist). 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 does well: it discloses the non-destructive Retouch layer, that create_backup_layer preserves the original, and that expand_px exists to eliminate halo artifacts. It omits permissions, reversibility, and failure modes, but the core behavior is transparent.

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

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

Front-loads the purpose, then the mechanism, then the args. Efficient overall; the Args block restates defaults that also appear in the schema, but that redundancy is warranted given the schema has no descriptions.

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 composite removal tool with an output schema (so return values needn't be explained), the description covers purpose, underlying operations, and every parameter. Only the relationship to competing removal siblings is left 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%, so the description must compensate and does: it documents all four parameters, including the [left, top, right, bottom] pixel bounding-box format for regions and the purpose of each optional knob. This fully covers the gap left by the undescribed schema.

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

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

States a specific verb (removes) and resource (unwanted people/background distractions), and the second sentence clarifies it's a composite operation (context expansion + edge feathering + Content-Aware Fill). This distinguishes it from the raw sibling primitives, though it never names those alternatives 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 to use it by describing the bundled workflow (a one-shot smart removal), but gives no explicit when/when-not guidance against siblings like photoshop_generative_remove_ai or photoshop_content_aware_fill. An agent must infer the choice.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that one action is undone, but says nothing about the history stack, whether multiple undos are possible, side effects, or what happens when there is nothing to undo.

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

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

A single sentence with no wasted words, front-loading the core action. It is appropriately sized for a simple, no-argument tool.

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

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

Given the low complexity and the presence of an output schema, the description need not explain return values. However, with no annotations and only a restatement of the tool name, it omits useful behavioral context (single-step scope, no-op behavior) that would help an agent invoke it correctly.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The description correctly adds no parameter information, matching the baseline expectation for a parameterless 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?

The description names a specific verb (Undo) and scoped resource (the last action in Photoshop). It is clear and unambiguous, but it does not explicitly differentiate itself from the sibling photoshop_redo or other editing 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 guidance on when to use this tool versus alternatives such as photoshop_redo, nor any context about prerequisites (e.g., an open document) or whether multiple undo steps are supported. The usage is only implied by the tool name.

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