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

Annotations already declare readOnly=false, destructive=true, openWorld=true, and idempotent=false, so the CONTRACT line largely restates structured data. However, the NOTES add genuinely new behavioral context: closing without save_before_close=True discards unsaved changes, and filesystem interaction is called out for open/save. That is real value beyond the annotations, though no auth or error/return behavior is described.

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

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

Front-loaded summary followed by clearly labeled CONTRACT, WHEN TO USE, EXAMPLES, and NOTES sections — very scannable. Slight redundancy: the CONTRACT line duplicates the annotations verbatim, which costs a little space but adds little information.

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

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

For a four-action document lifecycle tool, the definition covers preconditions, destructive side effects, and worked examples for every action; an output schema is present so return values need not be explained. Nothing essential for correct invocation is missing.

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

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

Top-level schema description coverage is nominally 0%, but the nested DocumentInput properties carry their own descriptions (name/create, width/create, file_path/open+save, save_before_close/close). The description reinforces this by tying parameters to actions in the examples (width/height/color_mode for create, file_path for open/save, save_before_close for close), so an agent knows which params apply to which action without opening the schema.

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

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

The description names a specific verb family (create/open/save/close) and the exact resource (Illustrator document), and enumerates each action so the agent can distinguish this from siblings like illustrator_export_document or illustrator_get_document. The one-line summary plus the per-action WHEN TO USE block makes the tool's identity unambiguous.

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

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

It explicitly states when to use each action, including the precondition that file_path is required for 'open' and is only optional (save-as) for 'save', and flags the close-without-save behavior. Alternatives are implicit but the action-level routing is explicit and complete.

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?

Annotations already declare readOnly=false, destructive=true, idempotent=false, openWorld=true, and the description's CONTRACT line is consistent with them. Beyond that it discloses non-obvious behavior: coordinate-system inversion (Y-down API vs Y-up ExtendScript), the mutation-counter/VLM cadence mechanism, auto-decrement on failure, and that ExtendScript can touch File/Folder/OS. This is substantial added context rather than restating annotations.

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

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

Headed sections and front-loaded verb make it scannable, and every block is actionable. It loses a point for redundancy: the mutation counter is explained in MUTATION SAFETY and again in NOTES, and final_step appears twice.

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 powerful, destructive, open-world scripting tool the description covers usage, safety patterns for iterating live collections, coordinate conversion, and worked examples. An output schema exists, so return-value explanation is correctly omitted, and the preview/validation parameters are documented in the schema itself.

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 visible schema nests a single 'params' object, and the description adds meaning that the schema cannot convey: the y -> -y coordinate convention, units (points), positive width/height requirement for rectangle, and corner-point-only behavior of setEntirePath. It does not walk through fields like max_ms, max_ops, or includes, but the field-level schema descriptions already cover those, so the description usefully compensates for the outermost-layer 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?

Opens with a specific verb+resource: 'Execute raw JavaScript/ExtendScript code in Adobe Illustrator.' The abstraction ladder and DECISION RULES explicitly name sibling tools (illustrator_path_boolean, illustrator_execute_task, element_create_batch, illustrator_path_import_svg) and state which one wins in each situation, so an agent can distinguish this tool from its neighbors without opening a 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?

WHEN TO USE lists three concrete scenarios (one-offs, full DOM access, custom read logic) and the DECISION RULES give hard 'MUST use X instead' constraints for boolean ops and batch creation. Exclusions and alternatives are explicit rather than 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?

Annotations already declare destructive=True, readOnly=False, idempotent=False, and the CONTRACT line merely restates them (no added credit). Beyond that the description adds real behavioral context: dryRun computes without applying, trace adds an execution trace, assignIds is opt-in, and results come with structured error reports — useful for 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?

Clearly front-loaded and sectioned (purpose, contract, when-to-use, examples, selectors, options, notes), and the length is defensible for a tool this complex. The CONTRACT line wastes space by duplicating the annotations, and the examples are generous, but overall it is well organized rather than 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?

