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

With no annotations, the description carries the full behavioral burden. It does disclose that the operation is transactional and requires explicit confirmation, which is useful mutation context, but it does not state what existing state may be overwritten, how rollback behaves, or what permissions or preconditions are required.

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

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

The description is a single front-loaded sentence with no filler. Every phrase contributes to identifying the operation, its transactional nature, and its confirmation requirement.

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, a nested preset object, and zero parameter descriptions, the description is too thin. The output schema reduces the need to explain return values, but the description still omits the meaning of texture_set, the preset shape, and the consequences of applying a preset.

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

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

Schema description coverage is 0%, so the description must compensate for the three undocumented parameters. It implies the 'preset' argument and references confirmation, but it never explains 'texture_set' or the nested structure and contents of the preset 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?

The description uses a specific verb and resource: apply a captured baking preset. It also distinguishes this operation from capture_baking_preset and other baking siblings by emphasizing application rather than inspection or configuration.

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

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

The phrase 'after explicit confirmation' gives a prerequisite for use, but the description does not compare this tool against alternatives such as configure_baking, preflight_bake, or apply_fill_preset. The usage context is implied rather than fully specified.

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

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

No annotations are provided, so the description carries the full burden. 'Apply' signals a mutation that presumably overwrites existing fill settings, but the description never says what prior state is replaced, whether presets must pre-exist, or whether permissions/resources are required. Only the 'named preset' phrasing hints at a dependency.

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 efficient sentence with no padding, and the action is front-loaded. Its problem is under-specification rather than verbosity, which caps it at adequate.

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

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

An output schema exists, so return values need not be described, but for a 3-parameter mutation tool with zero annotation coverage and zero schema descriptions the definition leaves too much unknown. An agent cannot tell what uid refers to or what applying a preset does to current fill state.

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

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

Schema description coverage is 0% across three parameters, so the description must compensate and largely doesn't. It only implies that 'preset' is a name; 'uid' (which object type?) and the optional 'channel' (what a channel selection does here) are completely unexplained.

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

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

The definition names a specific verb+resource (apply a named preset) and enumerates the source kinds it targets: Fill, Fill Effect, Generator, Filter. That distinguishes it from apply_baking_preset and apply_smart_mask in the sibling list, though the target object (uid) is left unnamed.

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

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

There is no statement of when to reach for this versus set_fill_parameters, set_fill_resource, or apply_baking_preset, and no prerequisites (does the layer need to be a fill layer? must the preset already exist?). Usage is only inferable from the title.

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

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

No annotations are provided, so the description must carry the behavioral burden. It hints at a transactional insertion but does not disclose whether an existing mask is replaced, whether the layer must be selected or unlocked, what permissions or resource formats are required, or how failures behave.

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 text. It communicates the action and target 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?

The tool is a mutation with no annotations and completely undocumented parameters. An output schema exists, so return values need not be explained, but the description is still too thin for an agent to call this safely and correctly.

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

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

Schema description coverage is 0%, so both parameters need explanation. The description only weakly implies that uid identifies the layer and resource_url identifies the Smart Mask resource; it does not clarify expected formats, identifiers, or constraints.

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: apply a Smart Mask resource to a layer. This is clear enough to understand the operation, but it does not differentiate the tool from nearby siblings such as insert_mask_effect or set_layer_mask.

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 insert_mask_effect, set_layer_mask, or insert_smart_material. The phrase 'using transactional mask insertion' describes mechanism, not usage conditions, 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 provided, the description carries the full disclosure burden. 'Audit' strongly implies a non-mutating inspection and there are zero parameters, so there is little risk of unintended writes, but the description says nothing about cost, coverage limits (whole project vs. selection), or what happens on large projects.

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

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

One front-loaded sentence with no filler; every word earns its place by naming an audited domain. It is efficient but flat, with no structure to signal which domain matters most or how results are organized.

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

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

An output schema exists, so return values need not be described, and the zero-parameter schema is trivially complete. What is missing is behavioral framing for a zero-arg project-wide diagnostic: whether it is read-only, how heavy it is, and whether it scopes to the whole project or the current selection.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. Nothing in the description contradicts or obscures the empty 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 uses a specific verb ('Audit') and enumerates the four domains covered: texture sets, channels, layer hygiene, and outdated resources. That is enough to distinguish it from pure listers like list_layers or find_outdated_resources, though it never names a sibling or explains how the combined audit relates to those narrower tools.

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

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

There is no when-to-use, when-not-to-use, or alternative routing information. An agent cannot tell from the text whether to run this whole-project audit or instead call find_outdated_resources and list_layers individually, nor whether the audit is expensive enough to warrant that choice.

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

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

With no annotations, the description carries the full burden. 'Cooperative cancellation' is genuinely useful — it tells the agent this is a request, not guaranteed immediate termination — but it omits idempotency, what state the job transitions to, whether partial bake output survives, and permission 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?

One sentence, front-loaded with the action and its scope, zero filler. Nothing is wasted or buried.

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

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

The output schema covers return values, so the description needn't explain them. What's missing is operational context: how to obtain job_id, whether to poll get_bake_job afterward, and what happens to in-progress bake results.

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

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

Schema coverage is 0% and the single required parameter job_id is never described. The description does not say where the job id comes from (start_bake / get_bake_job) or what format it takes, leaving the only parameter undocumented in both schema and prose.

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

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

Specific verb+resource ('cancel' + 'bake job') with a meaningful qualifier ('cooperative') that distinguishes it from any hard-kill semantics. It is clearly separable from start_bake/get_bake_job siblings, though it doesn't name them.

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

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

The phrase 'running bake job' implies the applicable state, but there is no explicit when/when-not guidance, no mention of what to do if the job already completed, and no pointer to get_bake_job for checking status before or after.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the output is portable JSON without filesystem-backed properties, but does not clarify whether capture has side effects, required permissions, or mutation/read-only 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 description is a single front-loaded sentence with no filler, and the key qualifier about portability appears immediately. It is efficient, though it omits necessary detail rather than adding it.

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

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

An output schema exists, so return values need not be explained, and no annotations are present. However, with two parameters at 0% schema description coverage and no usage or parameter detail in the description, the definition is not complete enough for reliable 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 description coverage is 0%, and the description does not mention either parameter. It gives no meaning for the required texture_set argument or the optional bakers list, leaving both undocumented beyond their schema titles.

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: capture a baking preset, and adds that the preset is portable JSON without filesystem-backed properties. It is distinguishable from siblings like apply_baking_preset or inspect_baking, though it does not explicitly name alternatives.

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

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

The phrase 'without filesystem-backed properties' hints at a portability use case but does not say when to use this tool rather than inspect_baking, configure_baking, or apply_baking_preset. No alternatives or exclusions are provided.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does not clarify permissions, whether the operation is read-only, what is returned (image data, file path, etc.), or what happens if the channel is missing.

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 with no redundant or filler content. The description is concise and easy to scan, even though it omits necessary details 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?

With three parameters, no annotations, no output schema, and zero schema description coverage, the definition is substantially incomplete. It does not explain the return format, the role of texture_set, or the effect of size_log2, so an agent would need to guess.

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

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

