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

With no annotations, the description must disclose behavior, and it does add a key fact: the tool saves a canvas as PNG and returns a CLI command for external execution rather than performing the conversion itself. However, it does not describe side effects (where the PNG is saved, whether the session is modified), prerequisites, or failure modes, leaving significant behavioral 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?

The description is short with no wasted words and front-loads the export purpose before the mechanism. The first and second sentences are slightly redundant in saying Aseprite conversion twice, but overall the structure is efficient.

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

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

There is no output schema, yet the description only says commands are returned without stating their format or how the agent should execute them. Given that external execution is the core behavior, an agent needs more detail about the returned command structure and expected follow-up actions.

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 100%, so session_id and output_name are already documented in the input schema. The description adds no additional meaning about these parameters, which is acceptable but means it earns only the baseline score.

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 concrete action and resource: exporting a canvas session to Aseprite format, and it clarifies the mechanism (saving PNG and producing an Aseprite CLI command). This makes it distinguishable from the other art.aseprite.* siblings (validate, spritesheet, layers). There is minor ambiguity because the first sentence implies a direct .aseprite export while the following sentence reveals the tool only returns a conversion command.

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 does not say when to choose this tool over art.aseprite.spritesheet, art.aseprite.layers, or the many asset/canvas export tools. It only implies usage via the purpose statement and the note that commands are returned for external execution, which is not enough guidance for an agent choosing among siblings.

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

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

With no annotations, the description carries the behavioral burden and does disclose two important behaviors: it writes the script to disk and it only returns the command rather than executing it. It does not specify file paths, overwrite behavior, or permissions, which keeps it from a 5.

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

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

Two sentences with no filler; the first names the deliverable and the second states side effect and return value. Every clause earns its place and key facts are front-loaded.

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 tool with full schema coverage, the description covers purpose, side effect, and return behavior. It is slightly incomplete on usage context and the generated script's details, but nothing critical is missing for calling it.

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

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

Schema coverage is 100%, so the schema already documents session_id and layers, including the defaults and bottom-to-top order. The description adds little parameter-specific meaning beyond tying layers to the 'standard layer structure'.

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 ('Generate') and resource ('standard layer structure'), and states the output is a Lua script plus an Aseprite command. This clearly separates it from sibling Aseprite tools like export, spritesheet, and validate.

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 'set up standard layer structure', but the description gives no explicit when-to-use guidance or alternatives. It does not mention when not to use it or distinguish it from canvas/layer setup siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose a side effect ('The canvas PNG is saved') and clarifies that a CLI command is returned rather than executed. However, it omits details such as where the PNG is saved, whether files are overwritten, whether the command must be run separately, and what the command actually looks like.

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

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

The description is two concise sentences with no filler. The primary action and resource are front-loaded, and the most important behavioral detail—that this returns a CLI command—is included 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?

The tool is relatively simple and the schema covers parameters, but there is no output schema and no annotations. The description explains the basic return concept ('a CLI command is returned') but not the command format, the relationship between the saved PNG and the command, or any prerequisites such as an existing canvas session. These are clear gaps for an agent trying to invoke the tool correctly.

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

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

The input schema already describes all three parameters with 100% coverage, including defaults, ranges, and descriptions. The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action and resource: 'Generate a spritesheet export command for a canvas session.' It also explains the two key outcomes: the canvas PNG is saved and a CLI command is returned. It is distinct enough from siblings like art.aseprite.export because it emphasizes command generation rather than direct export, 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 description gives no explicit guidance about when to use this tool versus art.aseprite.export, art.aseprite.layers, or other Aseprite-related tools. There are no stated prerequisites, exclusions, or alternative conditions. Usage context is only implied by the purpose statement, not explained.

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 and does disclose the key side effect (writes script to disk) and the return value (returns the command). However, it leaves ambiguous whether the tool actually executes the validation or only produces the command for the caller to run, and whether the session/canvas is modified.

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

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

Two sentences with zero filler. The generating action is front-loaded, and the second sentence efficiently packages the side effect and the return value without redundancy.

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

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

Reasonable for a simple 4-parameter tool with full schema coverage, but with no annotations and no output schema the description leaves material questions open: whether validation actually runs or just yields a command string, and where the script is written. An agent cannot tell if the returned command must be executed separately.

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

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

All four parameters already have schema descriptions (100% coverage), so the baseline is 3. The description's 'palette size, dimensions' merely restates what max_colors/width/height convey, adding no genuinely new parameter semantics.

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 ('Generate') with a specific resource (validation Lua script and Aseprite command) and names the check targets (palette size, dimensions). Its subject matter clearly slots it apart from art.validate_style and art.tilemap.validate, though it never names a sibling explicitly to earn a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as art.tilemap.validate or art.validate_style, and no preconditions (e.g., Aseprite availability, session state) are stated. The clause 'to check sprite constraints' restates the purpose rather than providing usage context.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. The description states it's a 'Get' operation, implying read-only, but does not disclose whether it returns full record details, partial information, or if it requires special permissions. For a simple read-by-ID tool, this is adequate but sparse, missing any mention of error behavior or returned data shape.

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, clear sentence that is appropriately concise and front-loaded with the core action. It does its job without fluff or redundancy.

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

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

With a single parameter, no output schema, and no annotations, the description is reasonably complete for a simple fetch-by-ID tool. However, it lacks information about what the response contains or whether the tool is restricted to certain approval states, which could matter for an agent deciding whether to call it.

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

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

The schema description covers 100% of the single parameter, describing 'approval_id' as 'Approval record ID'. The description adds minimal value beyond this, but since coverage is high, the baseline is 3. No additional semantic detail about the ID format (e.g., UUID, numeric) is provided in the description.

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

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

The description 'Get an approval record by ID' uses a specific verb ('Get') and specifies the resource ('approval record') and the lookup key ('by ID'). It clearly distinguishes this from other asset approval tools like art.asset.approve or art.asset.approval.request, which perform different actions. It doesn't explicitly contrast with siblings, but the purpose is unambiguous.

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

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

The description implies usage: use this when you have an approval record ID and need its details. It doesn't provide explicit context on when to prefer this over art.asset.approve or art.qa.history, but the name and description make it reasonably clear this is a read-only inspection tool. No exclusions or alternatives are named.

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

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

No annotations are provided, so the description bears full responsibility for disclosing behavioral aspects. It only states 'Request approval', which is a side-effectful action that likely creates a pending approval record or triggers a workflow. It does not disclose what happens after the request: whether it blocks, notifies human approvers, or returns a decision. The description is minimal but not contradictory.

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 concise sentence, which is efficient for a tool with clear semantics. However, given the complexity of the tool (7 parameters, nested objects), the brevity could be a trade-off; it's under-specified but not verbose. It earns a 4 for being front-loaded and to-the-point.

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

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

Given the tool's complexity (7 parameters, nested objects) and lack of annotations or output schema, the description does not provide enough context for an agent to understand the full purpose of the request, such as what constitutes a candidate asset, the role of the style, or the expected outcome. The description is too brief to be complete for a side-effectful operation.

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

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

While the schema description coverage is 100%, the description does not add any additional meaning to the parameters beyond the schema. The schema already names fields like asset_id, candidate_id, style, and actor, but the description does not explain how they relate to the approval request (e.g., that candidate_id likely refers to the generated asset version being submitted for approval). The description adds little value beyond the schema, so a baseline of 3 is appropriate.

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

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

The description 'Request approval for a candidate asset' clearly identifies the action (request approval) and the resource (candidate asset), distinguishing it from related tools like 'art.asset.approve' (which approves) and 'art.asset.reject' (which rejects). However, it doesn't explicitly differentiate between requesting approval versus directly approving, which could be slightly ambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like 'art.asset.approve' or 'art.asset.request_changes'. The description does not state that this is for initiating an approval workflow rather than finalizing it, nor does it mention any prerequisites such as passing QA or the need for a style reference.

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 disclosure burden. The phrase 'Approve a candidate asset' merely restates the tool's function without revealing side effects, reversibility, permissions required, or downstream consequences. This is a tautological description that adds no behavioral information beyond what the name implies.

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

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

The description is a single, short sentence with no wasted words, which is appropriately concise. It is front-loaded with the core action, but its brevity borders on under-specification; still, for what it does state, it is efficiently structured.

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

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

