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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description is not required to prove mutation. It adds useful context by saying it returns the updated graph including the new node ID, and it frames the operation as graph modification. No contradiction with annotations, but it does not disclose details about side effects on node positions, materials, or existing graph structure.

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. Every clause earns its place: the action, the type source, and the return value. It is appropriately sized for a simple mutation tool.

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

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

The tool has four parameters with zero schema coverage, and the description only partially addresses one of them. While an output schema exists and the description does state the return value, the meaning of x/y coordinates and material_id remains unknown, leaving a meaningful gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation, but it only clarifies `type` by sourcing it from list_node_types. The parameters x, y, and material_id are left entirely unexplained, so an agent must guess their meaning and valid values.

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

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

The description clearly states a specific verb ('Add') and resource ('material node'), and includes the useful constraint that the type comes from list_node_types. It names the return value (graph with new node ID), which helps distinguish it from other graph utilities, though it does not explicitly contrast with remove/connect 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 description gives implicit usage guidance by saying the type must be one returned by list_node_types, which is a helpful prerequisite. However, it does not explicitly state when to use this tool over siblings like armorpaint_set_node_value, armorpaint_connect_nodes, or armorpaint_create_material, nor does it list 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?

Annotations only state readOnly false and destructive false, so the tool's file-writing behavior needs description coverage; the text provides that by stating the result is a PNG. It also reveals important behavioral requirements such as high-poly dependencies and ray tracing dependencies. It does not discuss runtime or the exact side effects of overwrite, but the annotation context makes this a solid score.

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

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

Four sentences with no fluff: the main action, the full type map, prerequisites, and persistence workflow are all included. Information is front-loaded with the core verb and resource, and every sentence adds something the schema does not already state.

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 and zero schema descriptions, this description clarifies only the type and high-poly dependency. Numeric parameters like offset, radius, samples, and strength remain only name/range-guessable. The workflow advice and existing output schema help, but notable gaps remain for choosing values correctly.

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

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

Schema description coverage is 0%, so the description must carry the parameter-semantics burden. It fully explains type and clarifies when high_poly_object is needed, which is valuable. However, offset, radius, smooth, samples, layer_id, strength, overwrite, material_id, and path_name are left to their names and ranges rather than explained.

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

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

The description opens with a specific verb and resource: Bake a mesh map to PNG using ArmorPaint. It then enumerates all 14 map types, so an agent knows exactly what operation this tool performs. This distinguishes it from export/capture siblings by naming bake as its own 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?

It gives explicit conditions for correct use, including which types require a high-poly object and which require ray tracing. It also gives high-level workflow steps: use a regular paint layer and import the exported image for persistent reuse. It does not explicitly compare against alternatives such as export_textures, but the contextual guidance is strong.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by specifying that the result is returned as an MCP image in PNG format, which is not visible in the annotations or schema.

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

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

The description is a single, front-loaded sentence with no filler. Every element adds value: the action, the target, the output format, and the purpose.

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

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

Because there is no output schema, the description rightly explains the return value: a PNG as an MCP image. It could mention prerequisites like a project needing to be open or a viewport already rendered, but the phrase 'rendered 3D viewport' makes the expected context reasonably 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 and schema description coverage is 100%, so there is no parameter ambiguity. The description reinforces that the capture works on the current rendered viewport without requiring arguments, which is sufficient.

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 ('capture the rendered 3D viewport'), identifies the output format ('PNG', 'MCP image'), and names the intended use ('visual inspection'). This clearly differentiates it from sibling tools like status/state inspection or viewport configuration.

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

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

The phrase 'for visual inspection' provides a clear context for when to call the tool. It does not explicitly name sibling alternatives or exclusion cases, but with zero parameters and a unique capture purpose, the intended usage is evident.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the agent knows this mutates and destroys content. The description adds modest context by noting the operation also writes 'packed PBR values', implying metallic/occlusion/roughness are set simultaneously. No annotation contradiction exists. The description doesn't go further (e.g., indicating irreversibility beyond the destructive hint, or whether clearing affects only the target layer).

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

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

Two short sentences, front-loaded with the core action. The first sentence fully states the operation; the second reinforces the color range, which is useful even though the schema also encodes 0–1 constraints. No wasted words, appropriate size for 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 destructive 5-parameter operation with 0% schema coverage and no usage guidance, the description is minimal but adequate at a high level. The output schema exists so return values need no explanation, and annotations carry the safety profile. The main gaps are the missing layer_id semantics and the lack of any statement about the relationship to fill_layer or undo behavior, which an agent would benefit from before invoking a destructive op.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning by explaining the color array is RGBA in the 0–1 range and framing metallic/occlusion/roughness as 'packed PBR values' set together. However, the required layer_id parameter gets zero semantic help — its -1 minimum is unexplained (likely meaning active/current layer but unstated) — so the description only partially fills the coverage gap.

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

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