Schema description coverage is 0%, so the description should explain all three parameters. It only gives examples for 'channel' (Roughness, Normal) and does not mention 'texture_set' or 'size_log2', leaving most parameter meaning 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 states a specific resource: one flattened channel rendered as a flat texture, with concrete examples (Roughness, Normal). The verb 'See' is a bit vague about whether this returns an image, a file, or a preview, and it does not distinguish itself from siblings like capture_viewport or capture_turntable.

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 no guidance on when to use this tool versus alternatives such as capture_viewport, capture_turntable, or export_textures. The intended context is only implied by the name and the word 'channel'.

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: the camera is orbited and then the view is restored, so the agent knows the viewport state is not left altered. It says nothing about what the call returns (image files? paths? a list?), where captures land, how many images the angles list produces, or whether it is slow/expensive.

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 action summary followed by parameter hints; every sentence carries information and there is no filler. Slightly hurt by the abrupt line-wrapped fragments ('zoom above 1 moves closer.') that read as notes rather than a structured description.

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

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

For a five-parameter tool with no annotations and no output schema, the description is thin: it never states the return payload or output location, doesn't explain 'angles' or 'max_size', and gives no cost/pagination expectations for a multi-capture operation. An agent could call it but could not predict what it gets back.

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

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

Schema description coverage is 0%, so the description must compensate; it does explain zoom ('above 1 moves closer'), elevation (negative looks up from below) and focus ([x, y, z] orbit point, default model center). It leaves the 'angles' parameter list and 'max_size' entirely undocumented, so roughly two of five parameters remain guesswork.

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 concrete verb chain (orbit, capture each yaw angle, restore view) and a resource (the turntable/camera), so an agent knows this produces multi-angle captures rather than a single frame. It never names how it differs from capture_viewport or capture_channel, which are the obvious siblings an agent would confuse it with.

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?

'for close-ups of one part; it defaults to the model's center' implies a use case for the focus parameter, and 'see every side' implies the multi-angle use case. There is no explicit when-to-use-this-vs-capture_viewport guidance and no statement of prerequisites or when to avoid 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 behavioral burden, yet it discloses nothing about output format, whether an image is returned, or how max_size affects the result. The only content is a brief view-mode distinction.

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 only two short sentences and contains no filler. However, its brevity reflects under-specification rather than tightly packed useful detail.

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

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

For a simple two-parameter capture tool with no annotations or output schema, the description should at least state that it produces a viewport image and explain max_size. Neither is present, leaving meaningful gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It explains the view parameter's two values but says nothing about max_size, leaving half the parameters undocumented.

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

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

The description says only 'Look at Painter,' which is vague and never states that the tool captures a screenshot/image of the viewport. It clarifies the view mode values but does not clearly distinguish the tool's core action from capture_turntable or capture_channel.

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

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

There is no guidance on when to use this tool versus alternatives such as capture_turntable or capture_channel. The view-mode distinction is useful but does not tell the agent when this capture is appropriate.

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

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

With no annotations, the description carries the full burden. It discloses the key refusal behavior and the flag override, which is valuable, but it doesn't say whether discarding is permanent, whether close is reversible, or what permissions or failure modes apply.

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

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

One short sentence, front-loaded with the action and followed immediately by the key guardrail. No wasted words.

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

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

The tool is simple, has only one boolean parameter, and has an output schema, so return values need not be explained. The description covers the essential call behavior and the main failure condition; only deeper mutation/safety context 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 coverage is 0%, so the description must compensate. It does: 'unless discard_unsaved=true' explains the effect of the only parameter in context, which is meaningfully beyond the bare name and default in the schema.

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

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

The description states a specific verb and resource ('Close the open project'), which clearly distinguishes it from siblings like save_project or open_project. It doesn't explicitly name those alternatives, but the purpose is unambiguous.

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

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

It implies when the tool is usable ('open project') and when the flag is required ('refuses unsaved work unless discard_unsaved=true'), but it does not guide the agent to save_project instead of discarding, nor does it state any exclusions or prerequisites beyond the open-project implication.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that configuration is 'transactional', which is a useful behavioral trait (atomicity), but it omits critical details such as required permissions, side effects, what happens to unspecified settings, and whether the operation is destructive or reversible.

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

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

The description is a single, front-loaded sentence with no wasted words. It is efficient, though given the tool's complexity and lack of other documentation, it may be too terse to be fully helpful.

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

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

The tool has 8 parameters with zero schema descriptions and no annotations, making it complex. The description is minimal and does not provide enough context for an agent to invoke the tool correctly, especially regarding parameter meanings and behavioral constraints. An output schema exists, so return values need not be explained, but other gaps remain.

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 vaguely groups settings into 'Texture Set, UV tile, common, and per-baker settings', which partially maps to texture_set, enabled_uv_tiles, common_values, and baker_values, but it does not explain the remaining parameters (confirm, enabled, enabled_bakers, curvature_method) or provide any format or usage details.

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 explicitly states a specific verb (configure) and resources (Texture Set, UV tile, common, and per-baker settings), making the tool's purpose clear. It does not explicitly differentiate from sibling tools like apply_baking_preset or set_baking_mesh_inputs, but the scope is distinct enough that an agent can infer its role.

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 provides no guidance on when to use this tool versus alternatives such as apply_baking_preset, inspect_baking_parameters, or start_bake. There are no exclusions or conditions that would help an agent choose among the many baking-related sibling tools.

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

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

With no annotations, the description carries the full burden. It conveys that this is a creation/mutation and that placement can be relative to reference_uid, but it does not disclose whether a project must be open, what happens with an invalid reference_uid, whether the new layer becomes selected, or whether the operation is undoable.

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

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

Two short sentences with the core action front-loaded and no filler. The position sentence is slightly awkwardly worded ('position is top, or above, below or inside reference_uid'), but it is compact and functional.

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

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

An output schema exists, so return values need not be described, but for a five-parameter mutation tool with 0% schema coverage and no annotations, the description leaves texture_set and name unexplained and omits preconditions and side effects. It is under-specified for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate for five parameters. It adds real meaning for base_color (sRGB [r,g,b]) and position (top/above/below/inside relative to reference_uid, which is not expressed in the schema), but name and texture_set receive no explanation at all.

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

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

States a specific verb and resource ('Create a Fill Layer'), which distinguishes it from create_paint_layer, create_group, and insert_smart_material by resource type. It stops short of explicitly naming a sibling or contrasting use cases, so it is clear but not fully differentiated.

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

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

The description explains how to use two parameters but never says when to choose this tool over create_paint_layer or insert_smart_material, nor does it state prerequisites such as an open project or an existing reference layer. No when/when-not guidance is present.

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, yet says nothing about whether the layer stack is reordered, what happens when reference_uid is null while position is 'above'/'below'/'inside', permission or project-state requirements, or whether the group is empty on creation. It hints at placement semantics but does not resolve them into actionable behavior.

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

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

A single front-loaded sentence with no padding, which is the right shape for a simple creation tool. However, the comma-laden clause 'at the top, or above, below or inside reference_uid' reads ambiguously and forces rereading, so brevity comes at the cost of parseability.

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

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

An output schema exists, so return values need not be explained, but for a 4-parameter mutation tool with zero annotation coverage and zero schema descriptions, the single sentence leaves most call-critical information missing — notably the valid position values and the meaning of texture_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 description coverage is 0% and only two of four parameters get any mention: reference_uid is named, and position is gestured at through the 'top, above, below or inside' phrasing — but without stating those are the accepted token values, which the schema itself does not enumerate. 'name' and 'texture_set' are entirely undocumented anywhere.

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

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

States a specific verb and resource ('Create a layer group'), which distinguishes it from create_fill_layer and create_paint_layer in the sibling list. The scope caveat that placement is relative to a reference layer adds usefulness, though the phrase 'at the top, or above, below or inside reference_uid' is grammatically muddled and never says plainly what 'top' means.

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 create_fill_layer, create_paint_layer, or insert_smart_material, and no prerequisites (must a project be open? must layers exist?). The agent must infer everything about selection 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 behavioral burden. It usefully discloses that creation is atomic and that a backup may be saved first, but it omits permissions, failure behavior, what an 'approved .spp' means, and how overwrite_backup affects existing backups.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the action and the optional backup behavior.

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?