For a mutation tool with no annotations, no output schema, and a potentially impactful approval action, the description is severely incomplete. It fails to mention what happens upon approval, whether the asset is promoted, if subsequent steps are triggered, or any conditions that should gate the call. The one-line description leaves the agent without essential operational context.

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 100% and each parameter (actor, reason, approval_id) already has a description in the schema, so the description does not need to repeat them. The description adds no extra meaning about parameter usage, but the high coverage justifies a baseline score of 3.

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

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

The description states a specific verb ('Approve') and a specific resource ('a candidate asset'), making the action unambiguous. It clearly distinguishes from sibling tools like art.asset.reject and art.asset.request_changes, so an agent can tell them apart immediately without inspecting schemas.

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

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

There is no guidance on when to use this tool versus alternatives such as reject or request_changes. The description provides no context about the approval workflow, prerequisites, or criteria that should be met before calling it, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the core effect ('remove from active use') but does not mention reversibility, side effects, required permissions, or what happens to asset versions. This is adequate for a simple operation but leaves meaningful 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?

The description is a single, focused sentence that clearly defines the operation and its effect. There is no fluff, and the parenthetical adds necessary clarification without redundancy.

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

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

For a single-parameter mutation tool with no output schema, the description covers the essential invocation details. It lacks usage guidance and behavioral nuance, but the operation is simple enough that an agent can call it with just the id and a reasonable understanding of the action.

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

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

Schema description coverage is 100% for the single parameter, so the schema already documents its meaning. The description's 'Asset ID to archive' adds no new semantic detail beyond the schema, matching the baseline.

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 ('Archive') and resource ('asset'), and clarifies the meaning with 'remove from active use.' It is clear but does not explicitly distinguish itself from siblings like art.asset.archive_version or art.asset.deprecate, though the parenthetical helps.

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

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

No guidance is provided about when to use this tool versus alternatives such as art.asset.archive_version, art.asset.deprecate, or art.asset.update. The description only states what the tool does, leaving the agent to infer selection criteria.

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

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

With no annotations, the description must disclose side effects itself; it states that the asset is removed from active use but omits whether this is reversible, whether it affects only the canonical version, what happens to references, or whether special actor permissions are required.

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

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

A single, front-loaded sentence with no filler. It conveys the core action and consequence efficiently.

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

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

For a mutating archive operation with no annotations and no output schema, the description is under-specified: it lacks version semantics, reversibility, return behavior, and selection criteria. The presence of sibling archive/deprecate tools makes this ambiguity more costly.

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

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

Schema description coverage is 100%, so the baseline applies. The description adds no parameter-level meaning beyond the schema and does not clarify how asset_id identifies the canonical asset or how the actor object is used.

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 ('Archive') and a clear outcome ('removing it from active use'), so an agent understands the core operation. However, it does not differentiate this tool from the sibling art.asset.archive or art.asset.deprecate, and the phrase 'canonical asset' leaves the version-specific behavior implied by the tool name unclear.

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

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

No guidance is given about when to call archive_version versus art.asset.archive, art.asset.deprecate, promote, or rollback. The only usage signal is the generic purpose statement, which does not state exclusions, prerequisites, or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Compare' suggests a read-only operation, but the description does not explicitly state that it produces no side effects, whether it requires any particular permissions, or what happens if the versions are identical. It doesn't describe the output format (e.g., a diff, a similarity score, a list of changes). For a tool with no annotation coverage, this is a significant gap, but the verb 'compare' does give some hint of non-mutating 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, concise sentence that front-loads the primary verb and resource. There's no unnecessary fluff or repetition of the tool name. It earns a high score for being efficient, though it could arguably include a bit more context within that sentence.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is relatively minimal. It tells you what it does, but doesn't explain what 'compare' means operationally—does it return a diff, a list of changed fields, a boolean? With no output schema and no annotations, an agent might be unsure what to expect. The description is functional but incomplete for a tool that could have nuanced behavior.

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

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

Schema description coverage is 100%, so all three parameters are described in the schema: asset_id, version_a, version_b. The description doesn't add additional context beyond what the schema provides, but given full coverage, the baseline is 3. There's no extra info like how the IDs are formatted or how version numbers should be ordered, but the schema handles the core semantics.

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 clear verb+resource: 'Compare two versions of an asset.' It conveys the specific action of comparing versions, which is distinguishable from siblings like art.asset.get, art.asset.history, or art.asset.inspect_version. However, it doesn't explicitly differentiate itself from those siblings in the description text itself, so it doesn't quite reach 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 tool name and description imply a usage context: when you need to compare two versions of an asset. But there is no explicit guidance on when to use this versus alternatives like art.asset.history (which might list all versions), art.asset.inspect_version (which might show a single version), or art.asset.current. The description is minimal and leaves the when-to-use distinction to inference.

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

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

No annotations exist, so the description carries the full disclosure burden. The one-liner is nearly a restatement of the name '+ asset' and only clarifies that the return value is the version number, not the wrapped resource. It stops short of describing what happens for missing/invalid assets, whether the return is a plain value versus a structured object, or how 'current' interacts with archive/deprecate state. It isn't a tautology, but it does the bare minimum.

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 tightly scoped sentence, front-loaded with the verb, zero filler. Every word earns its place, and the key qualifier 'canonical (current)' is placed where it's most visible. This is exactly how a tool at this complexity level should be written.

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

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

For a trivial 1-parameter read with no output schema, the contract 'asset_id in, version number out' is marginally adequate. The main gap is the return type (a bare number vs. '1.4.2' vs. an object with metadata), which becomes agent-visible ambiguity. Given the untapped opportunity in the sibling graph, this stops just short of complete.

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

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

Schema coverage is 100% ('Asset identifier' is self-explanatory for asset_id). The description adds no parameter detail and doesn't need to. The baseline-3 applies: the structured field fully documents the parameter, and no additional semantics (formats, allowed values, side effects on the resource) are omitted.

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?

"Get the canonical (current) version number of an asset" uses a specific verb and resource. The qualification "canonical (current)" meaningfully narrows the scope to the version number rather than the asset object. However, it doesn't distinguish itself from the dense sibling cluster (art.asset.get, art.asset.inspect_version, art.asset.history), so an agent still has to guess how this differs from those.

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

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

No guidance is offered at all. With 60+ siblings and at least 4-5 plausible alternatives in the same namespace (get, inspect_version, exists, history, compare), the description should say when this read-most-likely-cheap call is preferred over art.asset.get, which returns the full asset. No alternative or exclusion is mentioned, forcing the agent to infer scope.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Mark an asset as deprecated', which implies a state change but does not explain consequences (e.g., whether it affects references, is reversible, requires permissions, or returns a confirmation). This is a significant gap for a mutation tool.

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

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

The description is a single sentence with no fluff, and it is front-loaded with the action. It is appropriately brief for a simple operation, though it might be considered under-specified. It earns its place without unnecessary 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?

Given the tool has no annotations and only a terse description, it is incomplete. An agent cannot tell when to use deprecate over sibling tools like archive or update, nor what the behavioral outcome will be. The output schema is absent, so the response format is unknown. This is a substantial deficiency.

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 covers the single parameter 'id' fully, so the baseline is 3. The description does not add any extra meaning beyond what the schema provides, such as format, constraints, or examples. It neither improves nor degrades the schema's clarity.

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 'Mark an asset as deprecated' with a specific resource. It is unambiguous, but it does not differentiate from similar sibling tools like art.asset.archive or art.asset.update, which could also change an asset's state.

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. No mention of prerequisites, side effects, or conditions like 'use this instead of archive when the asset is no longer in use but should remain discoverable'. The description only states the action without contextual 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 provided, the description carries the full behavioral burden. 'Check whether... exists' conveys a read-only, side-effect-free predicate operation rather than a mutation of registry data. For such a simple existence check, this level of behavioral disclosure is sufficiently clear, even though it does not spell out response format or edge cases like 'returns false for missing ID.'

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 with no wasted words. The operation is front-loaded, the resource is stetted immediately after, and every word contributes to understanding. This is concise to be model-parseable in a tool list.

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

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