The description states a specific verb ('Replace'), a clear resource ('a paint layer's pixels'), and the values involved (uniform color and packed PBR values). This is unambiguous about what the tool does. However, it does not differentiate from the closely named sibling armorpaint_fill_layer, which sounds functionally similar, so the agent gets no help choosing between them based on purpose alone.

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

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

The description gives no indication of when to use this tool versus alternatives. With 40 siblings including armorpaint_fill_layer, armorpaint_set_layer_channels, and armorpaint_export_layer, there is no guidance on when clearing is appropriate, whether it requires an existing/selected layer, or how it relates to fill operations. The agent must infer usage entirely from the tool name.

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

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

An annotation set is present but all entries are false, so the description carries the main burden of behavioral disclosure. It does disclose the key side effect: 'replacing any previous connection to that input'. However, it does not mention other potential effects, validation failures, or whether the operation is reversible through undo.

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

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

The description is a single, front-loaded sentence with no wasted words. Every phrase earns its place: what is connected, from where to where, and the replacement side effect.

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 graph-edit operation this is adequate but not complete. The output schema exists, so return values need no explanation. However, the description omits material_id semantics, prerequisites for knowing valid node/socket IDs, and any constraints around connecting incompatible socket types.

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

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

The schema has 0% description coverage, so the description must compensate. It clarifies that from_node/from_socket represent the output side and to_node/to_socket represent the input side, which adds some meaning. But it does not explain material_id, the meaning of the integer IDs, or how socket indices are obtained.

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: 'Connect an output socket to an input socket'. It also adds the key behavior of replacing any previous connection to that input, which clearly distinguishes it from sibling tools like armorpaint_disconnect_nodes and armorpaint_add_node.

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 versus alternatives. It does not mention armorpaint_disconnect_nodes, armorpaint_add_node, or any prerequisite such as fetching the material graph first. Usage is only vaguely implied by the operation name and description.

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

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

Annotations carry almost no signal: all four hints are false, which is the default state, so readOnlyHint=false merely confirms this is a mutation. The description adds one key behavioral constraint — masks require a parent layer ID — but does not disclose what happens with an invalid parent, whether creation alters the current selection, or how it interacts with the undo stack.

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

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

Three sentences with no filler: the purpose is front-loaded, followed by the single most important constraint and the trickiest parameter mapping. Every sentence earns its place for a tool with 6 parameters and 4 entity kinds.

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 covers purpose, the mask requirement, and UV semantics, and an output schema exists so return values need not be documented. But white and material_id semantics, plus failure behavior for invalid parent references, are missing — an agent could pass nonsensical defaults and only discover problems at runtime.

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

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

Schema coverage is 0%, so the description must compensate; it fully explains the cryptic numeric uv_type enum (0=UV map, 1=triplanar, 2=projection) and partially clarifies kind and parent_id. However, 'white' (initial layer color?) and 'material_id' (binding the layer to a material?) remain undefined, so compensation is only partial.

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

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

The description states a specific verb ('Create') and enumerates the full resource range ('paint layer, material fill, mask, or group'), which maps 1:1 to the 'kind' enum. This cleanly separates it from sibling tools like armorpaint_create_material, armorpaint_fill_layer, and armorpaint_layer_action.

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 mask-parent constraint ('Masks require a parent layer ID') is a genuinely useful condition, but the description never says when to prefer this tool over the many alternatives, such as fill_layer, set_layer, or layer_action. Usage context is implied by the name and the create verb 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?

Annotations already signal this is not read-only or idempotent, and the description adds a concrete side effect: the material is both created and selected. It does not detail duplicate handling or whether the previous selection is replaced, but the main behavioral trait 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, front-loaded sentence states the action and object without any filler. Every word earns its place, and the structure is easily 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?

For a simple one-parameter creation tool with an output schema and clear annotations, the description covers the essential behavior. It does not mention prerequisites like whether a project must be open or how duplicate names are resolved, but these are minor for this simple tool.

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

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

The schema only provides a parameter title 'Name' with 0% description coverage, so the description needs to compensate. It does so by connecting the value to a 'named PBR material', making it clear the string is the material's identifier. More constraints are not provided but are not critical for one obvious parameter.

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

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

Description states a specific verb 'create' and resource 'named PBR material', plus the side effect 'select'. This clearly conveys the primary function and distinguishes it from selection-only tools like armorpaint_select_material, though it does not explicitly name any 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 implies the tool is for creating and selecting a new named PBR material, which gives some usage context. However, it offers no explicit when-to-use guidance, exclusions, or comparison with alternatives such as armorpaint_import_material or armorpaint_set_material_pbr.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the destructive nature is known. The description adds useful behavioral context beyond annotations by warning that the final material cannot be deleted. It does not detail side effects on nodes or scene references, but this is acceptable given the annotation coverage.

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

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

Two short sentences, front-loaded with the core action and immediately followed by the key constraint. Every word earns its place; there is no filler or repetition.

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 one-parameter destructive operation with annotations and an output schema present, the description covers the main purpose and the key limitation. However, the lack of guidance around material_id semantics and the -1 minimum leaves a visible gap that an agent must resolve elsewhere. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it says nothing about material_id. The parameter name is self-explanatory, yet the meaning of minimum: -1 is unexplained and could be a sentinel or special value. An agent selecting arguments receives no help with valid id conventions or error conditions.

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

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

The description names a specific verb and resource: 'Delete a material.' This clearly distinguishes it from sibling tools like create_material, import_material, select_material, and export_material. The additional constraint about the final material adds precision without ambiguity.

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 makes the tool's purpose obvious and adds an explicit usage constraint: the final material cannot be deleted. It does not explicitly name alternative tools, but no sibling tool performs the same delete-material operation, so the clear context and final-material exclusion provide sufficient 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?

The description clearly states the mutation behavior—disconnecting an incoming link—which aligns with readOnlyHint=false and destructiveHint=false. However, it does not disclose what happens if the socket has no incoming link, whether the change can be undone, or how the node graph state is affected. With no annotations carrying additional behavioral context, the description provides only the basic action.

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 carries meaning and it reads clearly as the tool's core action.

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

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

For a tool with three parameters, no schema-level descriptions, and no annotation-provided safety context, the description is too thin to be considered complete. It fails to connect the action to the parameters, which is exactly what an agent needs when this is the only prose available. The presence of an output schema helps return values, but not input semantics.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters, but it does not. It mentions 'incoming link' and 'input socket' but never clarifies that 'socket' is likely the input socket index, why 'node_id' is required, what the -1 defaults represent, or when 'material_id' is needed. An agent must guess the meaning of the integer parameters.

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

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

The description uses a specific verb ('Disconnect') with a clear resource ('the incoming link to a material node input socket'). It is immediately distinguishable from the sibling connect_nodes and other node-editing tools, so an agent can tell what this tool specializes in.

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 use this tool versus alternatives such as armorpaint_connect_nodes, armorpaint_remove_node, or armorpaint_set_node_value. There are no exclusions or context clues beyond the literal action, so the agent must infer the appropriate scenario.

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

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

Annotations already declare the operation as read-only, idempotent, and non-destructive; the description adds the concrete output artifact (PNG) and the texture channels involved. It does not detail what layer_id=-1 resolves to or the overwrite behavior, but these are surfaced in the schema and the safety profile is already 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, front-loaded sentence with no filler; every phrase carries meaning and the text is appropriately sized despite being short.

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 four parameters and no schema descriptions, the description is too terse to let an agent invoke it correctly without guessing: the required path_name is unexplained, layer_id's -1 semantics are unclear, and the overwrite flag is not described. The output schema presence reduces the need to describe return values, but does not fix parameter ambiguity.

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

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

Schema description coverage is 0%, so the description must explain parameters; it only elaborates the channel options ('base color/mask, normal, or packed occlusion-roughness-metallic'), leaving path_name, layer_id, and overwrite semantically undocumented.

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

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

The description names a concrete verb ('Export'), a precise resource ('one layer's ... texture'), and a target format ('PNG file'), which clearly distinguishes it from sibling exporters like armorpaint_export_mesh or armorpaint_export_textures.

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 'one layer's' implies this tool is for per-layer texture export rather than bulk/material export, but the description never states when to choose it over alternatives such as armorpaint_export_textures or armorpaint_export_material. No explicit exclusions or alternative 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?

The annotations declare readOnlyHint=true, but the description describes an export operation that writes amaterial file to disk—a side-effecting operation. This contradicts the read-only annotation, and the description provides no additional 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 tightly worded sentence with no unnecessary filler. It is front-loaded with the verb and resource, making it easy to parse.

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

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

Given three parameters, zero schema descriptions, and no parameter guidance in the description, the tool definition is not fully complete. The output schema may cover return values, but the agent still lacks critical invocation details like which material is selected by default and what overwrite does.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It provides no information about path_name, material_id (including the meaning of -1), or overwrite behavior, leaving all three parameters semantically underdocumented.

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 ('Export'), a resource ('a material'), and the output format ('an ArmorPaint material file'). This distinguishes it from sibling export tools like export_textures, export_mesh, and armorpaint_import_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 on when to use this tool versus armorpaint_import_material or the other export tools. No alternative conditions, prerequisites, or exclusions are mentioned.

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

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

The description contradicts the annotations: it says 'Export ... to an OBJ file,' which writes to the filesystem and can overwrite files, while readOnlyHint is true. The description also does not explain overwrite behavior or side effects, and the contradiction makes the tool's safety profile unreliable.

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 short, front-loaded sentence. It communicates the essential action, object, and output format without redundancy or 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?

Even though an output schema exists and the tool is simple, the description leaves important invocation details uncovered: overwrite semantics, path requirements, and the meaning of 'current mesh.' The annotation contradiction further undermines an agent's ability to reason about side effects.

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

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

Schema description coverage is 0%, so the description must explain the parameters, but it does not mention path_name or overwrite. The only useful inference is that path_name is the destination OBJ path; overwrite behavior is left entirely to the parameter name and default.

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 ('Export'), object ('the current mesh'), and target format ('OBJ file'), so an agent immediately knows what the tool produces. The explicit OBJ format and mesh resource also separate it from sibling exporters such as export_textures, export_material, and export_layer.

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

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

The intended use is implied: use this when the current mesh needs to be saved as an OBJ. However, there is no explicit when-to-use guidance, no mention of prerequisites like having a selected mesh, and no comparison with the other export 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?

Annotations are largely non-informative, so the description carries the burden. It discloses that only the visible layer stack is exported, that output is PNG PBR maps, and that an installed preset is required. It does not mention overwrite or file-naming behavior, but the core side effect is clearly described without contradicting annotations.

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

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

The description is two tight sentences with the core behavior front-loaded. The second sentence is a useful actionable tip rather than filler or redundant schema restatement.

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 essential export behavior, output format, layer scope, and preset requirement are all covered, and an output schema exists for return values. Missing detail around overwrite and directory semantics is partly mitigated by self-explanatory parameter names and defaults.

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

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

Schema description coverage is 0%, so the description must illuminate parameters. It adds meaningful guidance for 'preset' by requiring exact names from list_node_types, but directory, name, and overwrite semantics are left entirely to their names and defaults. This partially compensates for the schema gap but not completely.

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: 'Export the visible layer stack as PNG PBR maps.' This clearly differentiates it from siblings like armorpaint_export_layer, armorpaint_export_mesh, and armorpaint_export_material by specifying both the output type and the scope of layers.

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

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

It provides concrete pre-usage guidance: 'Get exact preset names from list_node_types.' This tells the agent how to prepare the preset parameter. It does not explicitly list exclusion criteria or compare against alternative export tools, but the workflow context is clear enough.

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

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

The description adds one useful behavioral detail—that object masks are respected—but says nothing about whether existing layer contents are overwritten, how selection state interacts with the layer_id/material_id parameters, or what happens with default values. Since all annotation hints are false, the description carries the full burden and does not fully disclose the operation's effects.

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

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

The description is a single, front-loaded sentence that immediately states the action and scope. It is appropriately concise, though the brevity comes at the cost of omitting important behavioral and parameter 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 tool with two unannotated parameters and no schema descriptions, this description is incomplete. It does not clarify the default -1 values, the relationship between material_id and the selected material, or the overwrite behavior. The presence of an output schema covers return values, but not the preconditions and side effects an agent needs to invoke this correctly.

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

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

Schema description coverage is 0%, so the description must clarify the parameters, but it only refers to 'the selected material' without explaining material_id or layer_id. It does not mention that -1 likely means 'current selection' or describe what an invalid ID causes, leaving both parameters under-explained.

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 ('Paint'), a resource ('entire paint layer'), and a modifier ('respecting object masks'), making the core action clear. It distinguishes itself from stroke painting by emphasizing 'entire paint layer,' though it does not explicitly name any sibling tool.

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

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

The description implies when to use this tool: to fill a whole paint layer with the selected material rather than painting individual strokes. However, it gives no explicit guidance about when not to use it or which alternative tool (e.g., paint_stroke, clear_layer) would be more appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the 'Read' verb aligns with them - no contradiction. Beyond the annotations, the description discloses what the graph comprises (socket values, buttons, connections, not just nodes) and the default behavior that material_id=-1 resolves to the current material, which annotations do not convey.

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, both high-value: the first states the operation and its exact scope; the second explains the sentinel parameter. No filler words, front-loaded with the purpose. Every sentence earns its place.

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

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

An output schema exists to document return shape, and annotations cover the safety profile, so the description only needs to carry operational context, which it does. The only gaps are edge cases: behavior for invalid material_id values and whether an empty/fresh material returns an empty graph. These are minor for a simple single-parameter read tool.

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

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

Schema description coverage is 0%, and the schema offers only type, default, and minimum. The description supplies the critical semantics - material_id=-1 means the current material - which is essential for correct invocation. It leaves some ambiguity about what non-default integer values reference (an index, a generated ID, or an app-assigned material name) and what happens for out-of-range IDs, but the key behavior is explained.

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: 'Read a material's nodes, socket values, buttons, and connections.' The read scope clearly sets it apart from mutating siblings like armorpaint_set_node_value, armorpaint_connect_nodes, and armorpaint_add_node, and from the more genera armorpaint_get_state. Even the closer sibling armorpaint_list_node_types is distinguishable - that tool lists node types, this one reads a specific material's graph.

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?

Context is implied: you would call this when you need to inspect a material's node graph, and the sentinel hint tells you how to target the current material. However, there is no explicit when-to-use versus alternative tools, no exclusions, and no mention of a prerequisite such as selecting a material first.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds concrete scope (what state is inspected) but does not disclose return shape, cost, or failure behavior; this is acceptable because the output schema exists.

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

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

A single sentence with a clear action verb followed by a comma-separated list of scope items. No filler words, and the main purpose is 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 parameterless read-only tool with an output schema, the description covers all necessary selection context by enumerating what the returned state contains. There is no missing operational information an agent would need to invoke it.

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

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

The tool has zero parameters, so the description does not need to explain parameter meaning. Per baseline, a no-parameter tool earns a 4; there is no schema gap for the description to compensate for.

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

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

The description starts with the specific verb 'Inspect' and enumerates the state categories the tool exposes: objects, triangle counts, materials, layers, assets, selection, and project path. It clearly identifies what the tool reads but does not explicitly differentiate it from the similarly broad sibling armorpaint_status.

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 this tool instead of siblings such as armorpaint_get_material_graph, armorpaint_status, or armorpaint_select_object. The description implies it is a general read-only snapshot, but it never states 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?

Annotations are all false hints, so they do not convey much behavioral information; the description adds meaningful behavior: the image is grayscale and interpreted as a mask with white/black reveal semantics. It does not mention whether an existing mask is replaced, but the added context is still valuable.

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 core purpose is front-loaded, and the white/black behavior detail earns its place.

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

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

For a two-parameter tool, the description covers the basic purpose and mask behavior, and an output schema exists. However, it omits explicit parameter roles and any prerequisite context, such as requiring an existing layer to attach the mask to.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only implicitly references a path and a layer, but it never explicitly maps path_name to the image file path or parent_id to the target layer ID.

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

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

The description states a specific verb and resource: importing a grayscale image as a mask for a paint or fill layer. It also explains the mask semantics (white reveals, black hides), which clearly distinguishes this from sibling tools like import_texture.

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 intended use case by mentioning masks for paint/fill layers, but it does not explicitly say when to choose this tool over alternatives such as import_texture or import_material. No exclusionary 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?

All annotations are false, so they provide no safety or behavioral profile. The description only says 'import into the current project' and does not disclose whether the import overwrites existing materials, merges with them, requires an already-open project, or what side effects may occur. For a mutating operation, this 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?

The description is a single focused sentence with no filler. It front-loads the core action and resource, making it easy to parse quickly.

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

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

Although the tool has only one parameter, that parameter is undocumented and the behavioral side effects are missing. The description also provides no routing information relative to the many import/material sibling tools, leaving an agent without enough context to confidently select and invoke this 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?

Schema description coverage is 0%, and the description does not explain path_name or its expected format. The only useful clue is that the file is an ArmorPaint .arm material library, but the agent still lacks guidance on whether the path is absolute, relative, or must include a specific extension.

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 'Import', the resource (an ArmorPaint .arm material library), and the destination (current project). This also distinguishes it from sibling tools like armorpaint_import_mesh, armorpaint_import_texture, and armorpaint_import_mask, which target different resource types.

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 implied: use this tool when you need to load a .arm material library into the project. However, there is no explicit guidance about when not to use it or which alternative should be preferred, especially given the large number of closely related import and material 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?

Even though destructiveHint is already true, the description adds useful context by warning that replacement can clear current layers and that append mode preserves geometry. It does not explain all side effects such as discard_changes, but it goes beyond what the annotation alone conveys.

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 concise sentences carry the core purpose and the critical destructive caveat. There is no filler or repetition of schema details, and the most important information is 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 4-parameter mutation tool with zero parameter descriptions, the layer-preservation warning is valuable, but the vague 'append mode' wording and unmentioned discard_changes leave gaps. The output schema and destructive annotation reduce the burden, making this minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it only indirectly addresses replace/clear_layers by contrasting replacement with append mode. The required path_name and the discard_changes parameter are left unexplained, leaving a meaningful semantic gap.

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

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

The description opens with a specific verb ('Import') and a concrete resource ('UV-mapped OBJ or supported Blender mesh'), which clearly separates it from siblings like import_material, import_texture, and import_mask. The resource-oriented phrasing lets an agent identify the tool's purpose 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 practical mode-selection guidance: replacement can clear current layers, and append mode should be used to preserve geometry. It does not explicitly name alternative tools, but it clearly tells the agent when to prefer append over replace within this tool.

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

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

Annotations already indicate this is not read-only, and the description states it imports into texture assets, which confirms mutation. It adds the useful behavioral detail that the updated asset list is returned, but it does not disclose overwrite behavior, supported image formats, or side effects on existing assets. This is adequate but not richly 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 consists of two short sentences with no filler. The primary purpose is front-loaded, and the return-value sentence adds useful information without bloating the definition.

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 one-parameter import tool, the description covers the core purpose and return expectation, but it leaves a meaningful gap around how to populate path_name and what happens on duplicate or existing textures. The annotations and output schema partially compensate, but the description is only minimally sufficient rather than fully complete.

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

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

The input schema provides only a type and title for path_name, and schema description coverage is 0%, so the description must compensate. The word 'image' hints that path_name should reference an image file, but the description does not clarify whether path_name is a filesystem path, a URL, or an asset name, nor does it specify accepted formats. The compensation 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 a specific action ('Import an image') and a specific resource ('the project's texture assets'), which makes the tool's purpose immediately clear. This also distinguishes it from sibling importers such as armorpaint_import_mesh, armorpaint_import_material, and armorpaint_import_mask by targeting image textures specifically.

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 case is implied through 'Import an image into the project's texture assets', but there is no explicit guidance on when to choose this tool over alternatives, no mention of when not to use it, and no stated prerequisites or conditions. The usage context is present but only by 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?

Annotations already mark the tool as destructive and non-read-only, and the description adds useful context by identifying which specific operations are dangerous and recommending a checkpoint before merging or deleting. It also clarifies the scope of behavior to include mask operations and conversions.

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

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

The description is two short sentences with no filler. It front-loads the supported actions and ends with a single actionable safety warning, so every clause earns its place.

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

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

For a multi-action destructive tool, the description is too thin: it omits how reordering is parameterized via index, does not clarify prerequisites or side effects, and provides no context on whether conversion or mask actions require additional state. The output schema may cover return values, but invocation semantics remain incomplete.

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

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

With 0% schema description coverage, the description must compensate for missing parameter detail. It partially does so by mapping action enum values to plain language ('merge' for merge_down, 'reorder' for move, 'convert' for to_paint), but it does not explain how index is used or what layer_id must reference. The action semantics are covered, while the other parameters remain under-specified.

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 resource (layer) and the operations ('Duplicate, delete, merge, reorder, or convert a layer; apply or invert masks'), so the tool's purpose is unmistakable. It does not explicitly differentiate from sibling layer tools, but the action list makes it distinct from create_layer, set_layer, clear_layer, and export_layer.

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

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

No guidance is provided on when to choose this tool over sibling alternatives like set_layer, clear_layer, or select_layer. The only directive is 'Save a checkpoint before merging or deleting,' which is a safety precaution rather than a usage-selection guideline.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the agent knows this is safe and non-mutating. The description adds behavioral value by specifying exactly what the listing contains: socket schemas, button schemas, and installed export presets. No contradiction exists between the description and annotations.

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

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

Two short sentences with no wasted words. The main action and return payload are front-loaded in the first sentence, and the usage nudge is a concise second sentence. Every word earns its place.

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

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

For a zero-parameter, read-only listing tool with an output schema available, the description fully covers what the agent needs: what will be listed and when to call it. There are no missing prerequisites, side effects, or configuration details that an agent would need before invoking.

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

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

The tool has zero parameters, so there is nothing for the description to explain. The baseline for a no-parameter tool is 4, and the description correctly focuses on the return contents rather than inventing parameter guidance.

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

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

States a specific verb ('List') and a clear resource ('material node types with socket and button schemas, and installed export presets'). It is immediately distinguishable from sibling node-graph tools like armorpaint_add_node or armorpaint_get_material_graph because it focuses on enumerating schemas rather than mutating or querying a graph.

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

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

Provides an explicit usage context: 'Query this before building node graphs.' This tells the agent when to invoke the tool. It does not name alternative tools or when-not-to-use cases, but for a read-only listing tool the placement guidance is sufficient.

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

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

Annotations already mark the tool as destructive, but the description adds concrete consequences: the current project is discarded and must be saved first. This goes beyond the bare destructiveHint flag, though it does not detail reversibility or effects on the undo stack.

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 and every clause earns its place: the first states the operation, the second gives the critical warning. No redundant or filler language.

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 destructive tool with an output schema, the description covers the main operation and risk, so it is minimally viable. It is incomplete only because the input parameter's behavior is undocumented in both the schema and the description, which is a clear decision-making gap for an agent deciding whether to pass discard_changes.

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

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

With 0% schema description coverage, the description was expected to explain the discard_changes parameter, but it never mentions it. The phrase 'Save the current project before discarding it' implies loss of unsaved work but does not clarify whether true/false skips a prompt, forces discard, or has another effect; the agent is left to infer the boolean mapping.

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 action ('Create a new project') and immediately clarifies that the current project will be discarded, which distinguishes it from sibling tools like open_project and save_project. Even with no title, there is no ambiguity about what operation this tool performs.

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 actionable guidance by telling the agent to save the current project before invoking the tool. It does not explicitly name alternatives or state when new_project should be preferred over open_project, but the warning establishes the prerequisite and context clearly enough.

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

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

The description adds meaningful context beyond the destructiveHint annotation by warning the agent to save the current project before opening, implying current work may be lost. It does not contradict any annotation and gives a concrete behavioral safeguard.

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 that are front-loaded with the core operation and immediately followed by the critical safety instruction. Every sentence earns its place with no fluff.

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

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

For a destructive, two-parameter tool with no schema descriptions, the description should explain both parameters and behavior more fully. It adequately states the operation and save warning, but leaves discard_changes and path handling to inference.

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

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

The schema provides 0% description coverage, and the description fails to explain path_name or discard_changes. 'Save the current project first' hints at change handling but doesn't clarify the discard_changes boolean's role or default behavior.

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

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

The description uses a clear verb ('Open') and specific resource (an existing .arm project), which distinguishes it from creation or save operations. It doesn't name a sibling tool, but 'existing' implicitly separates it from new_project and save operations.

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

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

It gives a clear practical instruction: 'Save the current project first,' establishing a prerequisite for safe use. However, it doesn't explicitly state when not to use this tool or name alternatives.

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

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

The description goes beyond the minimal annotations by disclosing that world points are projected through the current camera and that hidden surfaces require another camera view. This gives agents important behavioral context about coordinate handling and visibility limitations, and it is consistent with readOnlyHint=false since painting is a mutating action.

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 sentences with no filler. The primary purpose is front-loaded, and the coordinate-system details are condensed into one focused second sentence, making it 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?

The description captures the essential selection and invocation guidance: what the tool does, how points are interpreted in each space, and the camera limitation on hidden surfaces. An output schema exists so return values need not be described. It could be more explicit about how layer_id/material_id defaults of -1 behave, but the overall scope is well covered.

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

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

The description adds meaningful semantics for the central parameters: it clarifies that screen points use normalized viewport coordinates and world points use XYZ, which directly informs the space and points parameters. However, parameter descriptions are absent for the other seven parameters; the schema provides names, types, defaults, and enums, but no narrative guidance for radius, opacity, hardness, layer_id, material_id, or text.

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 on a specific resource: 'Paint one continuous stroke.' This clearly distinguishes the tool from siblings like fill_layer or clear_layer by emphasizing continuous, stroke-based painting rather than area fills or clearing.

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 useful usage constraints by explaining normalized viewport coordinates for screen points and XYZ projection through the current camera for world points, plus the hidden surfaces limitation. However, it does not explicitly name alternatives or state when to prefer this tool over related tools like fill_layer, clear_layer, or set_layer.

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

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

Annotations already indicate this is not read-only, not idempotent, and not destructive, so the safety profile is covered. The description adds useful scoping by specifying that the redo targets the most recently undone operation, but it does not disclose what happens when there is no undo history or whether repeated calls consume multiple entries from the redo stack. For a no-parameter tool this is a moderate but not severe 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, front-loaded sentence with no wasted words. It states the action and the precise object in under ten words, which is ideal for a simple tool definition.

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 parameters and an output schema exists, the description is largely complete for selecting and invoking it. The only missing detail is the behavior when there is nothing to redo (e.g., no prior undo), which would be useful but is not critical for the common case.

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

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

The input schema has zero parameters, so the description carries no parameter-documentation burden. The schema already covers everything, and a baseline of 4 is appropriate for a parameterless tool.

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

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

The description uses a specific verb ('Redo') and a specific target ('the most recently undone operation'), making the tool's function unambiguous. It also differentiates itself from the sibling armorpaint_undo by explicitly referring to an undone operation rather than an operation to be undone.

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 should be used after an undo has occurred, meaning there is an undone operation to redo. However, it does not explicitly state when not to use it, mention that it requires a prior undo, or reference alternative tools such as armorpaint_undo.

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

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

Annotations already mark this as destructive, and the description adds meaningful behavioral detail: removing a node also removes its links, and the PBR output node cannot be removed. This goes beyond the structured annotation without contradicting it.

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, each earning its place. The main action is front-loaded and the protective constraint is stated clearly with 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 destructive operation with two parameters and no schema descriptions, the definition is incomplete. The role of material_id and how the target material is selected are missing, and while an output schema exists, the ambiguity around parameters remains a significant gap.

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

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

Schema description coverage is 0%, so the description needed to clarify both node_id and material_id. It gives enough context to infer that node_id identifies the node to remove, but material_id is left unexplained, including its default of -1 and whether it refers to the current material.

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 ('Remove') and identifies the exact resource ('a material node and its links'). It also adds a distinguishing constraint ('The PBR output node is protected') that sets it apart from related operations like armorpaint_add_node or armorpaint_disconnect_nodes.

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 use for deleting material nodes and their connections, and the PBR output protection gives a clear exclusion. However, it does not explicitly explain when to prefer this over armorpaint_disconnect_nodes when only links need removal, nor does it mention context like the currently selected material.

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?

Discloses behavior not visible in annotations: the path must be absolute, pack_assets is optional, and existing files require overwrite=true. Annotations already signal a non-read-only, non-idempotent operation; the description adds the overwrite guardrail and file-format detail. It doesn't describe failure modes, but the key behavior is covered.

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

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

One sentence, front-loaded action, and no filler. Every clause contributes a distinct fact: path, format, pack option, and overwrite requirement.

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

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

For a simple save operation, the essential conditions are covered: target path, pack behavior, and overwrite requirement. The presence of an output schema reduces the need to explain return values. Minor omissions such as requiring an already-open project are not critical 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 descriptions are 0% covered, yet the description effectively documents all three parameters: path_name (absolute .arm path), overwrite (existing files require true), and pack_assets (optionally packing imported assets). This fully compensates for the schema gap and adds meaning beyond the parameter names.

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 clear verb ('Save'), resource ('the project'), target format ('absolute .arm path'), and two behavioral modifiers (pack_assets, overwrite). It stands apart from siblings like open_project, export_textures, and export_layer because it targets the whole project file rather than a layer, 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?

Provides clear operational context: save must target an absolute .arm path, and existing files require overwrite=true. It does not explicitly name alternatives or state when not to use it, but the save-project scope is communicated clearly enough to route an agent without ambiguity.

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

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

Annotations are all false, which is ambiguous, and the description adds no behavioral context beyond the verb itself – it does not say whether selection changes active application state, whether it requires an existing layer, or what side effects may occur. No contradiction with the annotations, but the 'select' action is underspecified.

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, front-loaded sentence that states the operation and key constraint with zero 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?

Despite having an output schema, the absence of parameter explanation (especially the -1 sentinel), selection semantics, and differentiation from set_layer leaves an agent under-informed. For a state-mutating tool in a domain with 40+ siblings, more context is needed for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does partially by explaining that layer_id is a 'stable ID', which signals that IDs are persistent and can be reused. However, it does not explain the special value -1, how to discover valid stable IDs, or the origin of these IDs (e.g., from list operations).

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

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

Uses a specific verb ('Select') and resource ('layer') with the distinguishing detail 'by stable ID', which hints at how it differs from set_layer and create_layer. The main gap is the unstated relationship to armorpaint_set_layer, which likely selects the active layer too.

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 'by stable ID' phrase implies the intended use case, but no explicit guidance is given for when to choose this over select_object, select_material, or set_layer. No when-not-to-use or alternative conditions are stated, so an agent must infer the selection context 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?

Annotations provide no safety hints (readOnlyHint=false, destructiveHint=false), so the description must explain what selecting a material changes and what side effects occur. It only says 'select,' which is minimally informative and does not disclose whether a project must be open, whether selection affects later operations, or how invalid IDs are handled.

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 exactly what the tool does and nothing more.

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 very simple operation and presence of an output schema, the description is close to adequate. However, it omits practical context such as prerequisites, the effect of selecting a material, and the meaning of edge-case IDs, which matters because annotations do not clarify behavior.

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

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

Schema coverage is 0%, so the description must add meaning. 'Stable ID' clarifies that material_id is a persistent identifier rather than a runtime index, but it does not explain how to obtain a valid ID or what the minimum value of -1 represents.

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 ('Select'), an exact resource ('material'), and the key distinguishing detail ('by its stable ID'). It is immediately distinguishable from siblings like select_object and select_layer.

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

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

No guidance is given about when to use this tool versus related material tools such as create_material, import_material, delete_material, or set_material_pbr. The intended context is implied rather than 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?

Annotations already show the operation is not read-only and not destructive; the description adds that the identity comes from get_state. It doesn't explain side effects like replacing the current selection or invalid-index behavior, but those are largely implied by a simple select 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?

One sentence of a dozen words conveys the action, target, and data source, with no filler or repetition of the schema's type/minimum 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?

The tool is low-complexity (one required integer parameter) and has an output schema, so the description covers the essential call contract. Minor ambiguity remains about the exact get_state field and behavior on an out-of-range index, but not enough to materially impair use.

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

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

With 0% schema coverage, the description must do the work, and it does: it explains that index is zero-based and that a valid value comes from get_state. It could be more specific about which get_state field/array to read, but for a single integer parameter the semantic guidance is strong.

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 an explicit verb ('Select'), a concrete resource ('a mesh'), and the selector semantics ('zero-based index returned by get_state'). This is enough for an agent to distinguish selecting an object/mesh from selecting materials or layers among the 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 phrase 'returned by get_state' gives a clear workflow precondition: call get_state first and then use the generated index. It doesn't mention alternatives such as set_object or when not to use it, but the intended usage context is clear.

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

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

The description discloses the primary state-changing behaviors: orbiting by yaw/pitch, moving by zoom, resetting the view, and switching projection modes. It is consistent with readOnlyHint=false, but it does not mention side effects, whether changes persist, or whether a project must be open. The annotations are all false, so the description carries the burden and only partially satisfies it.

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

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

The description is only two sentences, with the core actions front-loaded and no redundant filler. Every clause adds useful information, including the projection enum mapping.

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 camera operations are described, and the output schema reduces the need to explain return values. But with six parameters, particularly the missing fov semantics and lack of guidance on how reset, yaw/pitch, and zoom interact, the description is not fully complete for reliable invocation.

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

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

With schema description coverage at 0%, the description must explain parameters, and it does cover yaw/pitch as radians, zoom as forward movement, reset as view reset, and projection as 0/1. However, the fov parameter is not mentioned at all, and zoom direction or parameter interaction is left vague.

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 identifies the tool's purpose: it orients, moves, and resets the camera, and it maps projection values to perspective/orthographic. It uses specific verbs with a specific resource. However, it does not explicitly differentiate this tool from the sibling armorpaint_set_viewport, so it falls just short of a 5.

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

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

The description explains what the tool does but gives no guidance about when to use it versus alternatives like armorpaint_set_viewport. There are no usage conditions, prerequisites, or exclusions, so the agent must infer 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?

All annotation hints are false, so the description carries the burden of behavioral disclosure. It only adds object_mask scope and an opacity range that is already present in the schema. It does not state whether omitted parameters are left unchanged, how layer_id=-1 behaves, or what side effects editing a layer can have.

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 text is brief and front-loaded, but it is under-specified for a tool with nine parameters. The second sentence adds some useful detail, yet the overall description is more sparse than 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?

With nine parameters, no schema-level descriptions, and uninformative annotations, the description is seriously incomplete. It lacks behavior around optional fields, enum meanings, and how object_mask interacts with layer editing, so an agent cannot reliably invoke the tool with correct semantics.

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

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

Schema description coverage is 0%, so the description must compensate for the nine parameters, but it only clarifies object_mask and repeats opacity's schema range. The meanings of blend, uv_type, angle, scale, visible, name, and layer_id remain unexplained, leaving the agent to guess at important values.

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

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

The description opens with 'Edit a layer,' a clear verb-plus-resource statement. The object_mask and opacity details hint at the properties involved, though it does not explicitly distinguish this from sibling tools like set_layer_channels, layer_action, or clear_layer.

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

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

There is no guidance about when to call this tool versus armorpaint_create_layer, armorpaint_fill_layer, armorpaint_layer_action, or armorpaint_set_layer_channels. The object_mask sentence explains a parameter effect but does not help an agent decide whether this tool is the right one for a task.

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

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

The description names the enable/disable action but does not explain the crucial behavior of null versus boolean values, whether existing channel data is preserved or replaced, or what happens when no channels are specified. Annotations provide only generic false hints, so the description carries the transparency burden but leaves important behavioral semantics unexplained.

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

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

The description is a single front-loaded sentence with no wasted words. The verb and object appear immediately, and the rest of the sentence adds relevant scope without 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?

Given eight parameters and a dense sibling set, the one-sentence description is incomplete. It does not explain null semantics, layer selection context, or how to relate this to the surrounding layer and material tools. The output schema exists, so return-value details are less critical, but setup and operational context are still missing.

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

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

Schema description coverage is 0%, so the description must compensate for the eight undocumented parameters. It groups the booleans conceptually as 'PBR channels' but does not map them to base_color, roughness, metallic, etc., nor does it clarify the meaning of null for optional channels or the role of layer_id.

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

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

The description uses a specific verb ('Enable or disable') and a clear resource ('individual PBR channels on a paint or fill layer'), so an agent can tell this is a layer-channel configuration tool. It does not explicitly contrast with sibling tools such as armorpaint_set_layer or armorpaint_set_material_pbr, but the channel-focused language is reasonably distinctive.

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 instead of related siblings like armorpaint_set_layer, armorpaint_set_material_pbr, or armorpaint_fill_layer. No prerequisites, such as requiring an existing layer or a selected layer, 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?

The description disclosed an important behavioral side effect: existing links to those channels will be disconnected. This goes beyond the provided annotations, which only indicate non-read-only and non-idempotent behavior. It does not explain how omitted/null parameters behave or how material selection works, but the core mutational consequence is clear.

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, no filler, and the core action plus side effect are front-loaded. Every word contributes to the agent's understanding.

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 9-parameter mutation tool, the description is thin on how the target material is selected (material_id default -1), what happens when parameters are null or omitted, and whether only provided channels are updated. The output schema exists, so return values are less critical, but the missing targeting/null semantics leave gaps.

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

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

With 0% schema description coverage, the description is responsible for parameter meaning. It adds one useful detail: color uses RGBA values in the ArmorPaint material UI. The other channel parameters are self-explanatory by name and have min/max in the schema, but material_id semantics and the meaning of null/default values are left undefined.

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

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

The description states a specific action ('Set'), a clear target ('constant PBR channel values'), and a distinguishing side effect ('disconnecting existing links to those channels'). This differentiates it from related graph-manipulation tools like armorpaint_set_node_value or armorpaint_connect_nodes, even without naming 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 'constant values' and 'disconnecting existing links' implies this tool is for replacing texture-linked PBR inputs with fixed values, but it never explicitly says when to use it over siblings such as set_node_value or connect/disconnect_nodes. No when-not or alternative guidance is 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?

All annotations are false and carry little safety signal, so the description shoulders the behavioral burden. It discloses one meaningful constraint — the numeric array length must match get_material_graph's report — and 'Set' correctly implies mutation. It does not describe failure modes, reversibility, or effects on existing connections, but there is no contradiction with annotations.

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

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

Two sentences with no filler; the first leads with the verb and object, and the second carries a genuinely useful constraint. The description is appropriately compact for the information it conveys, though the minimal length means it forgoes richer parameter explanation.

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 complex node-graph manipulation tool with five parameters, four required, and zero schema-level descriptions. The description never explains how node_id and index address ports within the graph, whether material_id is needed, or what value types the array should contain. The output schema covers return values, but the input addressing scheme is too under-specified for an agent to call this correctly without guessing.

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

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

With 0% schema description coverage, the description must compensate for all five parameters. It partially does: the 'kind' enum values (input/output/button) are echoed, and the length constraint clarifies the 'values' array. It leaves node_id, index, and material_id undefined, and the index semantics (position within a port list) remain ambiguous.

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

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

'Set a node input, output, or button value' is a specific verb+resource description that clearly identifies the operation. It implicitly distinguishes the tool from graph-topology siblings like connect_nodes, disconnect_nodes, add_node, and remove_node, since it addresses value-setting rather than structure. However, it does not explicitly name a sibling for differentiation, and the relationship to get_material_graph is only implied.

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 hints at a prerequisite — the values array length must match what get_material_graph reports — which implies an ordered workflow of query-then-set. It provides no explicit when/when-not guidance or named alternatives among the many node-editing siblings. This qualifies as implied usage rather than clear context with 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?

The annotations already declare readOnlyHint=false and idempotentHint=false, establishing that this is a non-idempotent mutation. The description confirms the concrete operations (renaname, visibility) but adds no deeper context such as side effects, reversibility, or what happens when name/visible are null. With annotations carrying the base safety profile, the description adds modest value beyond them.

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 eight-word sentence with high information density and front-loaded verbs. Every word earns its place with no fluff. It is slightly terse — it could have added one clause of usage context without padding — but it remains appropriately sized for a simple setter.

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?

Complexity is low (three primitive params, no nesting, one required), and an output schema plus annotations are present, so retur n values need no explanation. Yet the description still omits meaningful context: how index identifies a mesh, whether name and visible are independent or combined, and when to choose this over select_object. Adequate for a simple mutator, but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. 'Rename' maps to the name property and 'show/hide' maps to visible, providing a useful operation-to-parameter linkage. However, the required index parameter is left entirely unexplained, and the nullable optional semantics of name/visible are not addressed. This is only partial compensation for the coverage gap.

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

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

The description states specific verbs and a resource: 'Rename or show/hide a mesh object.' It is clearly distinct from siblings such as armorpaint_select_object (selection) and armorpaint_import_mesh (importing). It falls short of a 5 because the dual-operation phrase is slightly ambiguous about whether name and visible can be combined, and it does not explicitly name the sibling it is not.

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. It does not mention that index refers to an already-listed/imported mesh, nor does it distinguish itself from armorpaint_select_object or the other setter sibs such as set_layer/set_camera. An agent must infer selection criteria solely from the sibling name list.

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

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

Annotations carry little weight (all hints false), so the description bears the disclosure burden. It adds one useful behavioral consequence (GPU memory scaling) beyond the annotations, but it does not disclose that downscaling resamples and can permanently discard texture detail, nor that the operation affects the entire project. No contradiction with annotations.

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

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

Two sentences, 13 words, with the action front-loaded. The second sentence earns its place by conveying a non-obvious consequence of the operation. There is zero redundancy or filler.

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

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

For a single-parameter tool with an output schema and a self-explanatory enum, the description covers the essentials: what is resized and a key side effect. The only notable gap is the lack of warning about data loss when lowering resolution, which would be relevant for an agent deciding whether to invoke this tool.

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

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

Schema description coverage is 0%, so the description should compensate, but the schema is largely self-documenting: the enum values (128–8192) are self-evidently pixel dimensions and the title is 'Resolution'. The description adds context by tying the parameter to texture maps and noting the memory impact of larger values, though it never states the unit explicitly.

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 ('Resize the project's texture maps'), leaving no ambiguity about what the tool does. It is clearly distinguishable from all 40+ siblings, none of which concern resolution or texture-map resizing.

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 explicit when-to-use guidance, exclusions, or named alternatives. However, the second sentence ('Larger maps increase GPU memory use') implies a quality-versus-memory tradeoff that suggests when an agent should consider adjusting this setting, and there is no competing sibling tool to confuse it with.

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

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

Annotations provide no positive hints, so the description carries the burden. It usefully discloses the valid mode values and their meanings, but it does not state whether this is a pure view-state change, whether it affects the project, or whether any prerequisites exist. The mapping adds meaningful context, but side effects remain opaque.

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

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

The description is a single, front-loaded sentence that packs the complete mode mapping into a compact list with no filler. Every word is useful and the numeric mapping is easy to parse.

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

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

Given zero schema description coverage and five parameters, the description is incomplete. The mode channel mapping is thorough, but the environment and wireframe parameters are unexplained, and no output/behavioral context is provided. An agent could call the tool with mode but would lack guidance for other intended settings.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the 'mode' parameter's channel mapping, which is valuable. However, four of five parameters (wireframe, environment, environment_angle, environment_strength) receive no semantic explanation beyond their schema types and names.

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

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

States a specific verb 'Set' and resource 'viewport channel', and enumerates the exact channel-mode mapping. This clearly distinguishes it from related viewport tools like capture_viewport or set_camera, at least by action and 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?

Usage is implied: use it when the user wants to change the viewport display channel. However, there is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no mention of related tools like capture_viewport.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the explicit statement 'without changing the project,' which reinforces the non-mutating behavior and introduces the local-connection and bridge-version scope. It does not go beyond this, but given strong annotation coverage, the additional context is sufficient.

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

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

A single, front-loaded sentence that states the action and scope with no filler. It is appropriately minimal for such a simple tool and every word adds value.

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

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

For a zero-parameter status check with rich annotations and an output schema, the description is fully adequate. It identifies exactly what is being checked and explicitly notes the absence of side effects, which is the key contextual concern for an agent deciding to invoke it.

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

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

The tool has zero parameters, so the description has no parameter burden. The baseline for a no-parameter tool is 4, and the description appropriately focuses on what the status check returns rather than adding irrelevant 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 ('check') and identifies precise resources ('local connection and supported bridge version'). The phrase 'without changing the project' clarifies its non-mutating scope. It does not explicitly name a sibling for differentiation, but the stated purpose is distinct enough from project-state tools like armorpaint_get_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?

The implied usage is to verify connectivity and bridge compatibility before performing other operations, but the description provides no explicit when-to-use or when-not-to-use guidance and does not mention alternative tools. For a status/health check, the context is reasonably clear, though exclusions are absent.

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

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

The annotations already indicate this is not read-only, not idempotent, and not destructive, so the description's job is lighter. It adds behavioral context by warning that not every operation is covered by history and that checkpoints protect whole workflows, which is useful beyond the structured hints.

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 no filler. The core action is front-loaded, and the caveat about operation coverage is placed second, making the description 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?

Given the tool has no parameters and an output schema is present, the description is largely sufficient. It communicates the main behavior and an important limitation, though it could more explicitly address edge cases like an empty history or the relationship to redo.

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 and the schema coverage is 100%, so there is no parameter-level burden on the description. The baseline for a no-parameter tool is 4, and the description appropriately focuses on behavior rather than inventing parameter detail.

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 ('Undo') and the resource ('most recent operation recorded by ArmorPaint history'), so an agent understands what the tool does. However, it does not explicitly differentiate itself from sibling tools like armorpaint_redo, leaving the distinction to inference from the name and context.

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 versus alternatives, such as 'use redo to reapply an undone operation' or 'use this when a recent action needs reversing.' The caveat about coverage is useful but does not tell the agent the conditions under which undo should be chosen.

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