An output schema exists, so return-value documentation is not required, and the description covers the declarative entry points, target selection, and safety options. It does not surface the apply_fn/compute_fn JSX escape hatch or preview modes, which an agent only discovers in the schema, but the core call path is adequately described.

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 the top level the schema exposes only a single undocumented `params` field (0% coverage per signals), so the description must compensate — and it does, showing the payload wrapping rule, the task/params shape, worked payload examples, target-selector syntax, and the dryRun/trace options. It still omits apply_fn/compute_fn/collect_fn, includes, and preview_mode, which are passed through to the rich nested 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 opening line ("Execute a structured task using the Task Protocol v2.1") is somewhat abstract on its own, but WHEN TO USE immediately specifies the concrete job: creating/modifying elements with declarative ops and batch element creation. The NOTES section further distinguishes it from siblings by routing boolean ops to illustrator_path_boolean and raw SVG paths to illustrator_path_import_svg.

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?

Explicit when-to-use bullets (declarative element ops, batch creation, operations needing structured error reports/target selectors) combined with two explicit when-not-to-use redirections to named sibling tools. Nothing is left to inference about which tool to pick.

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?

Beyond the annotations (which it restates faithfully), it adds real operational context: the file at file_path is overwritten (destructive to filesystem), artboard_only runs a pre-check, PDF goes through saveAs with a longer timeout, and return_image yields base64 ImageContent. This is exactly the kind of behavior an agent needs and annotations do not carry.

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?

Well front-loaded: purpose first, then contract, usage, examples, notes. Each section carries information, though the CONTRACT line largely duplicates the annotations and could be trimmed without losing meaning.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description fills the remaining gaps (destructive overwrite, format-specific timeouts, pre-check behavior, image return path). An agent has everything needed to invoke this correctly on the first attempt.

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

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

The description pairs parameters with semantics that the schema alone leaves thin: scale is tied to raster output, return_image is constrained to PNG/JPG, and artboard_only is explained as clipping with a pre-check. artboard_index is left to its schema description, and no example uses it, so coverage is strong but not exhaustive.

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

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

The first line states a specific verb (export), resource (the active document), and the exact output formats (PNG, JPG, SVG, PDF). No sibling tool performs document export, so it is cleanly distinguishable from get_document, preflight_check, and place_file.

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 WHEN TO USE block names concrete scenarios (raster export with scale, vector formats, visual feedback via return_image). It clearly routes the agent by intent, but never states when NOT to use it or names an alternative tool, so it stops short of full routing guidance.

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

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

Annotations already declare readOnly/destructive/idempotent/openWorld, so the CONTRACT line is largely redundant. The description does add value beyond them: truncation semantics ('truncated=true and nextOffset'), offset-based paging per layer, and the shape of scope='both' responses. Those are real behavioral traits the annotations cannot express.

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?

Well front-loaded: the one-line purpose is followed by clearly labeled CONTRACT, WHEN TO USE, OPTIONS, EXAMPLES and NOTES blocks, and the examples are genuinely useful. The CONTRACT line merely restates the annotations, which is the one piece of low-value content.

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

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

An output schema exists, so return values need not be spelled out, yet the NOTES still flag the truncation/nextOffset signals an agent must handle when paging. With scope, pagination, filtering and the app-vs-document distinction all covered, nothing needed to call this correctly is missing.

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

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

Schema description coverage registers as 0%, so the description carries the full burden, and it does: every parameter is covered with defaults and valid ranges (max_items 1-5000, max_layers 1-200), plus the paging interaction between offset/max_items and layer_name/layer_index. The EXAMPLES block further disambiguates how the parameters combine.

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 opening line states a specific verb and resource ('Get complete document information and structure as a JSON tree') and the WHEN TO USE bullets clarify the three inspectable scopes (canvas/layers/items, app info). It stops short of naming siblings such as illustrator_query_items, which is the obvious alternative for filtered searching, so an agent must infer the boundary itself.

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 WHEN TO USE section gives three concrete contexts ('before writing modification scripts', 'inspecting layers, items, positions', 'scope=app'), which is genuine when-to-use guidance. It never states when NOT to use it or points to the sibling that should be used instead (e.g., illustrator_query_items for targeted queries), so routing is still partly inferred.

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?