For a single-parameter, side-effect-free existence predicate, the description is essentially complete: the parameter is fully documented by schema, and 'check whether it exists' naturally implies a boolean/presence outcome. An explicit 'returns true if the asset exists, false otherwise' would be marginally more precise given there is no output schema, but it is not missing for high-confidence 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 100%, so the schema already documents 'id' as 'Asset ID to check.' The description merely refers to 'the given ID' and adds no extra format, validation, or usage details beyond the schema, meaning it meets the baseline but does not improve on 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?

The description states a clear verb ('Check whether') and resource ('an asset with the given ID exists in the registry'), which is unambiguous about what the tool does. It also differentiates from sibling asset tools such as art.asset.get, art.asset.find, and art.asset.current by framing this as a pure existence test rather than a retrieval, search, or state-changing operation.

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

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

The description implies the tool is the right choice when an agent only needs to verify whether an asset exists, but it never explicitly says when to prefer this over art.asset.get or art.asset.find. No alternatives, exclusions, or contextual conditions are provided, so the agent must infer usage from the verb 'exists' and the sibling tool names.

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

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

With no annotations, the description carries the burden of behavior disclosure. The 'search and filter' wording implies a read-only operation and the optionality clarifies the empty-query behavior, but it does not mention result shape, pagination, ordering, or any access constraints.

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

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

Two short sentences with the core action first and the critical optionality note second. No filler or redundant restatement of schema details.

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 read-only filter tool with a fully documented schema, the description covers the essential call semantics. It would be more complete with a note on return format or default limits, but nothing blocks 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 coverage is 100%, so the baseline is 3. The description adds the cross-parameter insight that all filters are optional and an empty query lists everything, which is not immediately derivable from the individual parameter descriptions.

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 clear verb and resource: 'Search and filter registered assets.' It doesn't explicitly compare itself to sibling tools like art.asset.get or art.asset.current, so it loses the sibling-differentiation point, 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?

'All parameters are optional; omit all to return every asset' gives clear operational guidance and tells the agent when an unfiltered listing is appropriate. It does not name alternatives or exclusions, so it falls short of a 5.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does state 'Returns the full asset record,' which hints at read-only retrieval, but it does not specify error behavior (e.g., not-found handling), prerequisites (asset must exist), or any side effects. Since 'Get' implies a read, it's minimally transparent but not thorough.

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

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

Two short sentences with zero waste. The key action and return type are front-loaded. Every word adds value, making it 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 simple get-by-ID tool with one parameter and no output schema, the description is adequate. It states what it does and what it returns. However, it lacks guidance on error conditions, whether the asset must be registered, and how to react to missing IDs. Given the low complexityaging, the gaps are minor but 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?

The input schema already describes the parameter (id) and provides an example value. The description adds no new semantics beyond 'by its ID,' which is redundant with the schema. With 100% schema coverage, baseline is 3; the description doesn't add meaning.

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 ('Get'), names the resource ('registered asset'), and specifies the lookup key ('by its ID'). It also states the return ('full asset record'). It clearly distinguishes from siblings like art.asset.find (search-oriented) and art.asset.exists (existence check) without needing to open schemas.

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

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

The description implies usage (when you have an ID and want the full record) but does not explicitly state when to prefer this over art.asset.find, art.asset.exists, or art.asset.current. No exclusions or alternative routing 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 burden of behavioral disclosure. It only restates the purpose and does not mention pagination, ordering, return format, or what fields each version entry contains. 'Get' implies read-only, but no further behavioral detail is given.

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

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

One concise sentence with no filler. The action and resource are front-loaded, making the purpose immediately clear.

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

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

With no output schema and no annotations, the description should explain what the returned version history contains. It does not, leaving an agent to guess about response structure, ordering, and pagination, which are material for a tool returning 'full' history.

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

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

The input schema already describes asset_id as 'Asset identifier' with 100% schema description coverage. The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

States a specific verb 'Get' and resource 'full version history of an asset'. The scope is clear enough to distinguish it from related siblings like art.asset.current or art.asset.inspect_version, 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?

No guidance on when to use this tool versus alternatives such as art.asset.current, art.asset.inspect_version, or art.asset.provenance. The only usage signal is the phrase 'full version history', which is implied rather than explicitly stated.

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

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

With no annotations provided, the description carries the full burden. 'Get details' clearly indicates a read-only operation with no destructive side effects, which is transparent. However, it does not disclose any additional behavior such as existence requirements, authentication needs, or error handling.

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 or redundant information. Every word contributes to the core meaning, making it appropriately concise for a simple getter.

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 (two required parameters, no output schema), the description and schema together are sufficient to invoke the tool correctly. It lacks explicit return-value details and sibling differentiation, which prevents a perfect score, but the core invocation path is clear.

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

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

Schema description coverage is 100%, with both 'asset_id' and 'version' described in the input schema. The description adds no further meaning to these parameters beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description uses a specific verb and resource, 'Get details of a specific asset version,' which clearly states the operation. It does not explicitly differentiate from sibling tools like art.asset.get or art.asset.current, relying only on the word 'version' for 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 provides no guidance on when to use this tool versus alternatives such as art.asset.get, art.asset.current, or art.asset.history. No conditions, exclusions, or alternative recommendations are mentioned.

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

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

No annotations exist, so the description carries full burden. It only states 'promote... to become the canonical version' without disclosing side effects such as replacing the current version, authorization requirements, or reversibility. The mutation behavior is implied but not detailed.

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 concise sentence with no waste, but it is under-specified for the tool's complexity. It lacks structure or additional context beyond the bare statement.

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 11 parameters, nested objects, and no output schema, this description is inadequate. It doesn't explain the promotion workflow, success criteria, error handling, or implications for the asset's version history. An agent would struggle to call this correctly without additional context.

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 100%, so all parameters are already described. The description adds no extra meaning, such as relationships between parameters or usage context. Baseline 3 is appropriate since the schema handles parameter documentation.

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

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

The description clearly states the action (promote) and the object (approved candidate to become canonical version). It is specific and uses a distinct verb, though it does not explicitly differentiate from sibling tools like art.asset.approve or art.asset.rollback.

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 alternatives. It never states prerequisites like having an approval record or that it should follow approval. The term 'approved candidate' implies it, but no explicit when/when-not is provided.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It reports that the result includes an approval record, but it does not state whether the operation is read-only, what the provenance contains, whether any permissions are needed, or what the response looks like. This is thin for a tool with no structured annotation support.

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 filler. It front-loads the operation ('Get version provenance') and adds the key output qualifier ('including approval record'), earning its place.

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

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

Given the lack of annotations and output schema, the description should explain more about what 'provenance' includes and what the caller can expect. It does not specify return structure, limitations, or how this relates to the surrounding approval and history tools, leaving a fairly large gap for an agent selecting among many siblings.

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

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

Schema description coverage is 100%, with both parameters adequately described in the input schema ('Asset identifier' and 'Version number'). The tool description itself adds no extra parameter meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Get version provenance including approval record.' It clearly communicates that the tool retrieves provenance for a specific asset version, and the approval-record qualifier helps distinguish it from generic history or inspection tools. However, it does not explicitly name or differentiate against siblings like art.asset.history or art.asset.inspect_version.

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 art.asset.history or art.asset.approval.inspect. The description implies a read operation for version provenance but gives no conditions, exclusions, or preferred scenarios.

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 must disclose behavioral traits itself. 'Rebuild' implies a destructive overwrite of the existing index and a potentially expensive scan of asset files, but none of these side effects, performance implications, or error states are mentioned. The description adds some context about the data source but does not cover the operational impact.

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, well-formed sentence that states the operation and its input source with no redundant details. It is front-loaded and efficient.

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

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

For a zero-parameter tool, the description is mostly adequate, but it lacks behavioral warnings and usage context. Given that the tool is a mutation-like operation with no annotations, an agent might benefit from knowing when to use it and what consequences to expect. Still, the core action is clear.

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 the description is not required to clarify parameter meanings. The baseline of 4 applies.

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

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

The description uses the specific verb 'rebuild' with the resource 'asset registry index' and identifies the source as 'all registered asset files'. This clearly distinguishes it from asset query/registration tools like art.asset.get or art.asset.register.

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 invoke this tool versus alternatives, nor any mention of prerequisites or conditions. While the action is clear, an agent is left to infer when a rebuild is appropriate, such as after bulk registration or index corruption. No alternative or exclusion is stated.

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

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

