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 omits the most important traits: these events can mutate the document (make/set/select/delete), there is no disclosure of destructive risk, permission requirements, or failure behavior. The descriptor format is explained, but that is parameter mechanics, not behavioral disclosure.

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

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

The content is dense but front-loaded: the core action comes first, then the descriptor grammar, then the routing rule. Every clause earns its place, though the parenthetical grammar dump makes the middle heavy for a reader skimming for intent.

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

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

For a complex tool with nested objects, no output schema, and no annotations, the description covers the descriptor input shape but leaves return values, error modes, and mutation risk undescribed. Adequate as an escape hatch, but not complete enough to call it confidently without trial.

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

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

Schema coverage is only 50%, but the description compensates by explaining the descriptor grammar ({_c}, {_u}, {_e}, {_i}, {_ref}) for the otherwise empty descriptor param and by clarifying get:[referencia] semantics. It still does not explain exact, or the doc/layer formats, which the schema itself covers.

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 ("Ejecuta cualquier evento de Photoshop con un descriptor en JSON") and explicitly positions itself as the fallback for operations with no dedicated ps_* tool, which differentiates it from the 40+ sibling tools. However, "cualquier evento" is deliberately broad, so an agent must still infer the concrete capabilities from the descriptor grammar rather than from a described scope.

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

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

The final sentence gives a clear routing rule: this is the escape hatch for advanced operations that lack their own ps_* tool, implying agents should prefer specific siblings first. It does not name explicit when-not conditions or list which ps_* tools cover which tasks, but the fallback framing is actionable.

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

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

No annotations are provided, so the description carries the full burden. It discloses the non-destructive nature and the clip=true behavior of limiting the effect to the layer below, which is genuine behavioral context, but it omits auth/permission needs, error behavior, and reversibility 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?

Purpose is front-loaded in the first clause, followed by a compact reference block. The long type/params list is dense but each entry earns its place given the opaque params schema.

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

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

For an 18-parameter mutation tool with no annotations and no output schema, the description covers the most complex parameter well but leaves many behaviors (return values, defaults, failure modes, permissions) undocumented.

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

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

Schema description coverage is only 44%, but the description compensates strongly for the critical opaque 'params' object by detailing the expected key structure for every adjustment type (e.g. curves{points,channel}, selectiveColor{colors}). This goes well beyond the schema, which only declares params as a free-form object.

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: 'Crea una capa de ajuste no destructiva', and enumerates the adjustment types it supports. An agent can tell this creates an adjustment layer rather than a plain layer. It does not explicitly name a sibling alternative, but the resource 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 never says when to use this tool versus alternatives like ps_create_layer or ps_set_layer, nor any prerequisites. Usage is only implied by the type enumeration, leaving the agent to infer the context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says a vector shape is created, but does not disclose mutation side effects, required document context, layer insertion behavior, permissions, defaults, or reversibility.

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

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

The description is a single dense sentence, front-loaded with the creation verb and shape types. It contains no filler, though it is quite terse for a 30-parameter 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 30 parameters, no annotations, no output schema, and only 37% schema description coverage, the description is too sparse. It overviews main capabilities but leaves many parameter semantics, defaults, and return behavior unexplained.

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

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

Schema description coverage is low at 37%, so the description should compensate. It usefully explains shape type options, radius formats, fill modes, stroke attributes, effects, blend, and opacity, but many parameters such as x, y, width, height, parent, anchor, visible, and rotation remain undocumented.

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

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

The description gives a specific verb and resource: 'Crea una forma vectorial' and enumerates the supported shape types. This clearly distinguishes it from sibling creation tools such as ps_add_text, ps_add_adjustment, or ps_create_layer.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives or when another tool should be preferred. Usage is only implied by the verb 'creates'.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that this creates a new layer and that layer effects can be attached in the same call ('Admite efectos en la misma llamada'), which is useful. However it says nothing about permissions, side effects on existing layers, or failure/reversibility behavior expected of 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?

Front-loads the core purpose, then layers in usage modes, positioning, and effects in four tight clauses with no filler. Dense but each clause carries signal; slightly compressed wording is the only thing keeping it from a 5.

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

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

For a complex tool with 25 parameters, nested objects, and only 48% schema coverage and no output schema, the description covers the main mechanics but leaves a large surface of parameters and layer-placement options undocumented. Adequate for the core call, incomplete for the full parameter set.

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

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

Schema coverage is low (48%) across 25 parameters, so the description should compensate more than it does. It does clarify the highest-value semantics ('style' vs 'runs', x,y+anchor positioning, box for paragraph text), but the many remaining parameters (opacity, blend, label, parent, doc, language) rely on the schema 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 and resource ('Crea una capa de texto') and immediately scopes it with 'control tipográfico completo'. The verb 'crea' cleanly distinguishes this from the sibling editing/inspection tools (ps_edit_text, ps_text_info) without needing to name them.

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

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