This is a mutation tool with a required nested recipe array, five parameters, and no annotations, yet the description is extremely thin. The output schema may cover return values, but the input semantics and behavioral context are far too sparse for an agent to invoke it confidently.

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

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

Schema description coverage is 0% across five parameters, so the description must compensate. It mentions the recipe and backup concepts but does not explain backup_mode, backup_path, texture_set, or overwrite_backup, leaving most parameter meaning 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: creating a nested recipe atomically, with an optional .spp backup. This is clear enough to understand the operation, but it does not explicitly distinguish it from the sibling plan_layer_recipe or clarify that it is a layer recipe.

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 guidance on when to use this tool versus plan_layer_recipe or other layer-creation siblings. The phrase 'optionally saving an approved .spp backup first' hints at a backup option but does not state when that option should be used or what conditions make this tool appropriate.

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

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

No annotations exist, so the description carries the full burden. It implies a mutation (creating a layer) and mentions relative placement, but omits side effects, whether the layer becomes selected/active, what happens if reference_uid is omitted, and permission 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?

It is a single front-loaded sentence with no filler, but the wording is awkward and under-specified rather than crisp. Brevity here comes at the cost of clarity.

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

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

Output schema exists so return values needn't be explained, but for a mutation tool with no annotations and 0% schema coverage, the description leaves key parameters and behavioral effects undocumented. An agent would have to guess how name, texture_set, and position defaults 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 0%, so the description must compensate for all four parameters. It vaguely touches position and reference_uid but never mentions name (required) or texture_set, and does not enumerate valid position values (top/above/below/inside).

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 concrete verb and resource ('Create a Paint Layer') and hints at placement relative to a reference. However, the placement phrasing 'at the top, or above, below or inside reference_uid' is grammatically garbled and does not distinguish this tool from siblings like create_fill_layer or create_group.

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

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

No guidance on when to use this tool versus create_fill_layer, create_group, or insert_smart_material. It also does not explain when reference_uid 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?

With no annotations at all, the description carries the full burden, and it discloses only that a backup happens and that the file is verified. It says nothing about what the backup touches, whether existing projects are replaced, whether the call is blocking or returns a job, or what confirm/overwrite mean behaviorally — significant gaps for a mutating tool with destructive-sounding flags.

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 main action front-loaded and no filler. It is efficient, though the brevity is partly achieved by omitting information the agent actually needs.

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

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

An output schema exists, so return values need not be explained, but for an 11-parameter mutation with no annotations the description is far too thin. Critical details — the role of confirm, what overwrite/replace_current destroy, and the relationship to the plan/job siblings — are absent.

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

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

Schema description coverage is 0% across 11 parameters, so the description must compensate and largely does not. 'Back up an optional current project' only loosely gestures at backup_mode/backup_current_path, and nothing explains confirm, overwrite, replace_current, overwrite_backup, settings, template_file_path, or mesh_map_file_paths.

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

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

The description uses specific verbs and a resource: back up the current project, create a typed project, verify the file. An agent can tell this is the creation step rather than a status/list tool. It stops short of distinguishing itself from siblings like plan_project_creation or get_project_creation_job, which appear to belong to the same plan/execute/job family.

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 instead of plan_project_creation, get_project_creation_job, or open_project, and no stated prerequisites (for example, whether planning must happen first or whether confirm must be set). The agent must infer the workflow position 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 provided, the description carries the full behavioral burden, and it only says that the operation modifies the open project. It does not disclose whether deletion is permanent, whether deleting a group deletes its contents, or what permissions or project state are required.

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

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

The description is two short sentences with no wasted phrasing. The primary purpose is front-loaded, followed by the most important behavioral note.

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

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

An output schema exists, so return values need not be explained, but this is a destructive mutation with no annotations. The description is insufficiently complete about safety, irreversibility, group deletion semantics, and how to identify a valid UID.

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

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

Schema coverage is 0%, so the description must compensate for the undocumented uid parameter. It does identify that the argument is a UID and that it can refer to a layer or group, but it does not explain UID format or where to find valid UIDs.

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: delete a layer or group by UID. It clearly distinguishes this tool from sibling layer tools such as create_paint_layer, rename_layer, and list_layers, which do not delete 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 description implies the tool is used for deletion but gives no guidance on when to use it versus alternatives, how to obtain the UID, or whether deletion is reversible. It also does not mention prerequisites such as selecting or locating the target layer first.

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

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

No annotations exist, so the description carries the burden, and it does establish this is a non-mutating comparison producing a structured change report rather than an edit. However, it omits important behavior: whether mismatched or stale snapshots are rejected, whether it is read-only, and how 'changed' is determined. An output schema exists, so return formatting is not required here.

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

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

A single tight sentence with the action, the inputs, and the result shape front-loaded. Nothing is padded and nothing needs trimming.

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

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

The output schema covers the return value, so the description need not enumerate result fields. But for a two-argument tool with nested, fully undocumented object parameters, the description should at least say where the snapshot objects come from and what constraints they must satisfy; those gaps are unfilled.

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 both parameters are opaque 'object' types with no titles or descriptions, so the description must compensate. It only indirectly implies the parameters are layer snapshots and introduces 'by UID', which actually creates ambiguity about whether before/after are snapshot objects, UID strings, or payloads from snapshot_layer_tree.

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 ('Compare') and resource ('two layer snapshots') and names the output shape (added, removed, changed nodes), so the operation is unambiguous. It does not explicitly point at the sibling that produces snapshots (snapshot_layer_tree) or distinguish itself from list_layers/find_layers, so it falls short of full sibling differentiation.

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

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

Usage is only implied: an agent can infer this is the tool for spotting drift between two captured layer-tree states. There is no stated precondition (e.g. both snapshots must come from the same project/layer tree), no mention of the paired snapshot_layer_tree tool, and no guidance on when a plain list_layers call would suffice instead.

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

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

With no annotations, the description carries the full burden. It usefully discloses state persistence between calls and how values are returned via `result` or printed `output`, but it omits key behavioral details such as side effects, security scope, failures, timeouts, and execution 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?

The description is short and front-loaded: the gating condition appears first, followed by only the essential persistence and return-value semantics. Every sentence adds useful information.

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

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

An output schema exists, so the description need not fully explain return values, and it still helpfully notes `result` and `output`. For a raw code-execution tool with no annotations, however, it should say more about side effects, permissions, and failure modes to be complete.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented `code` parameter. It explains the return conventions using `result` and `output`, but it does not describe what form the code parameter should take or any constraints on the supplied Python.

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

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

The description clearly states the action and resource: executing raw Painter Python. It distinguishes this as a low-level escape hatch through the environment-variable gate, but it does not explicitly contrast it with the many domain-specific sibling tools.

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

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

It gives one important usage condition: only execute when SP_MCP_ALLOW_EXECUTE_PYTHON=1. However, it does not say when an agent should prefer this over dedicated siblings like create_project, configure_baking, or set_fill_parameters.

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 real behavioral constraint not present in the schema — the output path is sandboxed to SP_MCP_EXPORT_ROOTS — which is genuinely useful. However, it says nothing about what happens when the file already exists, what the Auto UV inclusion implies for the written asset, or any failure modes, leaving the mutation semantics largely unexplained.

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 come first and the path constraint follows. It is arguably too terse rather than too long, but nothing is wasted.

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

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

The output schema means return values need not be explained, and the description covers purpose plus the path sandbox. With no annotations and zero schema coverage, the missing piece is overwrite/failure behavior for a write tool, which is a meaningful 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?