No annotations are provided, so the description carries the full burden. It mentions validation of schema, style, source, and relationships, but does not clearly state the outcome (e.g., creation success) or any side effects or failure behavior. This leaves some ambiguity about the tool's actual 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 two short sentences, front-loaded with the core purpose and then a concise list of validation areas. No redundant or vague wording is present.

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

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

Given the complexity (12 parameters, nested objects) and absence of an output schema, the description provides adequate context for the tool's function. It does not mention return values or explicit preconditions (e.g., uniqueness of ID), but these are not critical for a create operation and the description is sufficient for an agent to invoke it correctly.

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

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

The schema provides descriptions for all parameters (100% coverage), so the tool description adds minimal extra semantic value. It does highlight that validation applies to certain fields, but this is already implied by the schema's required fields and enums. The description does not clarify any nuanced parameter interactions beyond what the schema already conveys.

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

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

The description clearly states the action 'Register' and the resource 'new asset in the registry', distinguishing it from other asset operations like update or archive. It also hints at the validation scope, making the tool's primary function 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 the tool is for creating new assets, which is sufficient given the presence of related sibling tools like art.asset.update. However, it does not explicitly mention when not to use it or provide alternatives, so it falls slightly short of fully explicit guidance.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states the action; it does not reveal side effects, whether the rejection updates an approval record, whether it can be reversed, or what response/callback occurs.

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 redundant text. It is appropriately brief, though its brevity leaves context to be supplied elsewhere.

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

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

For a mutating workflow action with no output schema and no annotations, the description is too thin to let an agent confidently understand consequences or expected results. The 100% schema coverage helps for parameters, but not for workflow semantics, rejection handling, or return behavior.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters and nested fields. The description adds no parameter-level meaning, but that is acceptable at baseline because the schema already carries the burden.

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 ('Reject') and resource ('candidate asset'), clearly identifying the action. It doesn't explicitly distinguish from sibling tools like art.asset.approve or request_changes, but the core purpose is unambiguous.

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

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

No guidance about when to use this tool versus alternatives such as art.asset.approve, art.asset.request_changes, or production.approve. The description provides no contextual conditions or exclusions, leaving the agent to infer appropriateness.

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. 'Request changes' implies a write/mutation action, but the description doesn't state whether the change-request is persisted, whether it blocks or cancels the approval, notification behavior, or reversibility. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

A single concise sentence that states the action clearly. It's front-loaded and every word earns its place. No fluff or redundancy.

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

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

For a mutation tool with no annotations distilled from the description, this is too thin. An agent needs to know what 'request changes' does to the asset lifecycle, whether it persists, whether it feeds into an approval flow, and what the response looks like (no output schema). Four parameters including nested objects, no annotations, and no output schema – this description doesn't carry its weight.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides. The nested feedback array is complex but the schema documents each sub-field (category, severity, etc.). The description doesn't clarify the relationship between reason and feedback, or how they interact. -1 for no added value over 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 ('Request changes') and a resource ('candidate asset'), which clearly identifies the tool's purpose. It's distinguishable from siblings like art.asset.archive_version or art.asset.update by its focus on the approval/review workflow, though it doesn't 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?

No guidance on when to use this tool versus the many sibling tools (e.g., art.qa.asset for quality checks, art.production.approve for approval). It doesn't state prerequisites (e.g., that an approval record must exist), nor when NOT to use it. The toolname and description imply an approval context, but no explicit routing or exclusion of alternatives.

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

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

No annotations are provided, so the description must convey behavioral traits: does it delete the canonical version or just switch a pointer? Does it create a new version entry? Does it require permission? The description neither confirms nor denies any of these. The mention of 'optimistic lock' in the schema hints at concurrency safety, but the description itself doesn't explain the consequences 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 sentence with no fluff. The key action and target are front-loaded. It is appropriately concise given that the schema covers parameters.

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

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

Given the complexity of a rollback operation with four parameters, including an optimistic lock, the description lacks key details such as side effects (does it permanently discard the previous version?), preconditions (must the asset be in a certain state?), and concurrency behavior. There is no output schema, so the description should clarify what the response indicates, but it doesn't. Overall, while it covers the basics, it leaves out critical operational context.

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?

Since schema_description_coverage is 100%, each parameter is described in the schema. However, the description adds only the concept of 'rollback' and 'canonical version', which provides some context but doesn't explain parameter relationships (e.g., why expected_current_version is needed). The schema descriptions are basic, so the description could have elaborated on the optimistic lock mechanism, but it doesn't, so the added value is minimal.

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

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

The description states the action (rollback) and the resource (canonical version), which is clear. It doesn't explicitly distinguish from other art.asset.* tools like art.asset.promote or art.asset.archive_version, but the verb 'rollback' is specific enough to indicate a revert operation, distinguishing it from promote or update.

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 art.asset.promote or art.asset.update. The description is a single sentence with no context about scenarios like reverting a bad deployment or precondition like asset must be in a certain state. The sibling tools include 'art.asset.archive_version' and 'art.asset.promote', which could be similar, but no exclusions are given.

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

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

No annotations are provided, so the description carries the full burden. It does not mention side effects (e.g., whether the operation is destructive), required permissions, error behaviors if the asset does not exist, or any return value. The user is left completely uninformed about the tool's behavior beyond its basic purpose.

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

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

The description is extremely concise, consisting of two short sentences with no redundant words. It is well-structured and easy to read, earning a perfect score.

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 description lacks essential context: no mention of return values, error cases, or how it relates to sibling tools. As a mutation operation without an output schema, the description should at least hint at what the caller can expect, but it does not.

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 already provides descriptions for both parameters (id and patch) with 100% coverage. The description merely restates these ('Provide the asset ID and a patch object with fields to change') without adding deeper semantics, such as constraints on the patch fields or interaction between parameters. Since schema coverage is high, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Update' and the resource 'asset', which distinguishes it from creation or deletion operations. However, it does not explicitly differentiate from other update-like operations such as archive_version or promote, though the context makes it clear enough.

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 a basic instruction but lacks guidance on when to use this tool versus alternatives like art.asset.register (for creation) or art.asset.archive (for archival). No conditions or prerequisites are mentioned.

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

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

Because no annotations are provided, the description carries full behavioral disclosure responsibility. It suggests a read-only analysis operation and states the extracted outputs, which is useful. However, it does not mention error conditions, color-count limits, coordinate space of the color map, or whether any state is modified.

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, tightly written sentence that front-loads the main action and lists outputs in a scannable way. Every word adds information and there is no filler.

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

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

For a simple one-parameter tool with no output schema, the description gives the agent enough to know what to pass and roughly what to expect back. It could be more explicit about the return shape of the color map and any constraints, but it is still reasonably complete 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?

There is only one parameter and its schema description already covers it (100% coverage). The description adds only the context that the image is a 'reference image', but does not provide additional semantic detail about accepted formats, path resolution, or behavior for missing files.

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 ('Analyze') and resource ('reference image') and names concrete outputs: dimensions, color palette with counts, and 2D color map. This clearly communicates what the tool does, though it does not explicitly differentiate it from similar siblings like art.get_palette.

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 usage context is implied: use when you need to analyze a reference image for dimensions, palette counts, or a color map. However, there is no explicit guidance about when to prefer this over related tools such as art.get_palette or art.canvas.get_state, nor any 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?

There are no annotations, so the description must carry the full behavioral burden. It only says commands are executed for efficiency; it does not state whether the batch is all-or-nothing, whether failures are partial, that commands run sequentially (this detail appears only in the schema), or that it mutates the canvas session.

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 concise at two sentences and front-loads the core purpose. It is effective and free of redundancy, though 'for efficiency' is a slightly motivational embellishment rather than a necessary technical 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 tool with 2 parameters and full schema documentation, the description gives enough selection and invocation context: it defines the batch role and what each entry contains. The only missing context, such as behavior on partial failure and authoritative requirements, is the same behavioral detail already penalized in behavior transparency.

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?