Beyond the annotations (which already declare destructive=true, idempotent=false), the description adds genuinely useful traits: checkpoints only capture MCP-managed items carrying @mcp:id, and checkpoint_restore is mutate-in-place, potentially needing multiple undos to revert. The CONTRACT line merely restates the annotations verbatim, so it earns no additional credit, but the NOTES section does add real behavioral context.

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

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

Front-loaded core sentence followed by clearly labeled CONTRACT/WHEN TO USE/EXAMPLES/NOTES sections; examples are compact and directly runnable. The CONTRACT line duplicates the annotations word-for-word, which is the one line that does not earn its place.

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

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

An output schema exists, so return values need no explanation, and the description covers every action in the enum, the constraint on what checkpoints capture, the reversibility caveat for restore, and the destructive nature of undo/redo. An agent has everything needed to select the right action and call it correctly.

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

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

Top-level schema coverage reads 0% because params is a bare $ref, so the description has to carry semantic weight — and it does, via worked examples that demonstrate count for undo, and name for checkpoint_save/restore. It conveys which arguments matter for which action more concretely than the enum list alone, though the nested $defs already document name/count/action individually.

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?

Opens with a specific verb+resource ("Undo or redo actions in Illustrator") and then extends it to the named checkpoint operations, which no sibling tool covers. An agent can distinguish it from illustrator_document, illustrator_query_items, or illustrator_execute_script without opening any schema.

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

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

The WHEN TO USE block gives three concrete scenarios mapped to specific action values (undo/redo for mistakes, checkpoint_save/restore for recovery), and the EXAMPLES section shows the exact call shape for each. It stops short of naming exclusions or alternatives (e.g. when to prefer document-level repair or execute_script over a checkpoint restore), so it is clear context without routing rules.

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?

Beyond the annotations (which already declare destructive=true and idempotent=false), the description discloses that originals are deleted on success only when delete_originals=True, that only fill geometry is processed while strokes are ignored with a warning, and that output type varies (PathItem vs CompoundPathItem). It also exposes the internal pipeline stages, so the agent knows the operation is a multi-stage ExtendScript/Python round-trip rather than an atomic edit.

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, then cleanly sectioned into CONTRACT, WHEN TO USE, PIPELINE, EXAMPLES and NOTES, which makes scanning fast. The five-step pipeline is the most verbose element and is more implementation detail than an agent strictly needs, but nothing is 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 destructive, multi-step geometry tool this covers the essentials: mutation semantics, the originals-deletion behavior, geometry limitations (strokes ignored), the MCP ID convention (@mcp:id in item.note), and result shape. An output schema exists, so return-value documentation is not required, yet the description still usefully explains when each result type is produced.

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 reported schema description coverage is 0%, so the description is expected to compensate, and it does so only partially: it clarifies the kept-vs-cutting roles of subject and clip via examples, and the destructive consequence of delete_originals. It says nothing about name, layer, style, max_segments, or flatten_tolerance, leaving half the parameters to be inferred from titles alone.

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

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

States a specific verb+resource ('Perform boolean operations ... on paths') and enumerates the four operations, which strongly differentiates it from every sibling (script execution, querying, SVG import, export). An agent can identify this tool's role 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?

A dedicated WHEN TO USE block maps each operation to a concrete scenario ('Combining shapes (unite), cutting holes (subtract), finding overlaps (intersect)') and adds the general case 'any shape sculpting that needs boolean geometry'. It lacks explicit negative guidance or a named alternative sibling to prefer in other cases, so it stops 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?