Schema description coverage is 0% for two parameters. The description partially compensates for output_path by revealing the export-root restriction, but says nothing about 'overwrite' — whether omission means the call fails on an existing file or silently skips — leaving one of two parameters entirely undocumented.

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

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

States a specific verb ('Export') and resource ('the project mesh'), and adds the notable detail that any Auto UV result is included. It distinguishes itself from the sibling export_textures/export_with_profile tools by naming the mesh as the exported artifact, though it never explicitly contrasts with them.

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

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

Usage is only implied: the export must land inside SP_MCP_EXPORT_ROOTS. There is no statement of when to prefer this over export_textures or export_with_profile, nor any prerequisite (e.g. project open, mesh loaded). The constraint hints at usage but does not guide tool selection.

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

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

With no annotations, the description carries the full disclosure burden. It does add one real behavioral constraint — output is confined to SP_MCP_EXPORT_ROOTS — but says nothing about what 'verified' means, whether export fails or silently succeeds on collision, or how the `overwrite` flag (default false) changes behavior.

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

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

A single front-loaded sentence with no filler, leading with the action and resource. It is efficient, though that efficiency is partly the result of omitting information the agent actually needs.

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

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

An output schema exists, so return values needn't be spelled out. However, for a four-parameter, no-annotation export/mutation tool, the description leaves preconditions, overwrite semantics, naming behavior, and 'verified' undefined — significant gaps for correct invocation.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate and largely doesn't. It implies output_directory is constrained to SP_MCP_EXPORT_ROOTS, which is genuinely useful, but `uid`, `name`, and `overwrite` are left entirely unexplained (whose uid, name of what artifact, overwrite of what).

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 (Export) and a specific resource (a layer mask, materialized as a 'verified Smart Mask'), which is enough to separate it from export_smart_material and export_textures in the sibling list. It stops short of explicitly contrasting itself with those siblings, so an agent must infer the distinction.

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

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

The description gives no when-to-use guidance: nothing about preconditions (e.g. the layer must already have a mask), nothing about when to prefer apply_smart_mask or export_smart_material instead, and no mention of what to do if an export already exists. Usage has to be inferred entirely from the name.

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

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

With no annotations, the description carries the load; it does disclose two real behavioral facts: output is confined to SP_MCP_EXPORT_ROOTS (a sandbox constraint) and the material is 'verified'. It says nothing about what 'verified' entails, whether existing files are replaced, or what failures look like — notable given the 'overwrite' parameter 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 with no filler; the constraint on output location is stated up front. It is tight rather than padded, though its brevity comes at the cost of the missing detail noted elsewhere.

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

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

An output schema exists, so return values need not be described, but for a file-writing export tool with no annotations and four undocumented parameters (0% coverage) the definition leaves key questions open: which group uid refers to, what happens when overwrite is false and the target exists, and how 'verified' is determined.

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

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

Schema coverage is 0%, so the description must compensate, and it barely does: 'a group' loosely implies uid identifies a group, and the export-roots clause constrains output_directory. Nothing explains what 'name' names, what 'overwrite' does, or the format of uid.

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 ('Export'), a specific source object ('a group') and a specific artifact ('a verified Smart Material'), plus a hard output boundary (SP_MCP_EXPORT_ROOTS). That is enough to distinguish it from siblings like export_smart_mask, export_textures, export_mesh and export_with_profile, though it never explicitly contrasts with them.

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

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

No statement of when to use this rather than export_smart_mask or export_textures, no prerequisites, and no note on whether the group must already be selected or created. Usage is only implied by the tool's name and the word 'Export'.

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

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

With no annotations, the description carries the full burden. It does disclose two genuinely useful traits: output is confined to SP_MCP_EXPORT_ROOTS and each written file is verified. It omits overwrite semantics (despite an overwrite parameter defaulting to false), failure/partial-write behavior, and permission requirements 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?

A single front-loaded sentence with zero filler; the safety boundary and verification guarantee are stated up front. Nothing is redundant.

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

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

An output schema exists, so return values need not be explained. But for a 7-parameter mutation tool with no annotations and no parameter documentation, the description leaves too much unspecified — particularly the required preset vocabulary and the overwrite/bit-depth behaviors that materially change the result.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and does not. It never mentions preset, output_directory, overwrite, bit_depth, size_log2, file_format, or texture_sets, leaving the agent to guess valid values and defaults from bare titles.

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 ("Export textures") plus a distinctive behavior ("verify every output file"), which an agent can grasp immediately. It does not, however, distinguish itself from siblings like plan_texture_export or export_with_profile, so the agent cannot tell from the description alone which export path to take.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (plan_texture_export, export_with_profile, plan_profile_export). The only implied constraint is the SP_MCP_EXPORT_ROOTS boundary, which is a limitation rather than routing advice.

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 mentions running a profile and verifying outputs, but does not explain write behavior, overwrite semantics, permissions, side effects, or what verification entails.

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

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

The description is a single front-loaded sentence with no filler. It is concise, though the terse phrasing leaves important behavior and parameter details unstated.

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

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

An output schema exists, so return values need not be explained. However, for a five-parameter export operation with no annotations and no schema descriptions, the description is missing too much about inputs, overwrite behavior, and execution scope.

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

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

The schema has five parameters with 0% description coverage, and the description only names the profile concept. It provides no meaning for output_directory, overwrite, size_log2, or texture_sets.

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 action and resource: running an export profile and verifying outputs. It does not distinguish this from siblings such as export_textures, plan_profile_export, or list_export_profiles, so an agent cannot fully infer when this is the right tool.

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

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

The only implied constraint is that execution happens inside SP_MCP_EXPORT_ROOTS. There is no explicit guidance on when to use this instead of plan_profile_export, export_textures, or list_export_profiles.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not say what an empty query returns (all layers?), whether matching is case-sensitive, whether filters are ANDed, or whether results are capped — all material for a search tool. It also omits the texture_set filter entirely.

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

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

A single front-loaded sentence with zero filler; the three filter axes are listed immediately. It is efficient, though the terseness is part of why behavioral and parameter gaps remain.

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

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

An output schema exists, so return values need not be explained, but for a 4-parameter search tool with no annotations the description is thin: one parameter is unmentioned and default/semantics of empty filters are undefined. An agent could call it, but could not predict its results reliably.

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

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

Schema description coverage is 0%, so the description must compensate and it partly does: it clarifies that query matches on partial name while node_type requires an exact match, which the bare schema never states. The fourth parameter, texture_set, is left undocumented in both schema and description, so coverage is incomplete.

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 (Search) plus resource (layers) and enumerates the three filter axes (partial name, exact node type, visibility). An agent can tell this is a filtered lookup rather than a mutation. It does not, however, contrast itself with the sibling list_layers, which is the nearest alternative.

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

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

The description only describes what the tool does; it never says when to reach for it over list_layers or the layer-tree inspection tools (snapshot_layer_tree, diff_layer_snapshots). There are no preconditions, no exclusions, and no note on how filters combine.

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 usefully disclose that the operation is non-destructive ('without modifying the project'). However, it doesn't explain what makes a resource 'outdated', whether the scan is project-wide or limited to selected layers, or any cost/permission implications — meaningful gaps for a no-annotation tool.

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

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

One short sentence with zero waste, and the most decision-relevant fact (non-mutating) is front-loaded after the purpose.

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 there are no parameters to document. What is missing is domain context: the criteria for 'outdated' and the scope of the scan, which an agent needs to decide whether this is the right tool versus list_project_resources or search_resources.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