Parameter schema coverage is 100%, and the description adds almost no detail beyond the schema except the general notion of 'references a canvas tool name and its params.' The required commands array, tool string, params object, and session_id are already well documented in the schema, so the description provides the baseline 3 without additional meaning.

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

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

The description clearly states a specific action: 'Execute multiple draw commands in a single call for efficiency.' It identifies the resource, the purpose, and calls out the relationship to individual canvas tools, so it is easy to differentiate from sibling tools like set_pixel or draw_rect.

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 communicates when the tool is useful: when multiple draw commands should be batched 'for efficiency.' It does not explicitly name alternatives or exclusions, but the sibling canvas tools make it clear that each individual draw is for single commands and batch_draw is for bundling them.

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

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

No annotations are provided, so the description bears the full burden of explaining behavior. It states the action and the optional fill color but does not disclose that clearing is typically destructive to existing canvas content, nor what happens to the canvas state after the operation.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to the core meaning.

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

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

For a simple two-parameter canvas operation, the essentials are present: clear entire canvas and optionally fill with color. However, the lack of any guidance around destructive behavior or relationship to art.canvas.fill leaves the description not fully complete in context.

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

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

The input schema already covers both parameters with descriptions, including that color is a hex string and defaults to transparent/black. The description confirms that color is optional but adds little beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly names the operation — clearing the entire canvas — and adds that a fill color may be applied, which is more specific than a generic 'clear' statement. It is easy to distinguish from drawing or asset tools, though it does not explicitly differentiate from the similarly named art.canvas.fill sibling.

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 guidance on when to use this tool versus alternatives such as art.canvas.fill or art.canvas.set_pixel. An agent must infer usage from the tool name and schema 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 present, the description carries full responsibility for explaining side effects. It only says 'create' a 'session', giving a minimal behavioral fact, but does not disclose what happens upon session creation, whether a previous session is replaced, whether the operation persists or is ephemeral, what the return value is, or any permissions or resource 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?

The definition is a single clear sentence, with the main verb and resource immediately accessible and no filler words. It is concise and appropriately sized for a simple creation operation, though sparse.

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

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

There is no output schema and no annotations, so the description needs to explain the overall usage context and effects. It merely states that a session is created, but does not mention what the agent receives in return, what the session_id is used for, or how it relates to subsequent drawing operations. The tool cannot be confidently and safely invoked based on this description alone.

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

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

Schema description coverage is 100%, so each parameter (width, height, asset_id, bg_color, session_id) already has documented meaning. The description adds no extra parameter context beyond the overall purpose of creating a drawing session. This meets the baseline of relying on the schema's parameter descriptions, but no more.

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 ('Create'), a distinct resource ('new pixel canvas session'), and is clearly separated from the many sibling canvas operations like set_pixel, draw_rect, get_state, and save by naming the session itself. This is the only kind of session creation tool among the siblings, so an agent can reliably identify what it does.

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

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

The description offers no guidance on when to use this tool versus the many drawing and state-reading canvas tools, or when a new session is needed instead of reusing an existing one. There is no mention of sequencing, prerequisites, or alternatives, so the agent must infer the usage context.

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

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

No annotations are provided, so the description carries the full responsibility for behavioral disclosure. It does not mention whether the circle overwrites existing content, whether the filled parameter affects the result, what coordinate system is used, or what side effects the operation has. The one-sentence description is minimal and does not provide enough 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?

The description is very short, focused, and front-loaded with the primary action. All words are relevant, though the minimal nature sacrifices useful context in other dimensions. It is concise without being bloated.

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

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

For a simple drawing primitive, the description plus the fully-described schema might be minimally viable. However, there are gaps around canvas session requirements, coordinate bounds, how filled interacts with the visual result, and what other canvas tools should be used in combination. The lack of any output schema makes the description less a problem about returns, but these situational 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?

The schema already provides 100% description coverage for parameters like cx, cy, radius, color, filled, and session_id. The description adds no additional parameter-level meaning, but since the schema is fully self-contained, the baseline of 3 is appropriate.

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

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

The description clearly states what the tool does: 'Draw a circle on the canvas.' It names a specific verb, resource, and the primitive being created, which differentiates it from sibling canvas tools such as draw_rect and draw_line. The behavior is unambiguous even with minimal text.

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 like draw_line or draw_rect, nor are there prerequisites explained, such as having a valid canvas session. The description only states the action and leaves all usage context to be inferred from the schema.

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?

There are no annotations to carry the behavioral burden, and the description gives no detail about side effects, whether the operation is destructive, coordinate constraints, or expected results. The verb 'apply' implies mutation but nothing else is disclosed.

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

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

A single, focused sentence communicates the core operation without filler or redundancy. It is well-structured and immediately understandable.

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 description is minimally viable for invoking the tool because the schema documents all parameters. However, without annotations or extra behavior details, an agent lacks contextual information about session requirements, visual outcomes, or distinctions from neighboring canvas 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?

Schema description coverage is 100%, so all parameters already carry individual descriptions. The tool description adds no parameter-level context, but no additional meaning is strictly needed given the schema's completeness.

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

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

The description clearly states a specific action ('apply a dither pattern') on a specific resource ('rectangular region'), which conveys the primary purpose. It does not explicitly differentiate among sibling canvas tools, but the dither-pattern concept provides enough distinction in most cases.

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 usage context or alternative routing is provided. The description does not explain when an agent should choose draw_dither over related tools like draw_noise, fill, or draw_rect.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the Bresenham algorithm, which hints at integer rasterization, but does not disclose state mutation, coordinate bounds, behavior with invalid points, or whether drawing overrides existing pixels. For a mutation tool, this is a notable gap.

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

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

The description is a single, concise sentence that front-loads the action and avoids irrelevant detail. Every word contributes to understanding what the tool does.

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 fairly simple and the schema fully documents its six parameters. However, with no annotations or output schema, and no mention of behavioral constraints like coordinate handling or session assumptions, the description is only minimally complete 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 100%, so the parameter descriptions already document each coordinate, color, and session ID. The description adds no extra parameter semantics beyond the algorithm hint; this aligns with the baseline score for a well-covered schema.

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

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

The description clearly states the operation: drawing a line between two points on a canvas, and identifies the algorithm (Bresenham). This distinguishes it from sibling tools like art.canvas.draw_circle, art.canvas.draw_rect, and art.canvas.set_pixel without requiring schema inspection.

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 implicit: use this when a line needs to be drawn. However, the description gives no explicit guidance about when to choose this over alternative drawing tools or any exclusions or prerequisites such as session initialization.

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 bear the full behavioral burden. It does not disclose whether existing pixels get overwritten, how hidden randomness is handled, whether density affects the probability of each pixel, or what side effects may occur. Since this is a mutating canvas operation, the lack of any destructive-impact context becomes significant.

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 one single purpose-driven sentence with no filler or redundant information. The verb and core concept come first, and the object and how it is created follow immediately; every word earned its place.

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

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

Given 7 parameters, no annotations, no output schema, and a large sibling set of drawing tools, the description is incomplete on its own. An agent lacks information about when to use noise versus dither or fill, what happens to existing content, and what the semantic role of density is beyond the schema default. The schema covers parameters, but the contextual essence and side-effect clarity are missing.

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

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

The schema covers all parameters in 100% of cases, so the baseline is already 3. The description adds the relation that 'specified colors' means the random pick palette and 'region' maps to x, y, width, and height. It does not need to explain density because the input schema already has a clear description for 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?

The description names a specific verb ('Fill') and resource ('a region') plus the defining behavior ('with random noise using specified colors'). This distinguishes it from solid fills, lines, and dithering operations without naming alternatives. It is not a 5 because it does not explicitly contrast with similar canvas tools.

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

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

No guidance is given for when to use this tool versus art.canvas.fill, art.canvas.draw_dither, or art.canvas.batch_draw. The description only explains the mechanism, leaving an agent to infer selection from the word 'noise' 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?

There are no annotations, so the description bears the full burden of explaining behavior. It only states the basic action and does not disclose coordinate system assumptions, whether the drawing overwrites existing content, how the filled parameter behaves, or any side effects. This is minimal 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?

The description is a single declarative sentence with no redundant words. It is immediately front-loaded with the core action and resource, making it very easy to scan and understand.

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

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