Gives clear operational context on the two modes ('style' for a single style vs 'runs' for multiple spans, plus box={width,height} for paragraph text), which tells the agent when each shape of call is appropriate. No explicit exclusions or named alternatives against siblings, keeping it short of a 5.

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 doesn't state whether this mutates layer positions irreversibly, what happens when 'to' is omitted vs 'artboard', whether it requires a selection, or whether distribution needs three or more layers. It also doesn't disclose that 'to' and 'artboard' interact (artboard target implies a specific artboard 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?

One compact sentence that front-loads the verb and enumerates targets. No filler, though it sacrifices necessary detail for brevity in a way that hurts the other dimensions.

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

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

Seven parameters, no annotations, no output schema, and only 29% schema coverage. The description does not explain distribute semantics, the 'to' vs 'artboard' pair, or the layer reference format the schema partially documents. An agent could easily call it wrong (e.g., setting 'distribute' without enough layers, or omitting 'to' unintentionally).

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

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

Schema description coverage is only 29% (only 'doc', 'layers', and 'artboard' have inline descriptions). The description mentions the rectangle form {x,y,width,height}, which adds a bit of meaning, but it says nothing about 'distribute', 'artboard', 'layers', or the relationship between 'to' and 'artboard'. For 7 params at 29% coverage the description under-compensates.

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

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

States specific operations (align layers to canvas/first/artboard/rect, distribute h/v) with the resource being layers, but is completely generic among 40+ siblings and never differentiates itself from related tools like ps_set_layer. An agent can infer the tool aligns/distributes, but gets no signal of when it beats neighbors.

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 alternative tool is mentioned. The description only says what the tool does, leaving the agent to guess between this and ps_set_layer, ps_group, or transform-oriented siblings.

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

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

With no annotations, the description carries the full burden, and it usefully discloses that execution stops at the first error and reports which one, plus the single-history-step grouping. It does not say whether already-applied steps persist on failure, whether the batch is atomic/undoable as one unit, or how the failure is reported back.

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

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

Front-loaded with the core behavior, then the element format, then the use case and error semantics. The long tool enumeration is necessary rather than filler, though the single dense paragraph is slightly hard to scan.

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

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

For a no-annotation, no-output-schema tool with a nested steps array, the description covers element format, allowed tools, use case, and failure behavior. Remaining gaps are partial-failure/rollback semantics and what the tool returns, which matter for a multi-mutation batch.

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 67% and the schema's 'steps[].tool' is a bare string with no enum. The description compensates substantially by enumerating the accepted tool values and stating that args use the same parameters as ps_<tool>, which is the key mapping an agent needs.

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 scope: it runs multiple tools in order and collapses them into ONE history step. The enumerated tool list and the '{tool, args}' element shape make it unmistakable versus the individual ps_<tool> siblings.

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

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

"Ideal para armar una composición completa" gives a clear usage context, and the tool list implies the alternative (calling each ps_ tool separately). It never states when NOT to use it, e.g. when later steps need results from earlier 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. It discloses that the operation reads style attributes and optionally persists them under a name (a state-changing side effect), which is useful. However it does not cover permissions, what happens on name collision, or the return shape of the recipe, leaving clear gaps.

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

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

Two tight sentences with the core action front-loaded, followed by the persistence behavior. No filler, though the effects:{recipe} reference assumes prior knowledge.

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 read/capture tool with a fully documented schema and no output schema, the description conveys the essential behavior (what is read, the recipe output, and optional saving). It stops short of clarifying sibling relationships and edge cases, so not 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?

Schema description coverage is 100%, so the schema already documents `doc`, `name`, and `layer`. The description mainly restates the `name` behavior already in the schema and adds no syntax or format detail beyond it, matching the baseline 3.

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

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

States a specific verb (lee/captura) and resource (efectos, mezcla, relleno, tipografía de una capa), and explains it produces a reusable recipe. It does not distinguish itself from the similar-sounding sibling ps_style_get or ps_style_analyze, so a 4 rather than 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?

It implies usage by noting that passing `name` saves the recipe into the active style for later use via effects:{recipe}, which is helpful context. But it never says when to use this instead of ps_style_get, ps_style_list, or ps_style_analyze, so the guidance is only implicit.

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

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

No annotations, so the description carries the burden. It discloses the critical behavior that closing discards unsaved changes unless save=true, which is important. But it doesn't mention if the document is removed from the workspace, whether it prompts confirmation, or what happens to the application 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?

Single short sentence, front-loaded with the core action and the key conditional. No wasted words, though it could be slightly more informative without excess.

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 2-param tool with no annotations and no output schema, the description covers the main action and the save behavior. However, it lacks details on default document handling, error conditions (e.g., closing last document), or return values.

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

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

Schema coverage is 50%; the doc parameter has a description in schema but save does not. The description clarifies save's effect ('sin guardar salvo save=true'), adding meaning beyond the bare boolean, but does not explain doc's default beyond what the schema already says.

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 (cerrar) and resource (documento), which is clear. However it does not differentiate from other closing/terminating operations among siblings like ps_save or ps_open, though 'close' 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 'sin guardar salvo save=true' clause implies when to use save=true, giving implied usage guidance. But there is no explicit when-to-use vs alternatives like ps_save.

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, yet it discloses almost nothing beyond the create action. It does not state whether a document must be open/active, what happens to existing artboards, whether the operation is reversible, or what is returned.

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

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

Two tightly packed sentences with the core action front-loaded and the workflow hint second. No filler, though it is terse enough to leave 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?

For a 7-parameter mutation tool with no annotations and no output schema, the description covers purpose and workflow but does not close the parameter-coverage or behavioral gaps. Adequate but not complete.

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

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

Schema coverage is low (29% – only doc and background documented), so the description should compensate. It names the concept of each field (name, position, size, background) but adds no syntax such as x/y coordinate origin, units, or the doc default, leaving half the parameters underspecified.

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 ('Crea una mesa de trabajo (artboard)') plus the key configurable attributes (name, position, size, optional background). Clear what it does, though it does not explicitly contrast with siblings like ps_new_document.

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

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

Provides concrete usage context ('varias piezas en un mismo documento') and points to the downstream alternative workflow via ps_export mode:"artboards". Lacks explicit when-not guidance, but the intended scenario 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 hints that pixel layers can be optionally filled and that solid/gradient layers cover the whole canvas, but says nothing about required state (an open/active document), default placement (above/below/anchor interaction), defaults for name/opacity/visible/blend, or failure modes for an 18-parameter mutation tool.

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

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

A single front-loaded sentence with the verb first and zero filler; nothing is redundant. It is perhaps too terse for an 18-parameter tool, but as conciseness it is efficient and well-ordered.

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

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

For an 18-parameter, zero-required, null-annotation, no-output-schema mutation tool with only 56% schema coverage, the description is far too thin. It never explains mode selection, parameter interaction, defaults, or the effect of placement parameters, leaving significant gaps for the calling agent.

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 56% across 18 parameters, so the schema documents roughly half (doc, fill, blend, color, anchor, parent, above/below, clipped) while several parameters (x, y, kind, name, label, opacity, visible, gradient object itself) carry no description. The description adds only marginal semantics – that fills are 'canvas-wide' and pixel layers 'optionally filled' – and does not compensate for the undocumented params.

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

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

States a specific verb (creates) plus the three distinct resources it can produce: pixel layer (optionally filled), group, and solid/gradient fill layer spanning the canvas. This is clear enough to distinguish from most siblings, though the group-creation mode overlaps with sibling ps_group, which the description does not acknowledge.

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 exclusions, and no routing to alternatives such as ps_group for grouping existing layers, ps_fill for filling, or ps_add_shape for vector work. The 'kind' enum implies modes but the description never says which situations call for which mode.

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. 'Borra' implies a destructive, likely irreversible mutation, but the description never states that deletion cannot be undone, whether it applies to a history step, or what happens if all layers or a locked/background layer are targeted.

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 action front-loaded, which is structurally clean. However, the brevity comes at the cost of the specification an agent needs, so it reads as under-specified rather than genuinely efficient.

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

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

For a destructive mutation tool with no annotations, no output schema, and partial parameter documentation, the description is far too thin. It should at minimum warn about irreversibility and clarify how the two layer-accepting parameters interact.

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

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

Schema description coverage is 67%: `doc` and `layer` have inline descriptions (including the {id|name|path|index|nth} form), but the `layers` array has none. The description adds nothing beyond restating 'one or several layers' and does not clarify the relationship or precedence between `layer` and `layers`.

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 ('Borra una o varias capas'), and the plural scope correctly signals that either the single `layer` or the `layers` array is accepted. It does not differentiate itself from neighboring layer tools such as ps_duplicate_layer, ps_merge_rasterize or ps_group, which an agent must distinguish among.

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 use this tool versus alternatives like ps_merge_rasterize (which also removes layers) or ps_close (which discards a document). No prerequisites, no mention of whether the document must be open, and no guidance on choosing `layer` vs `layers`.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It clearly implies a read-only inspection of document settings and lists the returned categories, but it never explicitly confirms it is non-destructive, requires no special permissions, or returns a structured payload.

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

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

It is a single front-loaded sentence that begins with the overall scope ('Todo lo que define el proyecto:') followed by an efficient list of contents. The listing is dense but appropriate for an info tool, with no wasted filler.

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

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

Because no output schema exists, the description must convey what is returned, and it does so comprehensively by enumerating document properties and features. It is weaker on usage, permissions, and raw-parameter effects, but those are largely covered by the 100% schema coverage.

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

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

Schema description coverage is 100%, with both doc and raw fully documented in the schema (including the default active document and raw full Photoshop descriptor). The description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description enumerates what the tool surfaces (size, resolution, mode, depth, profile, guides, artboards, channels, paths, comps, layer counts, history), making the resource clear. However, it is a noun phrase without an explicit verb like 'returns' or 'obtiene', and it does not explicitly distinguish itself from sibling info tools such as ps_layers or ps_history.

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 like ps_project_report, ps_status, or ps_layers. The only usage-like statement is the schema note that doc defaults to the active document, which is not in the description 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?

No annotations are provided, so the description carries the full behavioral burden. It states that toDocument allows cross-document duplication, but says nothing about permissions, stacking position of the copy, whether the source is altered, or mutation semantics for a write operation.

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

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

A single, front-loaded sentence with no filler; the core action and its main modifiers come first. It is efficient, though its brevity is partly under-specification rather than pure conciseness.

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

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

For an 11-parameter mutation tool with nested objects, no annotations and no output schema, this one-sentence description is too thin. It omits behavior, defaults, and most parameter meaning that the agent needs to 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?

Schema coverage is only 36%, so the description should compensate for undocumented parameters. It mentions name, offset/position and toDocument, but leaves blend, opacity, fill, anchor, doc and x/y unexplained, covering well under half the 11-parameter surface.

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

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

Names a specific verb (duplica) and resource (capa), and goes beyond a bare restatement by stating it can target the same or another document via toDocument and can apply new name/offset/position. It does not name a sibling (e.g. ps_create_layer) to differentiate, 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, no alternative named, and no exclusion. The agent must infer from the verb alone that this is the copy-layer path versus ps_create_layer, with nothing in the text routing it.

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

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

With no annotations, the description carries full behavioral burden. It states that unspecified fields are preserved, which is useful, but it omits critical details like required permissions, reversibility, and the fact that the 'layer' parameter is required. The mention of additional operations (move, rotate, effects, blend) is helpful context but lacks any caveats about their interaction with other settings.

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

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

The description is a single short sentence that is front-loaded with the core action and lists additional capabilities compactly. It avoids unnecessary words, though the parenthetical is slightly ambiguous and the list could be clearer.

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

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

Given the complexity (22 parameters, nested objects, no output schema, no annotations) and low schema coverage, the description is insufficiently complete. It omits essential information about parameter usage, required fields, and interaction with other tools, leaving an agent ill-equipped to 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?

Schema description coverage is only 32%, so the description would need to compensate, but it provides no details about any parameter. It does not explain the many options (runs, style, effects, opacity, etc.) or their formats. The high parameter count (22) makes this a significant gap.

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

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

The description says it changes the content and/or style of an existing text layer while preserving unspecified fields, and mentions additional capabilities (move, rotate, effects, blend). However, the parenthetical '(conserva lo que no indiques)' is ambiguous about merge semantics, and unlike 'ps_edit_text' the title 'Editar texto' is tautological. It does not clearly differentiate from siblings like ps_set_layer.

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

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

There is no indication of when to use this tool versus alternatives. The sentence 'También mover, rotar, efectos y mezcla' hints at breadth but doesn't specify when those capabilities should be used instead of other tools like ps_set_layer or ps_layer_style. No prerequisites or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden and does add real runtime context: the JS dialect (ES3), that `code` must be a function body that uses `return`, and which helpers are injected (A, U, AM, VZ). It still omits failure/error behavior, default timeout, and the fact that arbitrary code execution is inherently side-effecting.

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

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

The core capability and the function-body contract are front-loaded in the first two sentences, and the variable list is a compact tail. Dense and mostly waste-free, though the trailing 'Variables: ...' fragment could be integrated more cleanly.

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

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

For a tool that executes arbitrary code with no annotations, no output schema, and a nested `args` object, the description covers the invocation mechanics well but is silent on timeout defaults, error propagation, and the `history` parameter. Adequate to call it, but not complete enough for a high-risk execution tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `code` (function body, return semantics) and effectively maps `args` to the injected A variable, but leaves `history` and `timeoutSeconds` completely undefined in both schema and description, so two of four parameters remain opaque.

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 (executes) and resource (ExtendScript/JS ES3 code inside Photoshop) with scope ('acceso total a app, documentos, capas'). It is clearly distinct from data-inspection siblings like ps_status or ps_layers, but it never names the closest alternative, ps_run_script_file, so the agent must infer the code-body-vs-file distinction on its own.

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 mention of 'acceso total' signals this is the power-user escape hatch, but there is no explicit when-to-use or when-not guidance and no routing to alternatives such as ps_run_script_file, ps_action_manager, or ps_batch. An agent can infer a rough context but not the boundaries.

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

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

With no annotations the description carries the full burden. It usefully discloses non-destructive behavior ('sin tocar el documento'), which is the key safety trait for an agent. However it says nothing about output location, overwrite behavior, permissions, or file-writing side effects beyond the folder 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?

Two tight sentences with zero waste; the scope enumeration and the special 'slides' hint are both front-loaded. 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?

A 9-parameter, nested-object export tool with no output schema and low schema coverage needs more than a mode list. Format, quality, scale, crop/slices handling and where files land are all left implicit, which is a significant gap for correct invocation.

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

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

Only 33% schema coverage across 9 parameters, and the description explains essentially just 'mode' (and its 'slides' value). Key parameters (folder, name, scale, format, quality, crop, slices array) get no additional meaning from the prose, so it does little to compensate for the thin 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 (Exporta) and resource (copias/documento, artboards, grupos, slices), and even enumerates the export granularities. It is clearly an export tool and none of the siblings overlap with exporting, so no sibling differentiation is needed beyond scope.

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

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

Gives the mode choices (documento entero, artboards, grupos de nivel superior, slices) and one explicit routing condition: for a panoramic carousel use mode:'slides'. It lacks any 'when not to use' or prerequisite guidance, but the context is clear enough to select the right mode.

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 behavioral burden. It does not state whether the fill destroys existing layer content, whether it respects/affects selection state, whether it requires an active document, or what happens with overrides between color/gradient/contentAware. For a mutating raster operation 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?

Single front-loaded sentence, no waste. Sized appropriately, though brevity here contributes to the parameter/behavior gaps rather than compensating for them.

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

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

A 9-parameter mutation tool with nested objects, no annotations, no output schema, and low schema coverage. The description omits mutual exclusivity of fill modes, defaults, layer/doc targeting, and behavioral effects — inadequate for the complexity.

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

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

Schema description coverage is only 33%, and 9 parameters exist. The description only mentions color, gradient, and contentAware concept presence, but does not explain opacity, preserveTransparency, to/from, or that color vs gradient vs contentAware are mutually exclusive modes. It doesn't compensate for the coverage gap.

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

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

States a specific verb (rellena) and the resource/scope (la selección o toda la capa) plus the three fill modes. Clear what it does, though it doesn't distinguish itself from siblings like ps_filter or ps_mask beyond the fill domain.

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 which fill mode to pick under what conditions, no prerequisites. The agent must infer everything about tool selection and invocation context.

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

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

With no annotations, the description carries the full behavioral burden. It adds one genuinely useful trait — toSmart=true produces an editable smart filter — but does not disclose whether the default path is destructive, permission requirements, 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?

The core action leads, the dense filter catalog follows, and a short final clause covers the smart-filter flag. No filler sentences; every element carries selection or invocation value.

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

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

For a 5-param tool with no annotations and no output schema, the description supplies the critical filter/param mapping and the toSmart behavior. Remaining gaps (destructiveness, return value) are minor given the enumeration already answers the main 'how do I call this' question.

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

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

Schema coverage is only 40%, and the undocumented 'filter'/'params' params are exactly where the description compensates: it lists each filter name together with the exact parameter keys it expects (e.g. motionBlur{angle,distance}, cameraRaw{exposure,...}). Only the syntax/format of the params object itself is left implicit.

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

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

States a specific verb+resource ('Aplica un filtro a una capa') and then enumerates every supported filter with its parameter signature, which unambiguously separates it from sibling tools like ps_add_adjustment or ps_layer_style.

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 you call this to apply a filter, and the toSmart note hints at the editable variant. But there is no explicit when-to-use/when-not guidance and no mention of alternatives such as adjustments, so routing is left to inference.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses that it searches installed fonts and returns name/family/style, implying a read-only lookup, but says nothing about pagination, the 'limit' parameter's behavior, defaults, or what an empty query returns.

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

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

A single, front-loaded sentence with zero filler; the purpose, scope and downstream usage are all stated efficiently.

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 2-param read tool with no output schema, the description covers purpose, match fields and downstream use. The only real gap is the unexplained 'limit' parameter and lack of result-set behavior.

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

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

Schema coverage is 50%: 'query' is documented with examples in the schema, but 'limit' is undocumented in both schema and description. The description does enrich the query semantics by stating it matches on PostScript name, family and style, partially compensating.

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 (busca) and resource (fuentes instaladas), and even lists the returned attributes: PostScript name, family and style. It is clearly distinguishable from sibling tools, though it does not explicitly contrast itself with any other search/list 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?

'para usar en ps_add_text' implies the workflow context (find a font name before adding text), which is genuinely useful. However, it gives no explicit when-to-use/when-not guidance, no mention of defaults, and no 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 burden. It implies a mutation operation but does not state whether grouping is reversible, what happens to existing layers when ungrouping, required document state, or any permissions/rate concerns. For a destructive-capable structure mutation 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 concise sentence that front-loads the primary action. It is efficient, though cramming both group and ungroup into one line sacrifices clarity for brevity.

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

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

With 7 parameters, nested objects, no annotations, and no output schema, the description is insufficient. An agent cannot determine which parameters are relevant to which operation, what the tool returns, or how ungroup interacts with the layers parameter.

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

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

Schema coverage is 57%. The description names group attributes ('con nombre, modo de fusión, efectos') which maps to the name, blend, and effects parameters, but several parameters (doc, layers, opacity, ungroup) receive no description-level clarification. The schema itself documents doc, blend, layers, and effects reasonably well, which provides partial compensation.

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 dual-purpose: group layers into a named group with blend mode and effects, or ungroup a group. The verb+resource is clear ('agrupa capas', 'desagrupa un grupo'), and it is distinguishable from siblings, though the dual behavior is compressed into one sentence.

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

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

No explicit guidance on when to use grouping vs ungrouping, nor which parameters apply to which mode. The ambiguity of whether the tool groups or ungroups in a given call is left to inference.

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

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

With no annotations, the description carries the full behavioral burden. It states the operations but omits that undo/redo/revert are state-mutating and potentially destructive (revert discards later steps), whether snapshots persist, permission requirements, or what happens on undo when no history 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?

A single front-loaded sentence enumerating the modes with no filler. It is compact and readable, though the parenthetical parameter hints are terse enough to be slightly ambiguous.

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

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

For a 5-parameter, multi-mode tool with zero annotations, no output schema, and very low schema coverage, the description leaves key gaps: the undocumented 'name' parameter, default document behavior, and the destructive consequences of revert. It is not sufficient for confident invocation.

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

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

Schema coverage is only 20% (only 'doc' is documented). The description partly compensates by tying 'steps' to undo/redo and 'index' to revert, but leaves the 'name' parameter and the meaning of the action enum values (list/undo/redo/revert/snapshot semantics) only indirectly inferable.

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 concrete verbs and resources: listing history steps, undo/redo, revert to a step, and create a snapshot. An agent can tell this is the history-management tool, though it bundles four distinct modes into one dispatch tool and offers no sibling differentiation despite the large sibling list.

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

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

It implicitly maps modes to parameters ('revert con index', 'steps' for undo/redo), which hints at how to trigger each operation. However there is no explicit when-to-use/when-not guidance, no prerequisites, and no indication of defaults or ordering constraints.

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

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

With no annotations at all, the description carries the full behavioral burden. It does disclose one useful trait beyond the schema, that raw=true expands the response to the complete descriptor, which tells the agent how output size/shape changes. It omits safety profile, error behavior (missing/ambiguous layer), and any permission or document-state requirements.

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

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

Front-loaded with 'Todo sobre una capa:' followed by a dense but purposeful enumeration, and the raw flag note is placed last where a flag hint belongs. No filler sentences, though the single run-on sentence is heavy.

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

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

With no output schema, the description must carry the return-value burden, and it does so well by enumerating what the agent will receive (text runs, effects, stroke, mask, smart object, blend). The main gap is the undocumented 'exact' parameter and any note on error handling for an unresolvable layer.

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

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

Schema coverage is 50%: doc and layer are documented in the schema, while raw and exact are not. The description compensates for raw by explaining that raw=true adds the complete descriptor, but adds nothing for exact, and does not clarify the doc/layer selector semantics 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 (informs/detalles) and resource (una capa) and enumerates the exact payload: text runs with font, real size, tracking, leading, color; effects; stroke; shape radii; mask; smart object; blend. That enumeration makes the scope unmistakable. It stops short of naming a sibling (e.g. ps_layers or ps_text_info) to differentiate from, so it is clear but not fully disambiguated.

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: you call this to inspect the detail of one already-identified layer. There is no explicit when-to-use, no statement of when to prefer ps_layers or ps_text_info, and no prerequisites or exclusions given.

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

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

With no annotations, the description carries the full burden. 'Lista' implies a read-only, side-effect-free operation, and it discloses depth-limiting and group-descent behavior. However, it does not state that the call is non-mutating, nor address output size/performance for large documents.

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

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

Two sentences, front-loaded with what is listed before the parameter behavior. The attribute enumeration is long but earns its place given there is no output schema. Minimal waste.

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

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

For a 5-param tool with no annotations and no output schema, the description does well explaining the returned fields and two of the parameters. But raw and includeHidden are undocumented and the read-only nature is only implied, leaving gaps an agent must guess at.

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

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

Schema coverage is only 40% (doc and group documented), so the description must compensate. It does add meaning for depth and group ('baja a un grupo') beyond the schema, but leaves raw and includeHidden 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 (Lista) and resource (capas), and enumerates the attributes returned (tipo, visibilidad, opacidad, relleno, modo de fusión, contorno, máscaras, efectos, texto, smart objects). This is clearly a layer-tree listing. However, it does not differentiate itself from siblings like ps_layer_info or ps_document_info, which an agent must infer.

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

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

The description implies usage by explaining depth (limits levels) and group (descends into a group), suggesting when those parameters matter. But there is no explicit when-to-use vs. ps_layer_info, no when-not guidance, and no mention of prerequisites such as an open document.

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 destructive default ('replace' wipes existing effects), the non-destructive alternative ('merge' preserves the rest), the cross-layer copy behavior of copyFrom, and that the tool returns the resulting effects read back from Photoshop. It omits permission/error context, but the core mutation semantics are transparent.

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

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

The content is front-loaded (effect list first, then mode, then copyFrom, then return value) and each sentence earns its place with no filler. Slightly dense but appropriately sized for a tool with this many effect categories.

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

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

For a complex nested tool with 6 params and no output schema, the description covers the main behaviors and explicitly notes the return value, which is needed since no output schema exists. It leaves details of disable/effects sub-fields to the schema, which is reasonable given 83% coverage.

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 83% (above the 80% baseline of 3), but the description still adds real meaning: it documents that mode defaults to 'replace', what replace vs merge do, and how copyFrom behaves, none of which the bare enum conveys. This is meaningful added value over the structured schema.

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

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

The description opens with a specific verb+resource ("Aplica estilos de capa") and enumerates the exact effect types it supports (sombras, sombra interior, resplandores, bisel/relieve, satinado, overlays, trazo), so an agent knows precisely what it does. It does not, however, explicitly differentiate itself from the sibling style tools such as ps_style_set or ps_capture_style, 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?

It explains the operational semantics of mode ('replace' replaces, 'merge' preserves) and what copyFrom does, which implies usage. But it never states when to reach for this tool versus ps_style_set, ps_capture_style, or ps_style_get, so the when-to-use guidance is only implied.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses meaningful behavior: 'selection' consumes the current selection, gradient direction controls where the layer is REVEALED, and clip/unclip create a clipping mask. It does not disclose the destructive/reversible nature of 'delete' and 'apply', nor any permission or side-effect context, which is a real gap for a mutation tool.

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

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

A single dense sentence front-loads the resource and then enumerates operations compactly, which is efficient for a 12-parameter multi-op tool. It is a long sentence but nearly every clause carries distinct information about a different `type`.

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

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

For a tool with 12 parameters, nested rect/layer objects, two enums, and no output schema, the description covers the operation space but omits parameter semantics for start/end/reverse and gives no indication of return values or side effects of destructive ops. Adequate but with clear gaps given the complexity.

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

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

Schema description coverage is only 25% (doc, layer, direction documented). The description partially compensates by tying radius/feather to rect/ellipse, direction to gradient, and stating density/maskFeather adjust the mask. But start, end, and reverse are never explained in either the schema or the description, leaving several parameters undocumented.

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

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

The description opens by naming the resource ('Máscaras de capa') and enumerates every operation the `type` enum supports (revealAll, hideAll, rect/ellipse, selection, gradient, delete, apply, clip/unclip), each with a brief gloss. An agent can identify this as the layer-mask tool and distinguish it from siblings like ps_selection or ps_layer_style. It lacks a single crisp verb statement, but the operation catalog makes the purpose concrete.

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

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

It gives per-operation hints ('selection (usa la selección actual)', gradient direction meaning), which implies when each `type` applies. However, there is no explicit when-to-use-vs-alternative guidance, no note on clip vs unclip, and no mention of prerequisites (e.g., a selection must exist before 'selection'). Usage is inferable but not stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. Merge/stamp/rasterize are typically destructive, irreversible flattening operations, yet the description says nothing about loss of editability, required permissions, or reversibility. This is a significant gap 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 dense sentence that front-loads the primary operation and enumerates the modes efficiently. It is compact, though the mode enumeration with inline syntax is slightly cryptic.

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

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

For a 6-parameter, multi-mode tool with no annotations and no output schema, the description is too thin. It does not state which parameters apply to which mode, what the result is, or any constraints, leaving much of the calling contract ambiguous.

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

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

Schema coverage is only 33%, so the description should compensate. It mentions mode:'stamp' and the rasterize options, but refers to the parameter as 'what' when the schema names it 'rasterize' – a naming mismatch that can actively mislead an agent. It also never explains how name/layer/layers map to the merge mode.

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 three concrete operations (merge layers, stamp, rasterize) with a specific verb+resource, so an agent can tell what the tool does. However, it does not distinguish this tool from siblings like ps_group or ps_create_layer, which also combine/restructure layers.

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 three modes are described inline, which implicitly tells the agent what each mode does, but there is no explicit 'use this when...' guidance and no routing to alternatives. An agent must infer when to choose merge vs stamp vs rasterize.

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 lists configuration fields but says nothing about side effects: whether the new document is opened/becomes active, whether Photoshop must be running, what happens on name collisions, or what the response contains. For an 11-parameter mutation tool this is a significant gap.

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

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

A single front-loaded sentence beginning with the verb, with no filler. It is dense and comma-heavy but every listed element corresponds to a real parameter, so little 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?

With no output schema and no annotations on a complex creation tool, the description adequately covers the input configuration but omits return behavior and side effects (active document, error cases). It is complete enough to construct a call but not to predict its outcome.

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

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

Schema coverage is only 36%, so the description must compensate, and it largely does: it names every major field in natural language (tamaño→width/height, unidad, resolución, modo de color, profundidad, perfil ICC, fondo, guías) and adds meaning for slides ('diapositivas continuas (slides: {count, width}) con guías en cada corte'). It adds value beyond the sparse schema, though it omits the 'name' parameter and enum 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 and resource ('Crea un documento') and enumerates the configuration it applies (tamaño, unidad, resolución, modo, perfil, fondo, guías, slides). An agent knows this creates a new document, but the description never distinguishes it from siblings like ps_open or ps_set_document.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives such as ps_open (existing files) or ps_set_document (modifying an open document). The agent must infer that this is the creation path purely from the verb 'Crea'.

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 says the file is opened and configuration returned, but does not disclose whether it replaces/opens a new document, permission or session requirements, supported failure modes, or what 'configuración' contains.

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

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

A single, front-loaded sentence with no wasted words. Efficient, though its brevity is partly under-specification rather than pure conciseness.

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

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

There is no output schema, and 'devuelve su configuración' only vaguely gestures at the return value. For an open/file-loading tool with no annotations and one undocumented parameter, the definition is minimally adequate but leaves open questions.

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 67%: path and page are self-documented in the schema, while resolution has no description in either place. The description only echoes the accepted file formats, adding little param-level detail, so a baseline 3 is appropriate.

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

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

States a specific verb ('Abre') and the resource set (PSD/PSB/imagen/PDF/AI) and notes it returns configuration. Clear enough to distinguish from ps_new_document, but it does not explicitly differentiate from other file-producing siblings like ps_close or ps_save.

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

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

No statement of when to use this tool versus alternatives such as ps_new_document or ps_place_image, no prerequisites (e.g., needs an active Photoshop session), and no exclusions are given. The agent must infer context entirely.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a meaningful behavioral trait: colors are computed from rendered/visible content, not layer data, and results include a percentage. However, it says nothing about cost, permissions, or the return structure beyond the percentage.

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

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

A single tight sentence with the key scope distinction front-loaded and zero filler. Every clause earns its place.

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

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

There is no output schema and no annotations, so the description should do more. It notes that percentages are returned, which helps, but it leaves the `colors` parameter and the shape of the result undocumented for a computation tool.

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

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

Schema coverage is only 50%: the `doc` parameter is described in the schema, but `colors` (integer, 2-16) has no description anywhere. The description adds no parameter-level meaning and does not compensate for the undocumented parameter.

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

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

States a specific verb (calcula) and resource (colores dominantes), and explicitly scopes it to what is visible in the document rather than layers. This scope note distinguishes it from sibling analysis tools like ps_style_analyze and lets an agent identify it without opening the schema.

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

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

The visible-vs-layers clarification implies when this is appropriate (analyzing rendered output), but there is no explicit when-to-use, when-not-to-use, or named alternative. Usage must be inferred from the scope phrase.

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

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

No annotations, so the description must carry the behavioral load. It usefully discloses that 'cover' crops with a mask, that it can be embedded or linked, and that it accepts a url (downloaded) or path. But for a 27-parameter mutation tool it stays silent on permissions, reversibility, effects/mask interactions, and most 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?

Three compact sentences, front-loaded with the core capability and then the framing options. Every clause carries meaning; no filler. Slightly terse given the parameter surface but not bloated.

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 27-parameter, zero-required, no-annotation, no-output-schema tool with nested objects, the description is far too sparse. Large functional areas (blend modes, layer effects recipe, clipping, grouping, visibility/opacity) are entirely undiscussed, leaving the agent to guess at intended use.

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

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

Schema coverage is 48%, below the 50% mark, so the description should compensate. It meaningfully explains box, fit (including cover's mask behavior), and radius, but the majority of parameters (blend, effects, anchor, clipped, linked, parent, opacity, offsets, rotation) get no meaning beyond the schema.

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

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

States a specific verb+resource: places a file as a smart object (embedded or linked), and mentions box-fitting, radius, and free scale/position. This is clearly a placement tool, not shape/text/layer creation. However, it never distinguishes itself from the sibling ps_smart_object, leaving the boundary to inference.

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

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

No when-to-use or when-not guidance. It implies you can use box+fit to frame, or scale/position freely, but never says which mode suits which scenario, nor when to prefer linked vs embedded, nor when to use this instead of ps_smart_object.

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 delivers two important behaviors: it renders a duplicate so the original file is untouched (non-destructive), and it returns an image back to the agent. It omits other traits such as whether unsaved edits are reflected, but the core safety profile is disclosed.

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

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

Front-loaded with the core action and return value, followed by the non-destructive note and a dense options list. No filler sentences, though the option list is compressed into a single run-on clause.

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

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

For an 11-parameter tool with nested objects, no annotations, and no output schema, the description covers the main behavior but leaves gaps: image format, quality, and padding are unexplained, and it does not detail the returned image beyond "te devuelve la imagen." Adequate but incomplete for the parameter surface.

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

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

Schema coverage is only 45%, so the description must compensate. It explains crop (px zone), layer/artboard (crop to that layer) and showOnly/hide/show (isolate layers), but says nothing about format, quality, or padding, leaving several parameters undocumented in both places.

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

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

States a specific verb and resource: renders the document (or part) and returns the image, which clearly separates it from a status or info tool. It does not explicitly distinguish itself from the sibling ps_export, which also produces visual output, so differentiation is implied rather than stated.

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

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

"Úsala después de cada cambio importante" gives a concrete use context, telling the agent to preview after significant edits. It provides no exclusions or explicit alternatives (e.g. when to use ps_export instead), so it falls short of the top tier.

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

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

With no annotations, the description carries the full burden. It usefully discloses the report's scope and one real limitation (layers are only reported 2 levels deep), but it never states that the operation is read-only/non-mutating, what happens on timeout for a large file, or whether the document must already be open.

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

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

Two front-loaded sentences; the lead clause names the deliverable before the dense enumeration of contents. The parenthetical list is long but each item (fonts, linked, CC libraries, embedding, problems) is informative rather than filler.

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

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

For a no-annotation, no-output-schema report tool, the description does the necessary work of telling the agent what the returned text contains and what it does not cover (layer depth is capped at 2). Good coverage of return content, though depth/format of the text is unspecified.

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

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

Schema description coverage is 100% and the single 'doc' parameter is already documented ('nombre o índice desde 1, por defecto el activo'). The description adds no parameter detail at all, so it neither helps nor harms — baseline 3 applies.

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

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

States a specific deliverable — 'un solo informe en texto' — and enumerates its contents (document config, resources, 2-level layer structure, design definition). This implicitly distinguishes it from the narrower siblings ps_document_info, ps_resources and ps_layers, but none of them are named explicitly.

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

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

'Es lo primero que conviene leer al recibir un PSD ajeno' gives a clear situational trigger for using the tool (orientation on an unfamiliar PSD). It does not state when not to use it, nor does it point to alternative siblings for narrower needs.

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

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

With no annotations, the description carries the full burden. It usefully discloses the side effect that a mask is created rather than pixels being deleted, but says nothing about reversibility, required layer type, or Photoshop/neural-filter availability. Partial disclosure, so a middling score.

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 parenthetical is the only extra and it carries real information. Appropriately sized for a two-parameter tool.

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

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

For a mutation tool with no annotations and no output schema, the description covers the core action and its main side effect but omits failure modes, permissions, and what happens to existing masks. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both the doc and layer parameters are already documented in the schema with accepted formats. The description adds nothing beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Quita el fondo de una capa') plus the mechanism ('con la IA de Photoshop'), which an agent can distinguish from generic siblings like ps_mask or ps_filter. It does not name or exclude any alternative explicitly, so it stops short of 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 prefer this over ps_mask, ps_filter, or a manual selection workflow, and no prerequisites are stated. Usage has to be inferred 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?

With no annotations, the description carries the full burden. It discloses valuable behavioral content — it reports font install state, linked-file paths/libraries/lost-modified status, and detected problems, implying a diagnostic read operation — but never explicitly states that it is read-only and side-effect free, nor how results are returned.

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 enumerates the covered resource categories compactly via parentheticals. It is dense but every clause adds a distinct category; no filler sentences.

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

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

For a single-optional-parameter read tool with no output schema, the description gives a thorough account of the returned information categories, which is the main thing an agent needs. It falls short only on explicit read-only confirmation and usage routing, which are minor here.

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

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

Schema description coverage is 100%, so the single 'doc' parameter (name or 1-based index, defaulting to active) is already fully documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific information-gathering purpose — reporting what resources a project uses and how they are defined — and enumerates the resource categories (fonts, linked files, smart objects, text colors, detected problems). An agent can tell this is a read/inspection tool distinct from mutation siblings, though it doesn't explicitly name alternatives like ps_fonts or ps_document_info.

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 is for auditing a document's assets, but there is no explicit when-to-use, when-not-to-use, or guidance pointing to ps_fonts or ps_document_info as alternatives. The listing of covered categories implicitly scopes the tool.

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

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

No annotations are provided, so the description carries the full burden. It doesn't state whether the action mutates the document, what happens on failure, whether it requires an open document, or whether it's reversible via history. For a mutating execute 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 concise sentence that front-loads the core action and names the two inputs. No waste.

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

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

For a tool that mutates a document with zero annotation coverage, 0% schema coverage, and no output schema, the description is too thin. It omits preconditions (open document needed?), failure behavior, and parameter meaning.

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 two parameters (set, name) are undocumented anywhere. The description merely names them in passing ('nombre y conjunto') without explaining what a set is, expected format, or how to discover valid values. It falls short of compensating for the coverage gap.

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

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

States a specific verb (Reproduce/Ejecutar) and resource (acción grabada/Photoshop action) with the identifying fields (nombre y conjunto). Clear what it does, though it doesn't distinguish itself from siblings like ps_action_manager, which likely also concerns actions.

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 ps_action_manager or ps_run_script_file. The agent must infer that this executes an existing recorded action while the manager likely creates/manages them.

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

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

No annotations are provided, so the description carries the full burden. For a tool that executes arbitrary user-supplied code, it discloses nothing about side effects, error behavior, whether the script can mutate the open document, or any safety/permission constraints.

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

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

A single front-loaded sentence with no filler. It is efficient, though arguably thin for a code-execution 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?

With no annotations, no output schema, and zero parameter documentation, the description should compensate but does not. It omits how the script's result is reported, what context the script runs in, and any error or security expectations.

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

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

Schema coverage is 0% and the single 'path' parameter has no description. The phrase 'del disco' does imply the path is a filesystem location to a .jsx/.jsxbin file, which adds a little meaning beyond the bare string type, but format, absolute-vs-relative, and extension expectations remain unstated.

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 (Ejecuta) and resource (script .jsx/.jsxbin del disco) inside Photoshop, so the action is unambiguous. It does not explicitly distinguish itself from the sibling ps_execute_script, leaving the file-vs-inline distinction to inference.

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

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

No when-to-use guidance is given. The phrase 'del disco' hints that this is for scripts already saved as files, but the description never tells the agent when to pick this over ps_execute_script or ps_run_action, nor what preconditions (file must exist, extension) apply.

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

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

With no annotations, the description carries the full burden and does disclose two non-obvious traits: the default in-place overwrite and that asCopy avoids mutating the open document. It stops short of warning that a supplied path overwrites an existing file, does not mention the quality setting's effect, and omits the pdf format present in the enum.

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

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

Three short sentences, verb front-loaded, with each sentence adding a distinct fact (supported formats, path default, asCopy behavior). No padding or redundancy.

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

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

For a five-parameter mutation tool with no annotations and no output schema, the core save semantics are covered but gaps remain around the quality parameter, the pdf format, and the destructive overwrite risk when a path is given.

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

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

Schema coverage is low at 20%, so the description must compensate and it partially does: it clarifies the path default and the asCopy semantics, and its format list parallels the enum. It contributes nothing for quality, and doc relies entirely on its own schema description.

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

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

States a specific verb and resource ("Guarda el documento") and lists the supported formats, so the agent immediately understands this is an in-place save operation. However, it never names the closest sibling, ps_export, so the distinction between saving and exporting is left implicit.

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

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

Usage is only implied through behavior: no path means overwrite the current file, and asCopy leaves the open document untouched. There is no explicit statement of when to prefer this over ps_export or when a path should be supplied versus omitted.

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 useful behavior such as AI-based subject selection and that a selection can be chained into fill/clear/stroke/mask/deselect via "then", but says nothing about permissions, reversibility, coordinate expectations, or return behavior for what is clearly a mutating 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?

Front-loaded with the purpose and then a compact keyword stream. It is dense and efficient, though it reads closer to a value dump than structured prose.

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

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

For a 16-parameter, nested-object, no-output-schema, no-annotation mutation tool, the description is materially incomplete: it omits meaning for several params and gives no hint of the "then" sub-object's shape or result behavior.

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

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

Schema coverage is only 19% across 16 params, so the description must compensate. It names most parameters by their value sets (type, mode, grow/shrink/smooth/border/feather, then) but adds no semantics for fuzziness, sampleAllLayers, points, radius, or the structure of "then", leaving real gaps.

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

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

States a specific verb+resource ("Crea o modifica la selección") and enumerates the selection types, which lets an agent distinguish it from siblings like ps_mask or ps_fill. It stops short of true differentiation language, but the purpose is unmistakable.

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 lists the available modes and post-actions but never says when to choose one type over another, nor when this tool should be preferred over ps_mask or ps_fill. It is a value enumeration rather than usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about side effects: whether resizing resamples or crops pixels, whether canvas resize destroys content, whether profile conversion is reversible, or what permissions are needed. It is purely an enumeration of capabilities for a mutation tool.

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

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

A single front-loaded sentence that enumerates the capabilities without filler. Dense and efficient, though the enumeration is a bare list rather than organized by operation type.

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

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

For a 12-parameter mutation tool with nested objects (resizeImage, resizeCanvas), no annotations, and no output schema, a one-sentence capability list is thin. It omits parameter-level behavior, side effects, and interaction between conflicting options (e.g. trim vs resize), leaving the agent under-equipped to 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?

Schema description coverage is only 8% (just the 'doc' param), so the description must compensate, and it does map most parameter categories to natural language (image/canvas size, resolution, mode, depth, convert/assign profile, crop, rotate, guides). However it adds no detail on units, formats, or enum meanings, leaving the 12 parameters still largely undocumented.

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

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

States a specific verb ('Cambia') and resource ('la configuración del documento') and enumerates the concrete settings it touches (image/canvas size, resolution, mode, depth, profile, crop, rotate, guides). An agent can distinguish it from the read-only ps_document_info, though no sibling is named explicitly.

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

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

The description only says what the tool changes; it gives no guidance on when to use it versus alternatives (e.g. ps_document_info for reading, ps_selection for crop-by-selection), no prerequisites, and no exclusions. Usage must be inferred from the parameter 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 entire behavioral burden for a 30-parameter mutator. It discloses the scope of mutation ("casi todo") but nothing about permissions, prerequisites, reversibility, error behavior, or how conflicting options (e.g. size vs resize, x/y vs moveBy) interact.

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

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

A single dense semicolon-separated run-on. It is front-loaded with the verb and wastes no words on fluff, but the lack of structure makes a 30-parameter capability list hard to scan, and "casi todo" is needlessly 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?

For a 30-parameter tool with no annotations and no output schema, the description is inadequate: it never explains parameter interactions, prerequisites, or the expected result, leaving an agent unable to invoke it correctly in non-trivial 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?

At 50% schema coverage, the description must compensate, and it partially does by grouping parameters logically (posición: x,y,anchor/moveBy; tamaño: size/resize; orden: order/parent/above/below). However, it adds no syntax or format detail beyond the schema and doesn't resolve ambiguities between the overlapping position/size parameters.

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

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

States a specific verb ("Cambia") and resource ("una capa") and then enumerates the modifiable properties, so an agent can quickly see this is the broad layer-mutation tool. It does not, however, explicitly distinguish itself from overlapping siblings like ps_align, ps_fill, or ps_mask, which also touch some of these same fields.

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

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

There is no when-to-use guidance, no when-not-to-use, and no mention of alternatives. The agent is told what the tool *can* change but never when to prefer it over ps_align, ps_fill, ps_mask, or ps_layer_style, some of which clearly overlap.

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 lists the operations but never states side effects, reversibility, or the non-destructive nature of a smart-object conversion, and it omits 'rasterize' from the enum entirely. For a mutation tool with zero annotation coverage this is a real 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; the verb and resource lead. It reads as a long comma list, but every item maps to a real capability, so little is wasted.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description covers the operation space but omits the 'rasterize' enum value, ignores the 'path' parameter, and gives no behavioral or return context. Adequate but with clear holes.

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

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

Schema coverage is 50% (doc and layer documented; path and action undocumented). The description compensates partially by giving semantic meaning to six of the seven action values, but it leaves 'path' unexplained and, critically, never mentions the 'rasterize' action at all, so the description takes the agent only part of the way.

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 ('Convertir') and resource ('objeto inteligente') and enumerates the full set of operations (convert/replace/edit/relink/embed/toLinked). An agent understands this is the smart-object manipulation tool and won't confuse it with sibling layer tools. It loses a point only for not naming the siblings it differs from.

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/when-not guidance, no prerequisites, and no named alternatives. The enumerated operations implicitly hint at selection, but the agent must infer which action to pick and when – nothing routes it here versus ps_merge_rasterize or ps_place_image.

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

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

With no annotations, the description carries the full burden, and it does disclose one important side effect: Photoshop is launched if closed, so this is not a pure read. However, it says nothing about failure/timeout behavior when Photoshop is unavailable, latency of the launch, or whether the connection persists across calls.

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

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

One sentence, front-loaded with the action and followed by the returned content. No padding or repetition of the title.

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

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

With no output schema, the description usefully enumerates the return payload (version, open documents, active document and layer), which an agent needs. The remaining gap is error/edge behavior when the connection cannot be established.

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 nothing for the description to disambiguate; baseline 4 applies. The description correctly implies a no-argument call.

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 ('conecta con') and resource (Photoshop), plus the returned payload (versión, documentos abiertos, documento y capa activos). This separates it from siblings such as ps_document_info or ps_open, though it never names an alternative explicitly.

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

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

No guidance on when to call this vs. ps_document_info, ps_open, or ps_project_report, all of which overlap with the status/document information it returns. The agent must infer that this is the connection-health/state probe. No exclusions or prerequisites stated.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses that it opens and closes PSDs without saving (no mutation of source files) and that it persists a named style plus generates a guide (a durable side effect). It omits permissions, error behavior, and whether an existing style is overwritten, which keeps it short of a 5.

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

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

Front-loads the core action ('Lee ... y aprende el estilo') and puts the file-handling caveat inline rather than in a trailing afterthought. The long enumeration of extracted attributes is dense but each item tells the agent what will be modeled, so it earns its place.

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

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

For a 5-parameter tool with no annotations and no output schema, the description covers the source options, the write side effect, the scope of analysis, and the produced artifacts (named style + guide). It is nearly self-sufficient; only auth/preconditions and failure modes are left out.

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

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

Schema description coverage is 80%, so the schema already documents docs, name, files, and merge. The description usefully clarifies the two input modes ('abiertos o por ruta', i.e. docs vs files) and that the result is stored 'con nombre', but adds nothing for merge and the undocumented description parameter. Baseline 3 is appropriate.

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

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

States a specific verb+resource: reads one or more PSDs and learns a person's style, then saves it under a name and generates a guide. The enumerated extraction targets (canvas format, palette, typography, effects recipes, layer structure) make the purpose unambiguous. It does not, however, distinguish itself from near-siblings like ps_capture_style or ps_style_set.

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

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

"Úsalo con trabajos terminados de la persona" gives an implied condition for use (finished work, not drafts), which is real guidance. But no alternative tool is named and there is no when-not guidance, so selection among ps_capture_style / ps_style_get / ps_style_set is left to inference.

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

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

With no annotations, the description carries the full burden. It discloses a read operation ('Devuelve') and the shape of the returned content, which is useful, but says nothing about permissions, whether a style must exist, or how 'name' resolves when omitted (that detail lives only in the schema). Adequate but incomplete for an unannotated tool.

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

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

Front-loads purpose, then a usage directive, then the section enum — a logical order with no wasted sentences. Slightly dense parenthetical but still efficient.

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

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

No output schema exists, so the description usefully enumerates what is returned, states the pre-design workflow, and documents the section enum. Only the 'name' parameter semantics remain thin, 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?

Schema coverage is 50%. The description explains the 'section' parameter well by listing the enum values and stating it limits the returned slice, but the 'name' parameter's meaning (defaulting to the active asset) is left to the schema. Baseline 3 is appropriate given partial coverage and partial compensation.

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 ('Devuelve la guía de un estilo') and enumerates the returned content (palette, typography, presets, recipes, rules), so the agent knows exactly what this tool produces. It does not, however, differentiate itself from close siblings like ps_style_list or ps_style_analyze, leaving the agent to infer the boundary.

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

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

Gives a clear workflow directive — read before designing and follow the rules — which is stronger than mere implied usage. It stops short of naming alternatives or exclusion conditions (e.g., when to call ps_style_list instead), so it is clear context without routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states that it lists saved styles and reports the active one, but says nothing about return format, ordering, whether it is a safe read, or how it behaves when no styles are saved. For a no-annotation tool this is a significant disclosure 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. It states the resource and the active-style detail and stops, which is exactly right for a zero-argument list operation.

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?

Low complexity and zero parameters make a short description reasonable, but with no annotations, no output schema, and no return-format or ordering detail, an agent still cannot predict the shape of what comes back. It is minimally complete rather than fully so.

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, which is the baseline-4 case under the rubric. The description accurately implies no input is required, and there is nothing further for the description to add.

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

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

States a specific verb (Lista) and resource (estilos guardados), plus an added detail: which style is active. This distinguishes it from neighbors like ps_style_get, ps_style_set, ps_capture_style, and ps_style_analyze, which operate on individual styles rather than enumerating the saved list.

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 read-list use case (enumerating saved styles and the active one), but gives no explicit when-to-use versus alternatives such as ps_style_get or ps_style_analyze. Adequate but with a clear routing gap for an agent choosing among the style tools.

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

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

With no annotations provided, the description carries the full disclosure burden. It doesn't say whether changes are persistent, whether deletion is reversible, what happens to existing presets with the same name, or that a delete object triggers destructive removal.

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 stating the core actions, followed by a brief rationale sentence. No filler, though the second sentence is low-value.

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

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

For a 7-param mutation tool with no annotations and no output schema, the description is thin. It omits destructive semantics of delete, activation behavior, persistence, and doesn't compensate for the 14% schema coverage gap.

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

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

Schema description coverage is only 14%, but the nested schema is self-documenting for many fields (enums, effects schema reference). The description lists the main operation categories (style, preset, recipe, color) which maps to top-level params, but adds no syntax or format detail for the 7 poorly-documented params.

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 specific verbs and resources: activating a style and adding/editing text presets, effect recipes, or named colors. It clearly distinguishes the tool's scope from siblings like ps_style_list or ps_fonts, though it doesn't name an alternative for read operations.

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

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

It implies usage ('útil para afinar lo que el análisis dedujo') referencing a prior analysis step, but never states when to use this over ps_style_analyze or ps_capture_style, nor any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden, and it does disclose the return payload scope plus the notable detail that run styles are the 'estilo real' (resolved/effective style rather than nominal). However, it says nothing about side effects, permissions, whether the layer must be a text layer, or error behavior on non-text layers.

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

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

A single sentence that front-loads the verb and resource, then lists the returned data. Dense but every clause earns its place, listing distinct return categories.

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

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

There is no output schema, so the description must sketch the return shape — and it does, enumerating content, type, rotation, scale, and run-level styles. It stops short of explaining the structure of a 'tramo' or how multiple runs are represented, which is the remaining gap for a read tool.

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

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

Schema description coverage is 100%, with both 'doc' and 'layer' fully documented including the accepted forms ({id|name|path|index|nth}). The description adds no parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Lee') and resource ('capa de texto') and enumerates exactly what is returned: content, type (point/paragraph), rotation, scale, and per-run styling. This clearly separates it from write-side siblings like ps_add_text and ps_edit_text, though it never names the closest read sibling, ps_layer_info.

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

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

There is no guidance on when to call this versus ps_layer_info, ps_layer_style, or ps_style_analyze, and no stated prerequisites. The read-only intent is only inferred from the verb 'Lee'.

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