States a specific action ('plan project-resource replacements') against a specific resource, and the name plus description together make clear it identifies outdated resources. It doesn't name the sibling replace_outdated_resources explicitly, but 'without modifying the project' signals the read-only distinction from that mutation tool.

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

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

The phrase 'without modifying the project' implies this is the planning step before a replacement operation, but no explicit when-to-use, prerequisites, or named alternative (e.g., replace_outdated_resources) is given. The agent must infer the workflow from the sibling names.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It indicates a read-oriented status check but does not explicitly state that it is non-destructive, whether it blocks or polls, what happens if the job is missing, or any auth/rate-limit considerations. The output schema may cover return shape, but behavioral traits are largely left implicit.

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 definition is a single front-loaded sentence with no wasted words. It immediately communicates the action and the two supported job-selection modes.

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

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

The output schema exists, so the description need not explain return values in detail. However, for a job-status tool with no annotations, the description is only minimally complete: it omits polling expectations, error behavior, and how it fits into the bake workflow alongside start_bake and cancel_bake.

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 only parameter is undocumented in the schema beyond 'Job Id' with a null default. The description compensates by explaining that the tool returns the latest job by default or a selected job when an identifier is supplied, which is meaningful semantic guidance for the optional job_id 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?

The description states a specific verb ('Return') and resource ('progress and terminal status') for a bake job, and clarifies that it works for either the latest or a selected job. It is clear enough to distinguish from siblings like start_bake or cancel_bake, though it does not explicitly name those alternatives.

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

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

The description implies polling usage through 'progress and terminal status' but gives no explicit guidance on when to call it, when not to call it, or how it relates to start_bake, cancel_bake, or other job-status siblings such as get_mesh_reload_job. An agent must infer the workflow.

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

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

No annotations are provided, so the description carries the burden. "Report" implies a read-only operation, and "runtime-supported" and "version-sensitive" add some useful context, but it does not state side effects, permissions, or whether results vary by environment. The output schema covers return values.

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 clear sentence with no wasted words. The key information is front-loaded and easy 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 zero-parameter capability-discovery tool with an output schema, the description is nearly complete. It specifies the categories of information returned, though it could say more about runtime context or how to use the result.

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

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

The tool has zero parameters, so there is no parameter semantics to document. Baseline score 4 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?

Uses a specific verb ("Report") and names the exact resources: runtime-supported channels, blend modes, and version-sensitive features. It is distinguishable from siblings like get_project_info or painter_status, though it does not explicitly contrast itself with them.

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

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

The intended use is implied by the name and description—call it to discover runtime capabilities—but there is no explicit when-to-use guidance, prerequisites, or comparison to alternative tools. Adequate but not instructive.

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 behavioral burden; 'Inspect' implies a non-destructive read, which is the key safety signal, and the UID provenance hint adds workflow context. It does not say whether results reflect live state, whether presets are included in the response, or what the 'channel' scoping does.

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

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

Two short sentences, front-loaded with the purpose before the workflow hint, with no filler. The 'tune' phrasing is the only slightly wasteful/ambiguous word.

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

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

An output schema exists, so return values need not be described, and the description covers what the tool operates on and where UIDs come from. The unexplained 'channel' parameter and the absence of any read-only or side-effect statement leave gaps for a tool with no annotations.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partially does: it explains where UIDs come from (snapshot_layer_tree) but not what kind of object the UID identifies at call time. The 'channel' parameter is never mentioned in the description or the schema, leaving one of two arguments fully 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 ('Inspect') and resource ('parameters and presets of a Fill, Fill Effect, Generator or Filter'), which clearly distinguishes it from the sibling setter set_fill_parameters. It stops short of naming that sibling explicitly, so the read-vs-write contrast is inferred 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?

'Use it to tune generators such as edge wear' gives a context of use, and 'Effect UIDs come from snapshot_layer_tree' gives the prerequisite for obtaining the required argument. However, 'tune' muddies the read-only intent, and there is no explicit statement of when to use this versus set_fill_parameters or get_procedural_inputs.

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

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

No annotations exist, so the description carries the full behavioral burden. "Inspect" does convey a non-mutating read, which is the most important trait, but it says nothing about error behavior on non-fill layers, required permissions, or whether the "common UV transformation" is a normalized summary versus raw values.

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 target come first and nothing is redundant.

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

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

An output schema exists, so return-value explanation is appropriately omitted, and the tool is simple. However, the undescribed uid and the unstated precondition that the layer be a Fill layer leave meaningful gaps for a call that will fail outright with a wrong or non-fill uid.

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 single parameter 'uid' is completely undocumented in both schema and description. The description never states that uid identifies the target layer, nor what kind of identifier it is — leaving the caller to guess.

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 ("Inspect") and a specific resource ("a Fill layer's projection mode and common UV transformation"), which cleanly signals a read operation on fill projection state. It implicitly separates from the sibling mutators set_fill_projection / set_fill_projection_advanced, though it never names them explicitly.

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

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

There is no when-to-use guidance, no prerequisites (e.g. that the layer must be a Fill layer), and no mention of the sibling set_fill_projection / set_fill_projection_advanced as the write-side counterparts. An agent must infer the read-before-write workflow entirely on its own.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Inspect' strongly implies a read-only operation and it scopes the inspection to material or per-channel color/resource sources, but it does not explicitly state read-only behavior, prerequisites, or whether the target must be a Fill layer. The output schema reduces the need to describe return values.

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

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

The description is a single front-loaded sentence with no filler, starting with the verb and immediately stating what is inspected. It is efficient, though quite terse given the missing usage and parameter context.

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

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

An output schema exists, so the description need not explain return values. However, for a one-parameter tool with no annotations, it leaves the sole uid parameter undefined and provides no usage context, making the definition incomplete for reliable invocation.

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

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

The schema has one required integer parameter, uid, with 0% description coverage, and the tool description never mentions uid or explains what it identifies. The phrase 'a Fill layer's' is only an indirect clue 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?

The description uses a specific verb ('Inspect') and a specific resource ('a Fill layer's material or per-channel color/resource sources'), so the agent can tell it retrieves fill-source information rather than mutating it. It does not explicitly differentiate itself from sibling getters like get_fill_parameters or get_fill_projection, which keeps it from 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 exclusions, and no named alternatives despite many closely related fill-related sibling tools. The only implied usage is 'inspect,' leaving the agent to infer when this should be preferred over get_fill_parameters or get_fill_projection.

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. Beyond 'inspect' hinting at a read operation, it says nothing about permissions, side effects, or what 'available elements' means for a non-authored mask; an output schema exists but behavioral context is still missing.

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

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

A single efficient sentence that front-loads the verb and resource with no wasted words. Appropriately sized for a simple one-parameter read 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?

The presence of an output schema means return values need not be explained, but the absent annotations and undocumented uid leave the definition thin for a tool whose data model ('Mesh/UVTile geometry mask') is non-obvious. Adequate but with clear gaps.

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

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

Schema coverage is 0% and the sole 'uid' parameter is documented only as an integer with no description. The phrase 'a layer's' weakly implies uid identifies a layer, but the description adds no format, source, or lookup guidance to compensate for the empty 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 ('Inspect') and resource ('a layer's Mesh/UVTile geometry mask and available elements'), which clearly distinguishes it from the sibling set_geometry_mask by its read/inspect orientation. The lack of an explicit sibling callout keeps it from 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?

Usage is only implied by the verb 'Inspect' contrasted against the write-oriented sibling 'set_geometry_mask'; there is no explicit when-to-use or when-not-to-use guidance. An agent can infer the read-vs-write split but must do the work 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 must carry the behavioral weight; it does signal a read-only inspection and that texture-set changes are part of the payload. However, 'for the latest mesh reload job' sits uneasily against the optional job_id parameter, leaving it unclear whether this tool targets the most recent job or an arbitrary one.

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

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