For a tool with 7 parameters, 6 required, and no output schema, the description is too thin. It omits context that would help an agent use it correctly, such as coordinate system, integer bounds, canvas requirements, fill defaults, or interactions with the existing canvas 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 100%, so the schema already explains all seven parameters including x, y, width, height, color, filled, and session_id. The description adds no parametric meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific action (draw) and a specific resource (a rectangle), clearly identifying the tool's function. It naturally distinguishes itself from sibling canvas tools like draw_line and draw_circle by naming the shape being drawn.

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

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

The description provides no guidance on when to use this tool versus alternatives such as draw_circle, fill, or batch_draw. It does not mention any preconditions, context, or exclusions, leaving the decision entirely to the agent.

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 only describes the operation and does not mention side effects, color boundary behavior, whether pixels are replaced, whether the canvas is mutated immediately, or what the call returns.

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

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

The description is one action-focused sentence with no filler words, and the core behavior is front-loaded. For a simple tool this is appropriately concise.

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-oriented canvas tool with no annotations and no output schema, the description omits important context such as return value, boundary interpretation, color matching behavior, and persistence/session effects. The agent must infer too much from the tool name and operation.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description's phrase 'starting from a point' reinforces the x/y roles, but does not add meaning beyond the schema.

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

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

The description states a specific action, 'flood fill', a resource, 'an area', and the starting point. It is clearly distinguishable from sibling operations like art.canvas.set_pixel, art.canvas.draw_rect, and art.canvas.draw_line.

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: fill a contiguous region from a starting coordinate. However, the description does not explicitly state when to choose this tool over alternatives, nor does it mention any exclusions or complementing 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 burden of behavioral disclosure. 'Read' does imply a non-destructive operation, but the description is silent on what happens with out-of-bounds or negative coordinates (the schema permits coordinates down to -9007199254740991), how the color is returned (format?), and whether this triggers any validation or session 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?

One short sentence front-loads the essential message with zero waste. Every word earns its place, and the read-vs-write distinction is immediately visible.

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

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

There is no output schema, so the description must explain the return value, but it never states the color format (RGB/hex/RGBA?) or any error behavior. The enormous coordinate min/max in the schema without any clarification about canvas bounds or negative coordinates leaves an agent guessing about valid inputs. For a three-parameter, no-output-schema tool under a large canvas-family context, these gaps matter.

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 100%, so the input schema already documents x, y, and session_id. The description adds no coordinate-system context (origin location, valid bounds, units) beyond the schema's extremely wide integer range, which is not meaningful guidance for actual canvas dimensions. Per the high-coverage baseline, a 3 is appropriate.

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

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

The description names a specific verb ('Read'), a specific resource ('the color of a single pixel'), and a location ('the canvas'). This clearly contrasts with sibling tools like art.canvas.set_pixel (write) and art.canvas.fill/draw_rect (bulk drawing), so an agent can accurately select it without inspecting any other definitions.

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

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

No guidance is given on when to use this tool versus alternatives, and no alternatives are named. It does not mention related read operations such as art.canvas.get_state or art.analyze_ref, nor does it advise against using it for batch reads. The intended context is implied but never stated.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does indicate a read-only enumeration by saying 'Get' and mentions both output forms, but it does not disclose possible session requirements, failure behavior, or side-effect-free guarantees beyond the verb itself.

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 one sentence, front-loaded with the action and resource, and every clause adds value. It avoids restating the tool name or adding irrelevant 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?

This is a low-complexity read tool with fully documented parameters and clear return output formats in the absence of an output schema. It could be slightly more complete by noting that the state belongs to a specific canvas session and what happens if that session is missing, but nothing essential is 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 100%, and the description does not add meaning beyond what the input schema already says. format and session_id are both documented structurally; the description's mention of 'color map' and 'base64 PNG' mirrors the schema enum.

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 ('Get the current canvas state') and names the exact return representations, so it is easily distinguishable from sibling getters like art.canvas.get_pixel. No ambiguity about what object is being read.

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 guidance on when to use this tool versus alternatives such as art.canvas.get_pixel, art.canvas.save, or art.canvas.analyze_ref. The context is only implied by the word 'current', with no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that a PNG file is written, but it does not describe whether an existing file is overwritten, whether the canvas is mutated in memory, whether the operation is safe to repeat, or what happens when the session_id is invalid.

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. For a simple two-parameter tool, this is appropriately concise.

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 description is minimal but viable given that the schema covers both parameters and the tool is a simple save operation. Still, with no output schema and no annotations, return behavior, overwrite semantics, and failure cases are left unspecified.

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

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

Parameter coverage is 100%, so the schema already documents session_id and output_path, including the default path. The description adds nothing meaningful beyond the schema for parameter semantics.

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: 'Save the current canvas to a PNG file.' It clearly distinguishes this from sibling canvas tools like art.canvas.create, art.canvas.draw_rect, and art.canvas.get_state, which concern editing or querying rather than persisting.

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 usage is reasonably implied: use this when you want to persist the current canvas to a PNG. However, it does not explicitly state when not to use it, mention prerequisites like an initialized session, or contrast it with alternative 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 bears the full responsibility for behavioral disclosure. It states only the basic action ('set') and does not mention overwriting behavior, coordinate bounds, session prerequisites, or any failure modes. While 'set' hints at mutation, the description does not explicitly confirm that or any consequential side effects.

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

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

A single sentence of eight words that is front-loaded and contains no filler. Every word earns its place, and the size is perfectly proportional to the tool's simplicity.

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 tool, this is minimally viable but has gaps. The absence of an output schema means the description should indicate whether the call returns anything meaningful, yet it doesn't. It also fails to clarify that a valid session must exist before use, leaving an implicit prerequisite for an AI 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 coverage is 100% — all four parameters (x, y, color, session_id) have descriptions in the schema, so the baseline is 3. The description adds no further parameter semantics, but since the schema already covers them at a functional level, no deduction is warranted.

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 clear verb ('Set'), a specific resource ('a single pixel'), and immediately delineates this from sibling canvas tools like draw_rect, draw_line, fill, or batch_draw. An agent can unambiguously identify the tool's exact scope without opening the schema.

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

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

The description provides no guidance on when to use set_pixel versus alternatives such as art.canvas.batch_draw for multiple pixels or art.canvas.fill for regions. There is no mention of use cases, exclusions, or conditions selecting this tool, leaving the agent to guess the appropriate context.

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

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

Since no annotations are provided, the description must fully carry the behavioral burden. It does disclose core behaviors ('spatial scoring and issue detection') and implies a non-mutating evaluation, but it omits any mention of return structure, side effects, permissions, or whether the critic persists history. This partial disclosure is better than zero context, but still leaves key behavioral aspects 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 description is a single sentence that leads with the actionable verb 'Run' and packs meaningful qualification ('art critic', 'canvas quality', 'spatial scoring', 'issue detection') without filler. It is efficiently structured 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?

Enough to prompt the evaluator, but not enough to complete the picture. There is no output schema, no annotation, and the description doesn't specify whether the result is a score, a list of issues, or a report, nor does it explain the profile parameter despite that being a user-supplied input. An agent could invoke the tool correctly, but it would remain unclear how to interpret the response.

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

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

Schema description coverage is 100%, so the schema already documents both session_id and profile. The description adds no further parameter-specific meaning, but this is acceptable because the schema handles the semantics; it merely doesn't enrich the parameter 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 uses a specific verb 'Run' and names a concrete resource ('canvas quality') evaluated by an 'art critic'. It further narrows the intent by specifying the two core behaviors: spatial scoring and issue detection. This makes the tool's purpose clear, though it does not explicitly distinguish it from closely related siblings such as art.critic.refine.

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 or implied guidance about when to use this tool or when to choose an alternative. The description only restates what the tool does and does not mention sibling tools such as art.critic.refine or art.canvas.analyze_ref, nor any exclusions, prerequisites, or triggering conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies mutation of the canvas ('execute refinement actions') but does not describe side effects, failure behavior, partial execution, undoability, or whether the actions are applied in order. This is a significant transparency gap 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?

The description is a single sentence with essentially no filler. It is quick to parse, though 'improve canvas quality' is a vague outcome statement that does not add much operational detail to the tool's 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?