Annotations already declare readOnly=false, destructive=false, idempotent=false, openWorld=false. The description adds behavioral context beyond annotations: server-side parsing, arc-to-cubic conversion, safety limits (50,000 chars, 5,000 segments, etc.), and return format (bounds in Y-up space). This is rich context. Missing: what happens if limits are exceeded, or whether partial imports are possible.

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?

Well-structured with clear sections: CONTRACT, WHEN TO USE, EXAMPLES, NOTES. Front-loaded with the core purpose. Every sentence adds value. No redundancy.

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

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

Given complexity (SVG parsing, conversion, safety limits, output bounds), the description covers key behavioral aspects and provides examples. Output schema exists, so return value details are not needed. Missing: parameter semantics for tag, name, layer; and the fill parameter in the example is not in the schema (minor). Overall quite complete for the core use case.

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 provides an example showing the d parameter format and mentions the fill parameter (though fill is not in the schema – possible inconsistency). The description does not explain the tag, name, or layer parameters at all, leaving them fully to the schema (which also lacks descriptions). However, the example demonstrates the core d parameter syntax well.

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 (import) and resource (SVG path d attribute) with a clear scope (into the active document). It distinguishes from siblings by naming illustrator_execute_task + element_create as the preferred alternative for new shapes. An agent can immediately tell what this tool does.

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

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

Provides explicit WHEN TO USE criteria (importing existing SVG path data, complex outlines/arcs) and points to an alternative for new shapes. The guidance is specific and actionable, leaving no ambiguity about when to select this tool versus 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?

The CONTRACT line merely restates the annotations (readOnly/destructive/openWorld/idempotent), which earns no credit, but the description goes well beyond them: linked files auto-update from source, embed_editable opens and pastes PDF vectors, trace+expand tradeoffs for DOM complexity, and a warning above 2000 paths. It never states what document state is modified or what destruction occurs, which is a meaningful gap for a destructive 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?

Headers (WHEN TO USE, KEY CONCEPTS, EXAMPLES, NOTES) front-load the critical routing information, and the two examples show realistic call shapes. The CONTRACT line is pure duplication of annotation data and could be dropped, but the rest is dense and earns its space.

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

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

With an output schema present, return values need no explanation, and the description thoroughly covers placement modes, trace behavior, and complexity warnings. It leaves x/y positioning semantics (origin, units, artboard vs document space) undefined, which is the one operational detail an agent would need to place a file accurately.

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 nested schema already describes every parameter, but the description adds operational meaning the schema lacks: linked=True is a drafting choice vs linked=False for final deliverables, embed_editable is slower but fully editable, and expand controls editability vs DOM weight. It does not clarify coordinate origin or units for x/y, so it falls short of full coverage.

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

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

The opening sentence states a specific verb (place) and resource (external file), and enumerates the supported formats (EPS, AI, PDF, image). Combined with the WHEN TO USE scenarios, an agent can distinguish this from siblings like illustrator_path_import_svg without opening either 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 WHEN TO USE block explicitly enumerates the triggering scenarios (raster import, vector placement, vectorization via trace) and the KEY CONCEPTS block routes between the linked/embed_editable/trace modes based on drafting vs final output. This is explicit when-to-use guidance with clear mode selection criteria.

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

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

Annotations already declare readOnly/destructive/idempotent/openWorld, and the description adds genuinely useful behavioral detail beyond them: the specific issue classes checked, the guarantee that the document is not modified, and return semantics (ok=true when clean, warnings otherwise). The CONTRACT line merely restates the annotations, but the NOTES add real value.

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

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

Well-structured and front-loaded: purpose first, then contract, when-to-use, concepts, and notes. The CONTRACT line is redundant with the annotations and could be dropped, which is the only real waste in an otherwise tight layout.

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 read-only validation tool with annotations covering the safety profile and an output schema handling return values, the description supplies the needed context (what is checked, when to run it, and how results signal problems). The one gap is the inaccurate parameter guidance, which is minor against the rest of the 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?