One short sentence of eleven words with the verb front-loaded and no wasted clauses. It is efficient, though the phrase 'latest ... job' arguably spends words on a scoping claim that is ambiguous rather than clarifying.

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 the return payload need not be described, and with one optional parameter the tool is simple. Still, for a job-status tool an agent needs to know the lifecycle context (call after start_mesh_reload, how terminal states are reported) and the job_id default rule, neither of which is covered.

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

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

The single parameter has 0% schema description coverage, and the description never explains job_id: not what format it takes, not what happens when it is omitted (default null), not whether it must come from start_mesh_reload. The word 'latest' only hints at the default behavior without defining 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 ('Return') and resource ('status and texture-set changes for the latest mesh reload job'), which is enough to separate it from the planning/mutation siblings plan_mesh_reload and start_mesh_reload. It does not, however, state how it relates to the other job-polling siblings such as get_bake_job or get_project_creation_job.

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 at all on when to call this tool: no mention of polling after start_mesh_reload, no mention of what to do if no job exists, and no named alternative. The only implicit cue is the word 'latest'.

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. 'Inspect' implies a read-only operation, but the description says nothing about permissions, error behavior for invalid uids, or side effects; beyond the verb there is essentially no 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?

A single efficient sentence with the verb and scope front-loaded and no filler. It is concise to the point of under-specification, but that is a completeness issue rather than verbosity.

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

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

An output schema exists, so return values needn't be explained, but with zero annotation coverage and zero schema descriptions the definition omits critical parameter meaning and usage context. The agent knows what domain this touches but not how to call it correctly.

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

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

Schema description coverage is 0% for two parameters, and the description never mentions 'uid' or 'channel'. The channel selector in particular is undocumented, leaving the agent to guess its meaning and valid 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 (Inspect) and resource (image inputs) with a scoped list of source types (Fill, Fill Effect, Generator, Filter). It does not distinguish itself from nearby siblings such as get_fill_sources or get_fill_parameters, and the 'procedural inputs' vs. 'image inputs' terminology is slightly loose.

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 get_fill_sources or get_fill_parameters, no prerequisites (e.g., project/layer must exist), and no exclusions. The source-type list implies scope but does not route the agent among 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 supplied, so the description carries the full behavioral burden and largely drops it. It never says whether this blocks, whether it is safe to poll repeatedly, what it returns while the job is still running, or what error surfaces for an unknown job — only that it reads 'terminal state' and 'file verification'.

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 of ten words with zero filler; the object of the read is placed before any qualification. Nothing in it could be trimmed without losing 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 explained, but the tool is still under-specified for its async-job role: no polling guidance, no null-job_id behavior, and no mention of the companion creation tools. For a job-inspection endpoint with a deliberately nullable key, the description leaves the operational essentials unstated.

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

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

Schema description coverage is 0% and the single parameter job_id is optional with a null default, which is a semantically significant fact the description completely ignores. An agent cannot tell from the description what happens when job_id is omitted (most recent job? error? listing all?), so almost no meaning is added 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?

The description names a specific verb ('Read') and a specific resource ('terminal state and file verification for an asynchronous project creation'), which an agent can map to a job-status tool. It does not, however, name the sibling that starts such jobs (create_project/plan_project_creation), so differentiation relies on the reader's knowledge of the async pattern.

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?

Use is only implied: the phrase 'for an asynchronous project creation' suggests calling this after kicking off a creation job, and the sibling set (get_bake_job, get_mesh_reload_job, get_shelf_refresh_job) reinforces that pattern. There is no explicit when-to-use, no alternative named, and no statement about polling or when to stop.

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 disclosure burden; 'Return' implies a read-only, side-effect-free call, and it names the returned data. However, it says nothing about behavior on no-open-project, permissions, or freshness of the values, which are the traits an agent would want for a zero-param query tool.

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

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

A single front-loaded sentence with no filler; the most useful information (project path, texture-set names) appears immediately. Nothing is padded or restated from the name.

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

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

For a zero-parameter read tool with an output schema covering the return shape, the description is almost sufficient; the only gap is edge-case behavior (e.g., no project open) which the output schema can't convey.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. It correctly adds no parameter discussion, keeping focus on the returned 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 ('Return') and the exact resources ('current project path and texture-set names'), so an agent can tell what it produces. It doesn't explicitly distinguish itself from siblings like list_project_resources or audit_project, but the described output is precise enough to characterize the tool.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternative tool. An agent must infer from the output description alone that this is the lightweight 'what project am I in' check versus heavier inventory tools.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Read persistent state' implies a safe, non-mutating operation and that state survives beyond the call, but nothing is said about behavior with an unknown job_id, job expiry/retention, or concurrency concerns.

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

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

A single efficient sentence with the resource front-loaded and zero filler. It is terse to the point where a little more content (polling/lifecycle) would have earned space, but nothing present is wasted.

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

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

An output schema exists, so return-value explanation is not needed, and a one-optional-parameter getter is simple. Still, the relationship to start_shelf_refresh and the meaning of a job's lifecycle are unstated, leaving the agent to infer the workflow.

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

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

Schema coverage is 0% for the single optional job_id parameter, so the description must compensate. 'Latest or selected' does add real meaning — omitting job_id returns the newest job — but it does not clarify format, validity, or error behavior for an unknown id.

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

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

The description uses a specific verb ('Read') on a specific resource ('persistent state ... shelf refresh job'), which cleanly separates it from the sibling 'start_shelf_refresh' that initiates a job. It stops short of naming that sibling explicitly, but the read-versus-start distinction is inferable from the text alone.

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

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

The phrase 'latest or selected' implicitly tells the agent it can call this without a job_id to get the newest job, but there is no explicit when-to-use guidance, no mention of calling it after start_shelf_refresh to poll progress, and no named alternative.

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, yet it does not say whether this mutates the project persistently, what 'verify' actually checks, what 'sandboxed' constrains, or what the `confirm` flag gates. For a write-ish import operation with a confirmation parameter, this is a substantial gap.

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

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

A single front-loaded sentence with no filler, which is structurally clean, but it is under-specified rather than appropriately concise for a five-parameter mutation tool.

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

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

An output schema exists so return values needn't be described, but with zero annotation coverage, 0% parameter documentation, and a confirmation gate, the description leaves an agent unable to call this correctly without guessing.

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

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

Schema description coverage is 0% across 5 parameters, and the description names none of them. Terms like `usage`, `group`, `name`, and especially `confirm` (default false) are left entirely unexplained, so the description adds no meaning beyond the bare schema.

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

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

States a specific verb ('Import and verify') and resource ('sandboxed resource') scoped to the open Painter project, which distinguishes it from shelf/session variants in spirit. It never names the sibling tools (import_shelf_resource, import_session_resource) that an agent would otherwise confuse it with, so the differentiation is only implicit.

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

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

There is no when-to-use guidance, no prerequisites (must a project be open? does the file need to be in a sandbox?), and no mention of the closely related siblings that handle other import scopes. The agent must infer everything from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Import' implies a write, and 'verify' implies a post-import validation step, but neither is explained: it does not say what gets written into the session, whether an existing resource is overwritten, whether the operation is reversible, or what 'verify' actually checks.

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 with no filler, which is structurally clean. However, for a five-parameter tool with a confirmation gate, one sentence provides no structure to organize the invocation details an agent needs.

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

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

An output schema exists, so return values need not be described, but everything else is missing: five undocumented parameters, no annotation coverage, no sibling differentiation, and no explanation of the verify step or the confirm gate. For an import/mutation tool this leaves the agent materially under-informed.

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

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