The core parameters are named, but the tool's behavior is opaque: no output schema, no error semantics, no detail about how refinement actions affect the canvas, and no guidance on handling invalid or unknown action names. An agent could construct a plausible call from the schema, but it would not know what the call actually returns or guarantees.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds only an abstract note that actions come from a critique and does not explain how action names or params are interpreted beyond what the schema already provides.

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 ('Execute refinement actions ... to improve canvas quality') and ties the tool to critique output. It is clear, but it does not explicitly distinguish it from related tools like art.critic.evaluate or canvas mutation tools, so it stops short of a 5.

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

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

No explicit when-to-use guidance is provided. The phrase 'from a critique' implies this tool follows a critique, but it does not name alternatives, explain when not to use it, or describe the intended workflow relationship with tools like art.critic.evaluate.

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?

There are zero annotations. The description says 'Add' but does not disclose whether this modifies the canvas in place, whether it is reversible, whether it invokes any side effects, or whether it requires prior session setup. It only describes the visual result (dark center with light rim), which is true but thin context for an operation with 9 required parameters.

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 core verb and resource, then a parenthetical that adds the important visual detail. There is no filler, redundancy, or irrelevant context.

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

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

Given all 9 parameters, no output schema, and no annotations, this is a minimum-viable description. The schema covers parameter meaning, and the description states the purpose clearly. However, it omits how coordinates and dimensions interact with the drawing, the role of seed/count in practical use, and any expected visual or stateful 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 coverage is 100% and the schema already explains dark_color as 'cavity center' and light_color as 'rim', so the description's parenthetical does not add meaning beyond it. The baseline of 3 applies because the schema carries the semantic weight.

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

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

The description states the action and resource clearly: 'Add cavity details (dark center with light rim) to a region.' It identifies a specific visual operation and is distinguishable from siblings like art.detail.crack or art.detail.speckle by the 'cavity' term, but it does not explicitly name or contrast those alternatives.

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

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

No when-to-use, when-not-to-use, or alternative guidance is provided. The description only gives the action without explaining why an agent should choose this tool over other art.detail.* operations. The sibling landscape is rich (speckle, crack, grain, etc.), so the omission is noticeable.

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

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

With no annotations provided, the description carries the full disclosure burden. It indicates that pixels will be merged, but it does not state whether this is destructive, reversible, permission-sensitive, or what happens to isolated pixels that have no nearby larger cluster. For a mutating tool, this is a meaningful 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?

The description is one sentence, front-loaded with the operation type ('Cleanup pass') and then the concrete action. It avoids filler and does not merely repeat the tool name, though a tiny bit more side-effect context would make it richer.

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?

Despite having only two well-described parameters, this is a mutating canvas operation with no annotations and no output schema. The description does not cover what effects the cleanup has on the canvas state, what a good workflow order is, or what happens in edge cases like a pixel with no nearby larger cluster. It is minimally viable but not complete for an agent.

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

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

Schema coverage is 100%, so both session_id and min_cluster_size are already documented. The description adds conceptual context by framing small clusters as 'orphan/isolated pixels,' which helps agents understand min_cluster_size, but it does not provide additional parameter-level details 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 states a concrete verb and resource: 'merge orphan/isolated pixels into nearest larger cluster.' The 'Cleanup pass' label provides useful context that this is a post-processing step. It does not explicitly name sibling tools, but its operation is clear enough to distinguish it from clustering or texture-generation tools.

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

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

The phrase 'Cleanup pass' implies a post-processing stage, but there is no explicit guidance on when to use this tool versus related detail tools such as art.detail.cluster or art.detail.pass. No when-not-to-use conditions or alternatives are mentioned.

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

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

No annotations are provided, so the description must communicate behavioral expectations itself. It only says 'Create a pixel cluster' and does not mention whether existing pixels are overwritten, what happens to out-of-bounds coordinates, how the seed affects irregular shapes, or whether the action is reversible. The mutating nature of the tool is implied but its side effects and constraints are not disclosed.

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

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

The description is a single efficient sentence with the main action and semantic focus front-loaded. It avoids unnecessary examples or filler, though it could have been structured slightly better with a separate 'when to use' clause.

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

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

For a mutation tool with no annotations and no output schema, the description is too spare. It does not explain what a cluster consists of, which shape/seed choices are intended, how the cluster interacts with the current canvas state, or what the agent should expect after execution. The schema covers parameter names well, but the higher-level operational 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?

The schema already documents all seven parameters with individual descriptions, achieving 100% schema description coverage, so the baseline is 3. The tool description adds only a general conceptual framing ('position' and 'shape') and does not explain the seed parameter's interaction with irregular shapes or the coordinate system beyond what the schema provides.

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 specifies the action ('Create'), the object ('a pixel cluster'), the location ('on the canvas'), and the manner ('at a given position with a specified shape'). It is unambiguous about the core purpose, though it does not explicitly differentiate this tool from sibling canvas and detail tools like art.canvas.draw_circle or art.detail.speckle.

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 instead of the many related drawing and detail tools in the sibling list, such as art.detail.plan, art.detail.texture, art.canvas.draw_noise, or art.detail.clean_clusters. No conditions, prerequisites, or exclusions are provided, so the agent is left to infer the appropriate usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool adds crack patterns, but it does not mention that this mutates a canvas session, whether it is deterministic given the seed, how the region interacts with existing content, or what side effects occur. This is a significant gap for a drawing/mutation tool.

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

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

The description is a single, front-loaded sentence and is easy to scan. It contains little waste, though it does repeat the word 'crack' already present in the tool name. It is concise and structured well, but it could have used slightly more space for material context or behavioral 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?

Given that this is an 8-parameter mutating operation with no annotations and no output schema, this single-clause description is not sufficiently complete. It does not explain how the operation affects the active session/canvas, what the seed controls, how the region is treated, or what the caller should expect after invocation. The selection of an agent would need to rely mostly on the schema and the tool name.

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

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

Schema-description coverage is 100%, so all eight parameters already have descriptions in the input schema. The tool description does not provide additional parameter meaning, such as how seed drives crack generation or how x/y/width/height define the affected region. Baseline 3 is appropriate because the schema already does the heavy lifting.

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

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

The description uses a clear action verb ('Add'), a specific resource ('crack patterns'), and a concrete target ('a region') with material context ('stone, ice surfaces'). It distinguishes this tool from similar sibling detail tools such as art.detail.texture or art.detail.grain because it names a specific pattern type, though it does not explicitly compare against those siblings.

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

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

The parenthetical 'stone, ice surfaces' gives an implicit context for when to use this tool, but the description does not explicitly state when to prefer it over alternatives like art.detail.edge_break, art.detail.cavity, or art.detail.texture. The usage signal is inferable but not explicit.

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

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

There are no annotations, so the description must fully convey behavioral expectations. It only says 'apply edge breakup', without clarifying that this modifies the existing canvas/session, whether it is destructive, how the edge is detected, whether it affects the whole image, or what the visual result is. This is too thin for a mutation tool.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It states the action and the intended aesthetic outcome efficiently.

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

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

For a detail operation with no output schema and no annotations, the description is too minimal. It does not explain the side effects on the existing canvas, what happens to the original edges, the role of preserve_outline behaviorally, or what a successful call returns or changes. The tool seems simple, but the write operation itself is insufficiently contextualized.

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?

Because schema description coverage is 100%, the schema already documents session_id, amount, seed, and preserve_outline. The description adds no extra semantic value for these parameters. A baseline of 3 is appropriate since the schema carries the load.

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 'Apply edge breakup to avoid perfectly geometric silhouettes' names a specific verb and resource, and tells the agent the aesthetic goal. It is distinct enough from sibling detail tools like crack, grain, or texture, 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 phrase 'to avoid perfectly geometric silhouettes' gives some indication of when to use this tool, but there are no explicit alternatives, exclusions, or conditions. An agent must infer when edge breakup is preferred over tools like art.detail.crack, art.detail.grain, or art.detail.texture.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only explains what is run, not what happens to the canvas, whether the operation mutates or is destructive, whether it completes synchronously, or what result is produced.

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

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

The description is one focused sentence that leads with the verb and resource, then adds a useful prerequisite. It is compact and contains no filler, though it would be more helpful with a bit more operational context.

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

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