With schema description coverage reported at 0% for the parameter, the description carries the burden, yet its only parameter detail is misleading: it describes a 'bounds policy' with values 'warn'/'error', which matches no parameter in the schema and conflicts with the actual 'policy' parameter whose values are 'fully-contained'/'intersects'. This actively risks misconfiguring the call rather than clarifying it.

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 ('observational validation on the active document') and enumerates the exact checks performed (bounds, zero-size, empty text, locked items), which makes the intent unambiguous. It does not, however, explicitly differentiate itself from siblings like illustrator_query_items or illustrator_get_document, so it falls short of a 5.

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

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

A dedicated WHEN TO USE block gives two concrete scenarios (before export; after a series of modifications), which is clear context. It stops short of naming when NOT to use it or pointing to an alternative tool, so it does not reach the explicit-alternatives bar 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?

The CONTRACT line merely restates the annotations (readOnly, destructive, idempotent, openWorld), so it earns no credit. The description does add genuine behavioral context beyond the annotations: it returns an ItemRef per matched item for stable referencing, and include_trace enables debugging. With an output schema present and annotations covering the safety profile, this is adequate but not rich.

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 contract, usage, selectors, and notes in scannable sections. Efficient overall, though the CONTRACT block duplicates annotation data and consumes space without adding information.

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

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

An agent gets purpose, when to use, selector syntax, and return-value semantics; the output schema covers the response shape. Minor gap: the description shows {type: "all", recursive: true} while the schema example shows {type: "all"}, leaving the recursive flag's effect 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 reported at 0% (descriptions are buried under the $ref), so the description carries the burden and does so by enumerating four selector shapes with concrete payloads. It adds one detail the schema omits, the recursive flag on {type: "all"}, but otherwise largely mirrors the schema's own selector examples.

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 (query), resource (items), and mechanism (Task Protocol declarative target selection). The WHEN TO USE list makes it distinguishable from siblings like illustrator_execute_task and illustrator_execute_script, which run work rather than inspect it.

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

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

Gives three concrete scenarios: finding items before modification, inspecting the current selection, and listing items on a layer or in the document. This is clear context, but it never names an alternative tool or states when this tool is the wrong choice versus illustrator_execute_task.

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?

Annotations already declare destructive/idempotent, but the description goes well beyond them: it specifies the layer is locked, dimmed, and non-printable, that repeat calls replace the prior reference, that removal mode deletes the layer outright, that the active artboard drives fit/center, and that dominant color extraction is conditional on Pillow. That is the kind of side-effect detail annotations cannot carry.

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 one-line purpose followed by clearly labeled CONTRACT/WHEN TO USE/KEY CONCEPTS/EXAMPLES/NOTES sections, each carrying non-redundant content. It is longer than strictly necessary, but no section is 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 single-parameter mutation with a declared output schema, the description covers the destructive clear path, idempotency, persistence semantics, and environment dependencies. Nothing an agent needs to invoke or avoid this tool correctly is missing.

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

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

Schema text describes each field, but the description adds meaning beyond it: file_path omission is the clear signal ('omit file_path'), opacity is motivated ('dim tracing' via the 50 example), and fits are tied to the active artboard. The one gap is the boolean 'fit' flag, whose semantics come only from 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 ('set or clear a reference image on a locked background layer') and immediately distinguishes itself from the closest sibling (illustrator_place_file) by naming the dedicated '__reference__' layer and tracing use case. An agent can tell what this does without opening the schema.

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

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

A dedicated WHEN TO USE block gives both the set case (preparing a reference overlay before tracing) and the clear case (omit file_path). It does not name alternative tools for when a reference overlay is the wrong choice, so it falls short of a full 5, but the when/when-not conditions are explicit.

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