Schema description coverage is 0% across five parameters, and the description adds no information about any of them. The required file_path and usage, the optional name/group, and especially the confirm boolean are all left entirely unexplained.

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

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

The description names a specific verb (import) plus a verification step and a scoped resource (sandboxed resource for the current Painter session). It is clear on its own, but it does not distinguish itself from the close siblings import_project_resource and import_shelf_resource, which an agent must choose between.

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 rather than import_project_resource or import_shelf_resource, and no mention of prerequisites such as the session being open. The presence of a 'confirm' flag suggests a gated or potentially destructive step, but the description never says when confirmation is required or what happens without 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?

No annotations are provided, so the description carries the full burden. For an import/mutation tool it says nothing about permissions, whether an existing resource is overwritten, what 'verify' entails, what the 'confirm' flag gates, or what side effects occur on the shelf — all significant gaps.

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

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

A single sentence with no wasted words, but it is under-specified rather than concise — brevity comes at the cost of the operational detail an agent needs.

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

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

An output schema exists so return values need not be described, but with six undocumented parameters, no annotations, and a destructive-looking import operation, the description leaves too much unstated for an agent to call it reliably.

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

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

Schema description coverage is 0% across six parameters, so the description must compensate and it does not: file_path, usage, confirm, name, group, and shelf_name are all undocumented anywhere. In particular, the required 'usage' string and the confirm-gate are entirely opaque to the agent.

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 verb+resource ('Import and verify a ... resource') and a target ('an editable shelf or the user shelf'), which conveys the general action. However, 'safe resource' is unexplained jargon and it never distinguishes itself from sibling importers such as import_project_resource and import_session_resource, so an agent cannot tell which shelf-scoped import to pick.

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

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

There is no guidance on when to use this versus import_project_resource, import_session_resource, or start_shelf_refresh, all of which appear in the sibling list. The only implicit cue is the phrase 'editable shelf or the user shelf', with no statement of 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation by saying 'Insert' and lists effect types, but it does not disclose required permissions, side effects, failure behavior, or how it interacts with the target layer beyond that.

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

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

The description is a single front-loaded sentence with no wasted wording. Its brevity is appropriate structurally, though it reflects under-specification rather than rich conciseness.

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

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

For a mutation tool with four parameters, no annotations, and 0% schema description coverage, the description is not complete enough to guide reliable invocation. It does not clarify required inputs, layer context, effect_type constraints, or resource_url behavior, even though an output schema exists.

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

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

Schema description coverage is 0%, and the description only hints at acceptable effect_type values by naming Fill, Paint, Generator, Filter, Levels, and Anchor. It does not explain the required uid, optional name, or resource_url parameters, leaving most parameter semantics 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 states a specific verb and resource: inserting content effects such as Fill, Paint, Generator, Filter, Levels, or Anchor into a layer's content. It is clear what the tool does, though it does not explicitly distinguish itself from nearby siblings like insert_mask_effect or create_fill_layer/create_paint_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 guidance on when to use this tool versus alternatives such as insert_mask_effect, create_fill_layer, create_paint_layer, or insert_smart_material. The implied usage is inserting a content effect into a layer, but no exclusions or prerequisites are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but does not disclose side effects, permission requirements, whether existing mask effects are affected, or any other operational 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?

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though its terseness leaves important gaps that are better captured under 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?

With no annotations, 0% schema description coverage, and four parameters, the description is not complete enough for reliable invocation. The output schema exists, so return values need not be explained, but input semantics and behavioral context are largely 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 is 0%, so the description must compensate for four undocumented parameters. It enumerates possible effect_type values, which adds some meaning, but it says nothing about uid, name, or resource_url.

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: inserting one of several named effect types into a mask. It is clear enough to distinguish from generic layer creation, but it does not explicitly differentiate itself from siblings such as insert_content_effect or apply_smart_mask.

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 effect types but gives no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. An agent must infer usage from the name and sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only states that an insert occurs and says nothing about permissions, whether existing content is overwritten, what side effects occur, or how positioning affects the layer tree.

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 definition is a single front-loaded sentence with no filler, and the verb is placed first. It is efficient, though the terseness contributes to under-specification 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?

The tool has six parameters, no annotations, and no schema descriptions, yet the description covers only positioning. Output schema existence reduces the need to explain return values, but the description still leaves required inputs and mutation behavior 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 0%, so the description must explain all six parameters. It only clarifies parent_uid, reference_uid, and the 'top' position; the required resource_url, plus name and texture_set, are left unexplained.

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

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

The description uses a clear verb and resource, 'Insert a Smart Material,' and adds positioning context with 'at the top, inside parent_uid, or relative to reference_uid.' It does not explicitly distinguish this tool from any sibling, but the purpose itself is specific and 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 implies three insertion modes (top, inside parent_uid, relative to reference_uid), which gives some invocation guidance. However, it never states when to choose this tool over alternatives such as import_project_resource, import_shelf_resource, or insert_content_effect, and it omits prerequisites entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Inspect' and 'without starting a bake' imply a read-only, non-mutating operation, but the description does not explicitly confirm read-only behavior, permissions, or 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?

The description is a single, front-loaded sentence with no wasted words. It efficiently states the tool's scope and the key constraint of not starting a bake.

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

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

An output schema exists, so return values need not be explained. However, the description omits parameter semantics and, with no annotations, does not fully cover behavioral details such as read-only guarantees or usage relative to sibling tools.

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

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

There is one optional parameter, texture_set, with 0% schema description coverage. The description never mentions this parameter or explains how it filters the inspection, so it fails to compensate for the schema 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 uses a specific verb ('Inspect') and resource ('baking'), and enumerates what is inspected: enabled bakers, UV tiles, and mesh-map assignments. It does not explicitly distinguish itself from the sibling tool inspect_baking_parameters, which prevents a 5.

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

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

The phrase 'without starting a bake' implies this is a pre-bake inspection tool, giving some usage context. However, it does not state when to use this versus inspect_baking_parameters, preflight_bake, or other baking-related siblings.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only inspection, but does not state whether it mutates anything, what permissions are needed, or how the editable versus non-editable parameters behave. It also does not clarify the interaction with the required texture_set 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?

The description is a single efficient sentence with no wasted words, but it is under-specified rather than genuinely concise. It front-loads the action but does not provide enough substance for the tool's complexity.

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

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

An output schema exists, so return values need not be explained. However, with two parameters at 0% schema coverage and no annotations, the description leaves too much unspecified, including parameter meanings, read-only behavior, and when this inspection is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate. It only loosely maps 'one baker's' to the optional baker parameter and does not explain the required texture_set parameter, acceptable formats, or what 'typed property metadata' means in practice.

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, 'inspect,' and identifies the resource area: editable common parameters and one baker's typed property metadata. However, 'common parameters' is vague, and it does not distinguish itself from the sibling tool 'inspect_baking' or explain what inspecting yields beyond metadata.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as 'inspect_baking' or 'configure_baking.' The only implied context is inspection of baking parameters, but no exclusions or selection criteria are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the non-mutating nature ("without writing files"), but says nothing about what happens with an unknown/invalid preset, whether texture_set resolution changes the returned map names, or whether resolution requires an open project. For a zero-annotation tool this is a thin 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?

One tight sentence with the verb and the key non-mutation constraint front-loaded and zero filler. Nothing in it is redundant with the schema or wasteful.

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

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

An output schema exists, so return structure need not be explained, and the tool is genuinely simple. However, with no annotations and no parameter documentation, the definition leaves an agent without enough to know how texture_set alters the result or how failures present.

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

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