For a 4-parameter pipeline tool with no output schema and no annotations, the description is under-specified. The prerequisite is useful, but the behavior, side effects, and return/result of the pipeline are completely omitted.

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

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

The input schema already documents all four parameters with 100% coverage, including the means for seed, profile, materials, and session_id. The description adds no deeper parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource (run, full detail pass pipeline) and a clear target (existing canvas session), so an agent understands what the scope is. It stops short of 5 because it does not explicitly differentiate from closely related art.detail.* tools such as plan or pass.

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 states the key prerequisite: content must already be drawn on canvas. This gives useful placement in a workflow, but there is no guidance about when to prefer this tool over art.detail.plan, art.detail.pass, or the individual detail pass variants.

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. It clearly states the mutating behavior ('Add ... grain lines'), but it does not mention whether existing region content is overlaid, replaced, or preserved, nor does it describe determinism or result behavior. This is adequate but not fully transparent.

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

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

The description is a single, front-loaded sentence with no wasted words. The parenthetical examples are useful and the entire content is highly scannable.

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 9-parameter schema is fully documented and the core action is clear, but the description does not explain when to use this tool versus sibling detail effects, how it interacts with existing region content, or what an agent should expect after invocation. Given no annotations and no output schema, the definition is minimally complete rather than rich.

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

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

Schema description coverage is 100%, so every parameter is already described in the input schema. The description adds no new parameter-level semantics beyond the top-level grain concept and material hints, so the baseline score of 3 is appropriate.

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

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

The description 'Add directional grain lines to a region' uses a specific verb and concrete output, and the parenthetical examples 'wood, cloth' distinguish grain from the other art.detail.* effects such as speckle, crack, or texture. An agent can tell what the tool does with little inference.

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

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

The examples '(wood, cloth)' imply when this tool is appropriate, but there is no explicit when-to-use or when-not-to-use guidance. It does not name alternatives such as art.detail.texture or art.detail.speckle, and no prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the tool adds highlights; it doesn't disclose whether the operation is destructive, whether existing clusters are preserved, how deterministic the seed/color/density interaction is, or what happens in overlapping regions.

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 one concise, front-loaded sentence that names the operation, the target, and the purpose without unnecessary filler or repetition of the schema fields.

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 eight required parameters, no annotations, and no output schema, the description lacks important context about how the tool modifies the canvas, what 'clusters' and 'density' do visually, and whether the operation is deterministic. It is minimally sufficient but leaves significant room for mis-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 100%, and the schema already explains the parameters clearly. The description adds a high-level purpose but no additional parameter semantics beyond the schema, which is acceptable but not compensational.

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: 'Add highlight clusters to a region', with a useful purpose clause 'for specular/light reflection.' However, it doesn't distinguish this from sibling detail tools like art.detail.cluster or art.detail.shadow, so the agent may need to open other definitions to differentiate 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?

There is no explicit guidance about when to use this tool versus alternatives. The purpose clause hints at a use case, but it never mentions sibling tools or conditions that would favor this operator over others in the art.detail.* family.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It only says what the tool applies, not whether it replaces existing content, respects region boundaries, uses the seed deterministically, or has any side effects on the canvas session.

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 one focused sentence with no filler. The action is front-loaded, and the parenthetical definition of 'full material treatment' earns its place by clarifying scope.

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 mutating tool with 7 required parameters, no annotations, and no output schema, a one-sentence description is not enough. It omits behavior around the target region, coordinate handling, seed reproducibility, and what the operation means for existing canvas content.

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 already provides 100% parameter coverage, so the baseline is 3. The description adds only light context around 'region' and 'material', but it does not deepen the meaning of the seed, coordinates, or session parameters beyond what the schema already provides.

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 action ('Apply a full material treatment') and target ('to a region'). The parenthetical 'all texture patterns for that material' helps distinguish this from a single texture/detail operation, though 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 'full material treatment (all texture patterns)' implies this tool is for applying complete material coverage rather than individual detail effects. However, it does not explicitly state when to use this tool over alternatives such as art.detail.texture or art.detail.speckle.

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 does not state whether the pass mutates the canvas, what effects it has, whether it requires an existing session state, or what side effects occur. The description only says a pass is 'run', leaving the behavioral profile almost entirely undisclosed.

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 one concise sentence with no filler or redundancy. It is appropriately short for a tool whose parameters are documented in the schema.

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

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

Given there is no output schema and no annotations, the description is too sparse to be fully actionable. It does not explain what a detail pass involves, what materials are used for, what side effects occur, or what the caller should expect after invocation. The presence of many related sibling tools makes this lack of context especially problematic.

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 provides descriptions for all three parameters, so the schema coverage is 100%. The description itself adds little semantic value beyond the schema, though 'single named' reinforces that pass_name should identify one pass rather than a batch or plan.

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 ('Run') and identifies the resource ('a single named detail pass' on 'a canvas session'), which makes the basic action clear. However, 'detail pass' is domain-specific jargon and the description does not directly distinguish this from the many art.detail.* siblings such as execute, texture, or material.

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 the numerous related sibling tools like art.detail.execute, art.detail.plan, or the specific pass tools such as art.detail.texture and art.detail.material. The phrase 'single named detail pass' implies a singular operation, but no explicit when-to-use or when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description must disclose behavioral traits on its own. It states that a plan is created, but it does not clarify whether this is a persistent write, a pure planning artifact, requires prior asset registration, has side effects, or returns a plan object. For a creation-style tool, that is a significant transparency gap.

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

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

One clean sentence that fronts the verb and object, names all meaningful input categories, and contains no redundant wording. Good compression without losing needed semantics.

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 relatively simple 6-parameter tool with full schema coverage, the description is adequate, but it does not explain what a 'detail art plan' is used for or how the result integrates with sibling tools. With no output schema and no annotations, mentioning the relation to art.detail.execute or the expected output shape would make the tool materially easier to use 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 100%, so the schema already explains all parameters. The description only summarizes them with rendering ('subject', 'materials', 'resolution' for width/height, and 'detail profile' for profile), which adds no new information beyond the schema.

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

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

States a specific verb ('Create') and resource ('a detail art plan for an asset'), and enumerates the defining inputs (subject, resolution, materials, detail profile). This distinguishes it from related planning tools like art.production.plan and art.pipeline.plan by clearly focusing on the 'detail' planning scope.

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

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

The description gives no explicit guidance on when to use this tool rather than alternative ones. Although the name suggests it complements execution-oriented siblings like art.detail.execute, no conditions, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does state that the tool adds shadows, implying an additive, non-destructive paint operation on a region. However, it does not mention whether it replaces, blends with, or overlays existing pixels, nor does it describe any side effects beyond the plain 'add' framing. This is acceptable but minimal.

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

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

The description is a single, tightly written sentence with no filler words. The verb is placed first, the object is clear, and the purpose clause is tacked on without bloating the length. It earns its place entirely.

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 and no output schema, the description must do more work than usual. It covers what and why but not key contextual details like how 'clusters' are distributed, whether the region is modified in place, or what the call returns. The 100% parameter schema coverage balances this, but for a detail function with eight required parameters, a bit more descriptive context would be welcome.

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 100%, and every parameter has a helpful description (e.g., 'Random seed', 'Top-left X coordinate', 'Shadow density (0-1)'). The description itself adds no new parameter meaning beyond the schema, so it hits the baseline of 3 rather than outperforming 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?

The description is a single, specific action: 'Add shadow clusters to a region for depth/occlusion.' It names a concrete operation (add shadow clusters), the target (a region), and the intended artistic effect (depth/occlusion). This clearly differentiates it from sibling tools like art.detail.texture, art.detail.highlight, or art.detail.speckle, even without opening the input schema.

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

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

The phrase 'for depth/occlusion' gives a clear context for when the tool is appropriate: whenever the user wants to convey shadow-driven depth. It does not explicitly name exclusions or suggested alternative tools, so it is not a perfect 5, but it communicates the intended usage scenario without relying on inference.

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

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

No annotations are present, so the description carries full responsibility for behavioral information. It says 'Add' which implies mutation, but it does not disclose how the speckle dots are placed, whether random generation is deterministic via seed, or how the effects interact with existing pixels or the canvas.

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