Schema description coverage is 0%, so the description must compensate and does not. It accounts only for "preset" ("Resolve an export preset") and never mentions texture_set, leaving the optional second parameter's meaning, format, or effect on the previewed map names entirely undocumented.

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

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

The description pairs a specific verb ("Resolve") with a specific resource ("export preset") and states the scope of what is returned ("preview its map names"). The phrase "without writing files" implicitly separates it from export_textures/export_with_profile, though it never names a sibling outright.

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 the pre-flight inspection step before an actual export. There is no explicit "use this when..." or "use export_textures instead when..." routing, and no mention of prerequisites such as the preset needing to already exist.

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. "List" implies a read-only operation, but the description does not explain scope, filtering behavior when texture_set is omitted, permissions, or result limits.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately sized for a simple list 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?

The tool is simple and has an output schema, so return values need not be explained. However, the description leaves the optional texture_set parameter's behavior and the tool's relationship to sibling tools unclear.

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

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

There is one optional parameter, texture_set, with 0% schema description coverage. The description mentions "Texture Set context" but does not explain whether the parameter filters results, what format it expects, or what happens when it is null.

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 ("List") and resource ("Anchor Point effects") plus additional context fields. It is clear what the tool returns at a high level, though it does not differentiate itself from related sibling tools such as set_fill_anchor_source.

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

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

The description gives no explicit guidance on when to use this tool, when not to use it, or which alternatives exist among the many sibling tools. Usage is only implied by the verb "List".

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

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

With no annotations, the description carries the full burden, and it does disclose the key behavioral trait that no files are written, plus the two preset sources. It omits other traits such as whether shelf presets require a running/refreshed shelf or whether results are paginated.

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 scope and the non-mutating guarantee both land immediately.

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

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

An output schema exists and there are no parameters, so the description only needs to convey scope and side-effect profile, which it does. Only the relationship to sibling tools (inspect_export_preset, list_export_profiles) is left implicit.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly adds no spurious parameter discussion.

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

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

States a specific verb (List) and resource (export presets) with the scope qualifier 'built-in and shelf'. The clause 'without exporting files' separates it from export_textures/export_with_profile, though it does not explicitly distinguish it from inspect_export_preset.

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 'without exporting files' phrase signals a discovery step before exporting, but there is no explicit when-to-use guidance or named alternative such as inspect_export_preset for details or list_export_profiles for profiles.

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

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

No annotations are provided, so the description must carry the burden; 'List' adequately implies a read-only, non-destructive operation. However, it says nothing about whether a live Painter connection is required, what 'available' means when a preset is missing, or how curated profiles are sourced — relevant for a tool whose whole value is cross-app preset availability.

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

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

A single front-loaded sentence with no filler; the resource and the notable extra attribute (preset availability) are both stated immediately.

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

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

With an output schema present and no parameters, the description needn't explain return values, and it covers the essentials. It falls short only on prerequisites (Painter running/connected) and how the result feeds export_with_profile or plan_profile_export.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly does not waste space restating an empty 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 ('List') and a specific resource ('curated engine export profiles'), plus an extra attribute (Painter preset availability). It is distinguishable from siblings like list_export_presets and inspect_export_preset by the 'engine profiles' scope, though it never explicitly contrasts with them.

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

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

No indication of when to call this versus list_export_presets, inspect_export_preset, plan_profile_export, or export_with_profile, all of which appear in the sibling list. The usage is only inferable from the phrase 'list ... profiles'; no exclusions or prerequisites are given.

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

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

With no annotations, the description carries the full burden. "List" implies a non-mutating read, and it discloses the shape of what comes back (UIDs, types, visibility, children), which is useful. But it says nothing about ordering, scale/cost of recursion, or whether reads are filtered by the active texture set.

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 the terseness is part of why the usage and parameter gaps exist.

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 the description needn't explain return values, and it appropriately only summarizes them. The remaining gap is behavioral/scoping context: what texture_set does and how this differs from the other layer-listing tools is left to inference.

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 both parameters are undocumented in structured fields. The phrase "optional group children" loosely gestures at the recursive flag, but texture_set — an important scoping parameter with a null default — gets no explanation whatsoever, leaving half the surface ambiguous.

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 ("List layers") and enumerates what the listing contains: stable UIDs, types, visibility, and group children. That is concrete and distinguishable from mutating siblings like rename_layer or set_layer_properties, though it never contrasts itself with find_layers or snapshot_layer_tree.

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

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

There is no statement of when to use this versus close alternatives such as find_layers (presumably searched) or snapshot_layer_tree (presumably for diffing). The word "optional" hints that children may be excluded, but no condition or alternative routing is offered.

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 read-only operation scoped to the currently open project, but it does not explicitly state safety, side effects, or prerequisites beyond the implicit need for an open project.

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

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

A single, front-loaded sentence with no filler. It is appropriately sized for a simple zero-parameter 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?

Given the low complexity, zero parameters, and an output schema that explains return values, the description is nearly complete. It only misses an explicit prerequisite statement that an open project is required.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema. Baseline 4 applies.

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

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

The description states a specific verb ('List') and resource ('resources referenced by the open project'), so the agent can distinguish this from broader resource search tools like search_resources. It is clear, but it does not explicitly name sibling alternatives.

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

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

The phrase 'open project' implies a context, but there is no explicit guidance on when to use this versus search_resources or find_outdated_resources. No exclusions or alternatives are stated.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses that results include 'paths, write capability, and crawling state,' but it does not mention permissions, pagination, or whether the listing triggers any refresh/crawl behavior. The 'List' verb implies read-only, but this is not explicitly confirmed.

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

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

The description is a single front-loaded sentence with no filler. Every phrase contributes either the action or the returned 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?

The tool is a simple zero-parameter list operation and has an output schema, so the description need not explain return values in detail. It covers the resource and the notable fields returned, though it could say more about when to choose this listing over sibling resource-listing tools.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to clarify. The empty input schema is consistent with the description, and the baseline for a zero-parameter tool is 4.

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

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

The description gives a specific verb and resource: 'List Painter shelves,' and adds the returned fields 'paths, write capability, and crawling state.' This clearly distinguishes it from mutating shelf tools like import_shelf_resource or start_shelf_refresh, though it does not explicitly name alternatives.

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

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

There is no guidance about when to use this tool versus alternatives such as list_project_resources or search_resources. The description states what the tool does but provides no conditions, exclusions, or routing hints.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one meaningful trait (backup triggered on a dirty project), but leaves unexplained what 'approved' means, whether unsaved changes are discarded, what 'dirty' is detected from, or whether this is destructive to current state.

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

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

A single front-loaded sentence with no filler; the core action leads and the conditional constraint follows. Nothing is redundant.

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

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

An output schema exists so return values needn't be covered, but for a 5-parameter project-opening operation with zero schema descriptions and no annotations, one sentence is far too thin. The agent lacks the information needed to set confirm, overwrite_backup, or backup_current_path safely.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and it largely does not. The word 'backup' hints that backup_mode, backup_current_path, and overwrite_backup exist, but confirm and project_path receive no explanation and the string/boolean semantics of the backup options are undefined.

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

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

States a specific verb and resource ('Open an approved .spp'), including the file type, which distinguishes it from create_project and plan_project_creation in the sibling set. It stops short of explicitly naming the adjacent tools (close_project, save_project), but an agent can infer the operation unambiguously.

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 one conditional usage rule — a backup is required when the current project is dirty — which tells the agent something about preconditions. It offers no guidance on when to prefer this over create_project or save_project, and no instruction on how to handle 'confirm' or 'overwrite_backup' before invoking.

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