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

No annotations are present, so the description must carry the full behavioral disclosure burden. It states the operation but does not mention that alignment mutates node positions, what alignment is computed relative to, whether nodes must share a parent, or any side effects. 'Relative to each other' adds some context but leaves major behavioral questions unanswered.

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

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

The description is a single sentence with no wasted words. It front-loads the operation and the scope ('multiple nodes relative to each other') efficiently.

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

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

For a mutating tool with no annotations and no output schema, the description is incomplete. It does not explain expected node count, whether the alignment applies to the group's bounding box or individual nodes, or how this relates to batch_align. An agent would need to infer too much to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents nodeIds and alignment adequately. The description does not add meaning beyond the schema, which fits the baseline of 3 for high schema coverage.

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

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

The description uses a specific verb and resource: 'Align multiple nodes relative to each other.' This makes the core operation clear, but it does not differentiate from the sibling tool batch_align, which likely performs a similar alignment operation across multiple 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?

There is no guidance on when to use this tool versus alternatives like batch_align, set_constraints, or reorder_node. The description only states what it does, not the conditions that make it the right choice.

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

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

No annotations are provided, so the description carries the full burden. It only states that the tool adds annotations but does not disclose whether existing annotations are replaced, whether this mutates the frame, or whether it only works on certain node types. This is a meaningful gap for a mutating tool.

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

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

The description is a single compact sentence with no filler. The action and target are front-loaded, 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?

For a single-parameter tool with no output schema, this is minimally usable. However, it lacks behavioral context such as whether the annotation is visual only, persistent, or destructive to existing annotations, so it is not fully complete for an agent.

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

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

The input schema already describes nodeId as 'Frame to annotate', and the description reinforces the same framing. With 100% schema description coverage, the description adds little beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Add') and resource ('color swatch annotations to a frame'), making the core purpose clear. However, it does not explicitly differentiate from sibling annotation tools such as annotate_spacing, annotate_typography, or set_annotation.

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

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

The phrase 'to a frame' implies the main use case: adding color swatch annotations specifically to a frame. But there is no explicit guidance about when to choose this tool over alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior, but it only says 'Visualize.' It does not disclose whether this is read-only, whether it creates persistent annotations on the frame, what it returns, or whether it modifies the design. The behavioral profile is underspecified for a tool that may add visual 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 a single, front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's purpose, and it is appropriately sized for a simple tool.

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

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

With no annotations and no output schema, the description needs to explain what calling this tool does and what the caller should expect. It does neither beyond a vague visualization intent. Missing details include whether the tool returns computed grid information, creates visible annotations, or requires specific frame 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?

Schema description coverage is 100%, so the input schema already documents both parameters ('Frame to annotate' and 'Grid size to overlay'). The description adds no information about nodeId or gridSize beyond that, keeping this at the baseline 3.

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

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

The description uses a specific verb ('Visualize') and names a concrete resource ('the underlying grid and spacing system of a frame'), so the core purpose is clear. It does not explicitly differentiate from sibling tools like annotate_spacing, but the focus on 'grid' gives enough distinction to be useful.

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

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

There is no guidance about when to use this tool versus alternatives such as annotate_spacing, create_measurement, or create_spec_sheet. The description implies it is for visualizing grid/spacing, but it provides no exclusions, prerequisites, or context for choosing it over similar annotation tools.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It says 'Annotate' but does not explain whether this creates persistent annotations, modifies document state, replaces existing annotations, or returns anything. For a mutation-like tool this is a meaningful gap.

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

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

A single, front-loaded sentence with no filler. Every word contributes meaning, and the key specifics are listed compactly.

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 a simple one-parameter schema and a clear purpose, but there is no output schema and no annotation metadata. The description does not explain what the annotation result looks like or whether it modifies the document, so it is not fully complete for an agent.

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

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

Schema description coverage is 100%, so the schema already documents that nodeId is the frame to annotate. The description does not add further parameter semantics, but per the baseline with high schema coverage this is acceptable.

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 ('Annotate') and resource ('visual hierarchy'), then specifies the exact aspects covered: heading levels, reading order, focal points. This clearly distinguishes it from sibling annotate_* tools like annotate_spacing, annotate_colors, annotate_typography.

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 described scope implies when this tool should be used, but there is no explicit guidance about when not to use it or which sibling tool to choose instead. Listing the specific hierarchy aspects gives some context, but leaves routing to the agent's inference.

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

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

No annotations are provided, so the description carries the full disclosure burden. The verb 'Annotate' hints at a non-destructive note-adding operation, but the description does not state whether this writes to the canvas, whether the frame itself is modified, whether annotations are reversible, how they are stored or displayed, or whether any analysis is performed. The text largely restates the tool name rather than revealing behavioral traits.

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 lean sentence with no redundant filler and the key domain is front-loaded. It is efficient for its length, though it is under-specified rather than over-long, and it largely rephrases the tool name instead of adding substantial new information.

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

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

With two parameters, no output schema, and no annotations, the description leaves the agent without expectations for return values, side effects, or how annotations relate to the broader responsive tool family. Given the crowded sibling ecosystem of responsive and annotation tools, the description is too thin to support confident tool selection.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema documents nodeId as 'Frame to annotate' and breakpoints as 'Breakpoints to annotate', and the description adds no further meaning such as the expected shape of the breakpoints array, whether it maps to existing breakpoints, or how the two parameters interact. The description neither compensates for nor worsens the schema.

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

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

The description uses a specific verb ('Annotate') with a resource ('a frame') and a precise domain ('breakpoint behavior and responsive rules'). This domain distinguishes it from sibling annotate_* tools (annotate_spacing, annotate_colors, annotate_typography, annotate_grid, annotate_hierarchy) and from responsive-modification tools like set_breakpoint and convert_to_responsive. However, it never explicitly names any sibling or the differentiating condition, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. An agent choosing between annotate_responsive, set_breakpoint, convert_to_responsive, create_responsive_variant, and responsive_check receives no routing help, and there is no mention of prerequisites such as performing a responsive check first. The context in which annotation is preferred over actual responsive modification is entirely 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?

No annotations are provided, so the description carries the full burden. It names the core behavior—adding redline spacing annotations—but does not disclose whether the operation is destructive, whether it replaces existing annotations, whether it requires special permissions, or whether it affects the frame in other ways. These are significant unknowns for a mutation-style tool.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, and the parenthetical '(redlines)' adds useful precision without bloating.

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

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

The tool is simple and the schema covers all parameters, making it minimally viable. However, with no annotations and no output schema, the description should disclose more about side effects and expected results. It is adequate but leaves meaningful behavioral gaps.

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

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

Schema description coverage is 100%, and the schema already explains nodeId as the frame and each boolean as a show/hide setting with defaults. The description adds no parameter-level detail, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Add') and identifies both the resource ('a frame') and the type of output ('visual spacing annotations (redlines)'). It clearly distinguishes this tool from sibling annotation tools like annotate_colors, annotate_typography, and annotate_grid by focusing specifically on spacing.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are many sibling annotation and spacing tools, but no mentions of exclusions, prerequisites, or preferred contexts, so the agent must infer usage entirely from the purpose.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not explain whether adding annotations mutates the node, creates separate annotation objects, overwrites existing annotations, or is purely non-destructive. The distinction between annotating typography and changing typography is not made explicit.

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

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

One compact sentence communicates the operation and scope with no filler. The key verb and target are front-loaded, and the parenthetical property list efficiently adds useful detail.

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

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

For a tool with one parameter, no output schema, and no annotations, the description leaves critical context missing: the target node type is ambiguous, the practical effect is unclear, and there is no guidance on how annotation tools relate to style-modification tools. More behavioral and usage context is needed.

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

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

Schema coverage is 100%, which normally warrants a baseline of 3, but there is a meaningful ambiguity: the schema describes nodeId as 'Frame to annotate' while the tool description says annotations are added 'to text nodes'. The description adds no parameter-level detail beyond this and does not resolve whether the caller should pass a text node ID or a frame 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 ('Add') and resource ('typography annotations ... to text nodes'), and enumerates the relevant properties (font, size, weight, line-height). This helps distinguish it from sibling annotate tools like annotate_spacing and annotate_colors, though it does not explicitly contrast with styling tools such as style_text_range.

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

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

There is no guidance about when to use this tool versus alternatives like style_text_range, batch_set_font, type_scale_apply, or annotate_hierarchy. The only usage signal is implied by the word 'annotations', but no when-to-use or when-not-to-use context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states that a blur is applied. It does not disclose whether the tool replaces or appends to existing effects on the frame, what the 'backdrop' semantics mean for layers behind the frame, or any side effects or prerequisites. 'Frosted glass' hints at backdrop behavior but does not make it explicit.

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

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

A single efficient sentence with no filler — the action verb is front-loaded and the parenthetical adds useful clarifying context about the visual effect. It earns high marks for brevity, though the available space could have carried more behavioral context.

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

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

For a mutation tool with no annotations and no output schema, the description is thin. It omits side effects (whether existing effects are overwritten), the meaning of 'backdrop' relative to other layers, and routing guidance against closely related siblings — all material gaps when an agent chooses among nearly 200 sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (amount with a default of 16, nodeId as target frame). The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Apply') with a precise resource ('background blur' / 'frosted glass effect') and target ('to a frame'), making the operation immediately identifiable and free of tautology. The parenthetical gives the agent the visual outcome, which distinguishes it from generic effect tools like set_effects, though the overlap is not explicitly addressed.

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 the many sibling effect and style tools (set_effects, create_glassmorphism, remove_all_effects, set_blend_mode, etc.). There are no conditions, prerequisites, or exclusions stated, so the agent must infer the appropriate 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?

No annotations are provided, so the description carries the full burden. It discloses the behavioral scope by listing the four audit areas, and 'audit' implies a read-only analysis. However, it does not state what the tool returns, whether it modifies anything, or what happens when issues are found.

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 crisp sentences with zero filler. The main action is front-loaded and the check list is compact and informative.

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 tool, the invocation requirements are clear, but the lack of an output schema and any return-format description leaves the agent unsure what an audit result looks like. It also doesn't clarify how this relates to closely related siblings like lint_design, check_contrast, or generate_a11y_report.

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

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

Schema description coverage is 100% and the description reinforces the 'node tree' concept, but it adds no parameter-specific detail beyond what the schema already says. Baseline of 3 is appropriate since the schema carries the load.

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

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

The description states a clear verb ('Run') and resource ('node tree'), and enumerates exactly what the audit checks: contrast, touch targets, font sizes, focus indicators. This distinguishes it from sibling tools like check_contrast (single check) and generate_a11y_report (report generation).

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 this is the comprehensive accessibility audit tool, but it never explicitly says when to prefer it over check_contrast, fix_touch_targets, lint_design, or generate_a11y_report. There is clear context but no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Align multiple nodes' and does not explain side effects, whether alignment mutates node positions, how vertical and horizontal parameters interact, or what happens when none are provided. This is minimal behavioral context.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and readable, though it could have used additional sentences to clarify usage or siblings without losing efficiency.

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 3-parameter schema, no annotations, no output schema, and a very large sibling list, this short description is insufficient. The agent cannot infer when to use batch_align, what the parameters mean in practice, or how this differs from align_nodes.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The parameters and their enum values are already documented in the schema, so the lack of parameter explanation in the description is acceptable.

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 'Align' and the target 'multiple nodes', so an agent understands the basic operation. However, the sibling tool 'align_nodes' exists and likely performs a similar operation, and the description does not distinguish batch_align from it.

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

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

There is no guidance about when to use this tool instead of align_nodes or other batch alignment tools. No alternatives, exclusions, or conditions are mentioned, leaving the choice of tool to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely states the destructive action without mentioning irreversibility, cascading deletion of children, partial failure behavior, or permission requirements.

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

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

'Delete multiple nodes.' is three words with no filler. The action and target are immediately front-loaded, and no sentence is wasted.

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

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

For a one-parameter tool with full schema coverage, the description is minimally adequate. However, because no annotations exist and the operation is destructive, important context like irreversibility or whether child nodes are affected is missing.

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

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

Schema description coverage is 100%, with nodeIds documented as 'Nodes to delete'. The description adds no extra meaning about ID format, ordering, or failure handling, so it stays at the baseline for fully-covered 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 states a specific verb ('Delete') and a pluralized resource ('multiple nodes'), making the tool's batch intent explicit. This distinguishes it from sibling delete_node, which presumably targets a single 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?

No guidance is given on when to use batch_delete versus delete_node or other batch mutations. The word 'multiple' implies the main use case, but there is no explicit when-to-use, when-not-to-use, or alternative routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that nodes are duplicated, without explaining whether originals are preserved, how offsets affect copies, what happens to selection, or whether any side effects occur.

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, direct sentence with no filler words. It is appropriately front-loaded and easy to parse, though it is extremely brief.

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

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

The tool is relatively simple and all parameters are documented, but the lack of annotations and output schema leaves some behavioral context unstated, such as what the operation returns and how offset values apply. The description is minimally viable but not rich enough for complete understanding.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description itself adds no additional meaning beyond what the schema provides, meeting the baseline.

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

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

The description 'Duplicate multiple nodes' uses a specific verb and resource, clearly indicating a batch duplication operation. The word 'multiple' helps distinguish it from the sibling 'duplicate_node' 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 batch usage through 'multiple', but it does not explicitly say when to prefer this over 'duplicate_node' or when not to use it. There are no explicit alternatives or exclusions provided.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It reveals that the tool mutates lock state on multiple nodes, but it does not explain failure behavior, whether the operation is all-or-nothing, what happens with invalid node IDs, or what the response contains. This is a meaningful gap for a mutation tool.

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

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

The description is a single front-loaded sentence with zero filler. Every word contributes to conveying the tool's operation and scope. Brevity is appropriate given the small, fully documented parameter set.

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

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

For a mutation tool with no annotations and no output schema, this description is too thin. It does not mention return values, failure semantics, or how the locked boolean affects previously locked nodes. An agent would need to infer a lot of behavioral detail that is not present in either the description or structured metadata.

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

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

Schema description coverage is 100%, so the schema already documents nodeIds as 'Target nodes' and locked as 'Lock state.' The description adds a small semantic link by mapping 'lock/unlock' to the boolean locked parameter, but this is already heavily implied by the schema. There is no substantial parameter information beyond what the schema provides.

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

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

The description states the specific verb 'Lock/unlock' and the resource 'multiple nodes,' making the operation and scope unambiguous. The plural scope distinguishes it from the singular sibling tool lock_node even without naming it. This is a clear, non-tautological statement of purpose.

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 'multiple nodes' implies this tool is for batch locking/unlocking, which differentiates it from lock_node for single nodes. However, the description does not explicitly state when to prefer this tool over alternatives, nor does it mention exclusions or edge cases. Usage guidance is only implied, not articulated.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does state that effects are removed and that the operation applies to multiple nodes, which is meaningful, but it leaves 'scope' undefined and does not mention irreversibility, permissions, or effect on other node properties.

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

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

Single sentence with no filler; the action and target are front-loaded and every word contributes. This is appropriately concise for a simple one-parameter tool.

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

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

For a one-parameter mutation tool, the definition is minimally viable, but the ambiguity around 'scope' and the lack of distinction from remove_all_effects leave gaps. No output schema is provided, so return-value detail is not required, but the scope semantics should be clarified.

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

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

The schema already fully describes nodeId as 'Root node' with 100% coverage, so the baseline is 3. The description's word 'scope' weakly connects to nodeId, but adds no additional parameter semantics, constraints, or formatting 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?

The description clearly states a specific verb ('Remove'), a specific resource ('all effects'), and a scope ('nodes in a scope'). However, it does not explicitly distinguish this batch tool from the closely named sibling remove_all_effects, so an agent must infer the batching distinction from the name.

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

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

There is no guidance on when to use this tool versus alternatives like remove_all_effects, set_effects, or batch_remove_strokes. The name implies a batch use case, but the description does not state the intended conditions or exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states that strokes are removed, which signals a destructive mutation, but it does not clarify whether the operation applies recursively to descendants, whether the root node itself is included, whether it is undoable, or what other side effects may occur. The term 'scope' is underdefined.

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

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

The description is a single sentence with no filler words. It front-loads the core action and resource. There is no redundancy, and every word contributes to the essential meaning.

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

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

For a batch operation with no annotations and no output schema, the description is incomplete. It does not define the extent of 'scope,' explain whether the root node and all descendants are affected, or mention return behavior or side effects. An agent could call this tool with an incorrect mental model of what nodes will be modified.

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

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

Schema coverage is 100% because nodeId is described as 'Root node.' The description adds the concept of a 'scope' linking nodeId to the set of nodes affected, but it does not elaborate on how the scope is determined. This adds marginal meaning beyond the schema but leaves important semantics ambiguous.

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

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

The description states a specific action and resource: 'Remove all strokes from nodes in a scope.' This is clearly distinct from sibling tools like set_stroke or batch_remove_effects, though it does not explicitly name them. The term 'scope' is somewhat vague, but the overall purpose is understandable.

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. The description does not mention set_stroke, batch_remove_effects, or remove_all_effects, nor does it specify whether this tool is preferred over per-node stroke removal. The agent is left to infer appropriate usage from the name and description alone.

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

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

With no annotations, the description must carry the behavioral burden. It only says 'rename multiple nodes' and does not disclose that this is a mutating operation, whether existing names are overwritten, how numbering works, or any side effects. This is insufficient for a mutation tool.

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

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

The description is a single concise sentence with no filler or redundancy. It is front-loaded with the core purpose and stays appropriately minimal.

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 are no annotations and no output schema, the description should explain more about what happens after execution, order of renaming, or behavior when names collide. The current description is too sparse to fully support reliable agent invocation.

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

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

Schema description coverage is 100%, so the schema already documents nodeIds, pattern, and startNumber. The description adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Rename'), the resource ('multiple nodes'), and the method ('using a pattern'). It is reasonably distinct from the sibling rename_node because it explicitly targets multiple nodes, but it does not explicitly contrast itself with 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?

There is no guidance about when to prefer this tool over rename_node or other batch operations, nor any mention of exclusions or prerequisites. The description implies batch renaming but does not help an agent decide between 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?

There are no annotations, so the description must reveal behavioral traits. It discloses that the operation replaces a color, but does not mention whether this modifies fills, strokes, effects, other color properties, whether it is destructive/reversible, whether it affects selected nodes or the whole document, or what happens with the optional scope node.

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

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

A single short sentence with no redundant words. The core action and scope are front-loaded, and there is no filler or repetition of schema details.

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

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

This is a mutating batch operation with no annotations and no output schema. The description is too minimal to fully support correct invocation: it does not clarify scope semantics, matching behavior, whether nodeId limits 'all nodes', what properties are affected, or whether there are side effects. Given the large sibling list and the batch/global ambiguity, more context is needed.

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

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

The input schema already documents all three parameters with descriptions (find, replace, nodeId), so schema coverage is 100%. The description adds little beyond 'across all nodes' and does not clarify hex format, color matching behavior, or how nodeId scopes the replacement, but it also does not need to repeat the schema.

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

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

States a clear action ('Replace') and object ('a color across all nodes'), and the optional nodeId implies scoping. However, it does not explicitly distinguish itself from the sibling color_replace_global or from set_fill, and 'across all nodes' is slightly ambiguous about whether it replaces fills, strokes, or other color properties.

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 set_fill, color_replace_global, or batch_replace_text. The phrase 'across all nodes' implies a batch use case, but there is no explicit when-to-use, exclusions, or mention of how optional nodeId affects the operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It correctly indicates a mutation (replacement), but it does not mention reversibility, how character styling is affected, whether all matching nodes in scope are modified, or any side effects. For a destructive batch operation, this is a significant gap.

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

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

A single concise sentence that front-loads the core behavior with no unnecessary words or repetition of 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?

The description and schema provide enough to understand what the tool does and how to invoke it, but there is no output schema and no annotation. It lacks guidance on appropriate use cases relative to alternatives and does not disclose potential side effects, which is relevant for a batch mutation tool.

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

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

Schema description coverage is 100%, with each parameter (find, replace, nodeId, matchCase) having a basic description. The tool description does not add meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('find and replace') and resource ('text across multiple text nodes'), making the operation unambiguous. It clearly distinguishes the tool from siblings like type_replace_font (replacing fonts) or batch_replace_color (replacing colors).

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 'across multiple text nodes' implies a batch context, but the description does not explicitly contrast with closely related siblings such as set_text_content or type_replace_font. There is no when/when-not guidance or mention of alternatives, so usage context is only inferred.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action. It does not mention whether the operation is destructive, how scale interacts with width/height, whether aspect ratio is preserved, or what happens when conflicting parameters are supplied.

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, direct sentence with no filler or redundant detail. It is appropriately front-loaded, though it may be too terse to fully earn its place given the lack of behavioral context.

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

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

For a mutation tool with no annotations, no output schema, and optional sizing parameters, the description is incomplete. It leaves unstated how the sizing parameters should be used together, what units are expected, and whether any node must be selected first, making it insufficient for confident invocation in complex cases.

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

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

Schema description coverage is 100%, so the input schema already explains the parameters (scale factor, new width, new height, target nodes). The description adds no semantic meaning beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description 'Resize multiple nodes' states a specific verb and resource, making the tool's core function clear. It does not explicitly distinguish itself from sibling batch tools like batch_style or batch_align, but the resize operation is unambiguous enough to avoid confusion.

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

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

There is no guidance on when to use this tool versus alternatives such as batch_align, modify_node, or individual resize operations. The phrase 'multiple nodes' implies batch usage, but no when-to-use or when-not-to-use context is provided.

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

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

No annotations are provided, so the description must disclose behavioral traits itself. It states the core mutation—rounding dimensions, positions, and spacing—but does not mention whether this affects only the root node or its subtree, whether changes are reversible, or whether it overwrites existing values irreversibly. For a mutating batch operation, this is a notable gap.

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

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

The description is a single, front-loaded sentence with no filler. Every word carries meaning, specifying the action, scope, and exact target properties.

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

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

Given the low complexity—one parameter, no nested objects, no output schema—this description plus the schema is largely sufficient for an agent to invoke the tool correctly. It would be more complete with a brief note on whether the rounding applies recursively, but the current definition still communicates the essential intent.

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

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

The single parameter `nodeId` is documented in the schema as 'Root node', giving the agent a clear enough indication of scope. The description adds no additional parameter-specific meaning but none is strongly needed due to the 100% schema coverage.

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

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

The description states a specific verb ('Round') and a precise resource and scope ('all dimensions, positions, and spacing to whole pixels'). It is clearly distinguishable from sibling batch tools, none of which target rounding to whole pixels.

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 the tool—when the user wants whole-pixel values for layout properties—but it does not state when not to use it or name any alternative such as `fix_spacing` or `normalize_design`. Usage context is clear but not fully explicit.

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

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

No annotations are present, so the description carries the full disclosure burden. It does convey the core behavioral traits: batch application, restriction to frame/rectangle nodes (others presumably untouched), and scoping under a root node. It does not disclose side effects (e.g., overriding existing radii), reversibility, or behavior on mixed selections, which are meaningful gaps for a mutating batch tool.

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

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

A single 10-word sentence is front-loaded with the action, target, and scope. There is zero wasted text — every word carries meaning. The brevity is appropriate given the two simple, self-describing parameters.

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

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

For a 2-param batch mutation with no output schema and no annotations, the description plus schema cover what, where, and scope. It omits what happens to non-frame/rectangle nodes, whether existing radii are replaced, and whether any result is returned. These are not fatal gaps, but the tool performs enough work that a sentence on behavior/return would round it out.

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

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

Schema description coverage is 100% (nodeId='Root node', radius='Corner radius'), so the baseline is 3. The description adds minimal meaning beyond the schema; it clarifies that nodeId defines the batch scope but does not specify radius units, range, or application behavior. The schema already carries most of the parameter semantics.

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

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

The description uses a specific verb-resource pair ('Set corner radius') plus a precise scope qualifier ('all frames/rectanglеs in scope'), which distinguishes it from the sibling set_corner_radius (single node) and the other batch_* tools. 'In scope' is slightly ambiguous on its own, but the nodeId 'Root node' parameter resolves the intended meaning.

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 context is implied: the 'batch' prefix and 'all frames/rectangles in scope' signal choosing this tool when many nodes need the same radius, versus set_corner_r_adius for a single node. However, it never names the alternative or states explicit when/when-not conditions; an agent must infer the distinction from the sibling list.

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

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

With no annotations, the description carries the full burden and does add one useful behavioral trait: it applies to 'all text nodes' in a scope, indicating bulk application. However, it does not disclose whether existing font overrides are overwritten, whether changes are reversible, or how 'scope' is interpreted (e.g., recursive).

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

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

The description is a single sentence that front-loads the action and resource with no filler. Every word contributes meaning, making it highly efficient.

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

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

The description is underspecified for a mutation tool with no output schema or annotations. The main gap is nodeId: it is optional in the schema, but the description never states what happens when no scope is given, leaving a critical ambiguity 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 coverage is 100% with descriptions for both nodeId ('Scope') and fontFamily ('New font family'), so the baseline is 3. The description mostly restates the schema rather than adding new meaning; notably, it does not clarify that nodeId is optional or what the default scope is when omitted.

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

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

The description states a specific action ('Change font family') on a specific resource ('all text nodes in a scope'), which clearly distinguishes it from siblings like set_fill or type_replace_font. The scope qualifier adds precision beyond a generic 'set font' tool.

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

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

The description gives no guidance on when to choose this tool over alternatives such as style_text_range or type_replace_font. There is no mention of intended use cases, exclusions, or context, leaving the agent to infer selection criteria.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does state the core effect—changing visibility of nodes—but it does not disclose secondary behavior such as all-or-nothing failure, handling of invalid node IDs, or idempotency. For a simple, low-risk mutation, the core behavior is at least transparent enough to earn a baseline 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?

The description is five words, front-loads the action and target, and contains no filler. Every word contributes meaning, making it an appropriately concise 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 two-parameter tool with no output schema and no nested objects, this description plus the schema is nearly sufficient: an agent knows what to pass and what effect to expect. It would be fully complete if it explicitly clarified that visible=true shows and visible=false hides, or if it named set_visibility as the single-node alternative.

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

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

Schema description coverage is 100%, so nodeIds and visible are already documented in the schema. The description adds only the 'multiple' qualifier and no additional format, syntax, or range details, which matches the baseline 3 for schema-covered 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 states a concrete action (show/hide) on a concrete resource (multiple nodes), and the word 'multiple' clearly differentiates it from the singular set_visibility sibling. It is not a tautology of the tool name and tells an agent exactly what the tool accomplishes.

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

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

There is no explicit guidance about when to use this tool versus set_visibility or other batch tools. The only usage cue is the implied 'multiple nodes' scope, but no alternatives, exclusions, or prerequisites are stated.

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

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

With no annotations, the description carries the full behavioral disclosure burden. 'Apply style changes' implies mutation but does not disclose whether existing style properties are overwritten, whether changes are reversible, or whether only specified properties are affected. For a batch mutation tool 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, front-loaded sentence with no filler. It efficiently communicates the core operation, though it misses opportunities to add brief guidance without bloating the text.

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

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

For a mutation tool with no annotations and no output schema, the description is too minimal. It does not clarify the effect on existing styles, the accepted value format for changes, or how it differs from the many sibling batch and style tools. An agent would need to inspect external examples to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the phrase 'at once' but no new parameter-level meaning; the changes examples in the schema ('fill, opacity, cornerRadius, fontSize, fontWeight, ...') are the primary semantic content.

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 and resource: 'Apply style changes to multiple nodes at once.' The 'multiple nodes' scope distinguishes it from the singular style tools like set_fill and set_stroke, though it doesn't explicitly name a sibling alternative.

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

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

No usage context is provided. The description does not explain when to choose batch_style over the many related tools such as batch_set_corner_radius, batch_remove_effects, or batch_resize, nor does it state any exclusions or prerequisites.

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

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

There are no annotations, so the description carries the full disclosure burden. It only states the swap scope and never explains what happens to overrides, hidden/locked instances, or whether the operation is reversible. For a mutating batch 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?

One sentence, no filler, and the core scope is front-loaded. Every word contributes.

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 two parameters, the essential scope and parameter identities are covered. However, with no annotations and no output schema, the description leaves important operational details (override handling, error behavior, reversibility) unaddressed, so it is adequate but not complete.

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

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

Schema coverage is 100%: the schema already describes oldComponentId as 'Component to replace' and newComponentId as 'Replacement component.' The tool description echoes this directionality but adds no new semantic value.

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 precise action ('Swap'), a precise object ('all instances of one component for another'), and a scope ('across the file'). This clearly separates it from the sibling swap_component, which reads as a more targeted swap.

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 'all instances... across the file' implies a global batch use case, but the description does not explicitly state when to prefer it over swap_component nor any when-not-to-use conditions. Usage guidance is inferred 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?

No annotations are provided, so the description must carry full behavioral responsibility. It states only the operation and omits side effects such as whether existing property values are overridden, whether the variable must already exist, or whether the binding is reversible.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for the simple operation it describes.

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

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

Given the low parameter count and fully documented schema, the definition is adequate for constructing a valid call. However, the lack of behavioral context, prerequisites, and any annotation or output schema leaves room for misinterpretation of what binding actually entails.

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

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

Schema description coverage is 100%, so nodeId, property, and variableId are already documented. The description reinforces the purpose but adds no parameter-level detail beyond what the schema provides, meriting the baseline score.

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

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

The description uses a specific verb ('bind') and identifies the resource ('variable' and 'node property'), clearly conveying the core action. It does not explicitly contrast it with sibling tools like set_fill or update_ariable, which slightly weakens differentiation.

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

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

The description gives no guidance on when to use this tool over alternatives such as set_fill for literal values or update_ariable for editing variables. No conditions, exclusions, or alternative tool references are provided.

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

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

With no annotations provided, the description carries the full burden of explaining behavioral impact, but it only says 'perform boolean operations' without stating whether the original nodes are modified, replaced, or combined into a new shape. It also fails to disclose what happens to the base shape versus the subsequent shapes, which is essential for a destructive geometry operation.

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

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

The description is a single short sentence with no filler, so it is concise. However, it is under-specified for an operation that mutates shapes and has non-obvious semantics around the base node and operation enum, making it smaller than 'appropriately sized' even though it is not verbose.

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

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

This is a mutation-style tool with no annotations and no output schema, so the description needs to carry more context. It omits key operational details: how many nodes are required, which node is the base, what the result is, and how the operation values differ in effect. The schema compensates partially, but the overall tool definition is not complete enough for an agent to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema fully documents nodeIds and operation, including the enum values and the note that the first node is the base shape. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description names a specific operation type (boolean operations) and a clear resource (shapes), which distinguishes it from the large sibling list where no other tool mentions boolean operations. It could be stronger by clarifying that it applies set-style combinations like union/subtract to multiple nodes, but the core purpose is clear.

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

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

There is no guidance about when to use this tool versus alternatives like group_nodes, flatten_node, or create_vector. The description only restates the obvious purpose, and it does not mention prerequisites such as requiring at least two selected nodes or the significance of node ordering.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Check' implies a read-only analysis, but the description never states what the tool returns, whether it mutates anything, what it compares against (local styles, variables, heuristics), or how results are delivered.

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 verb and scope with no filler; every word earns its place. It is appropriately compact for a one-parameter tool, though some brevity could have been traded for routing or behavioral context 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?

Since there is no output schema and no annotations, the description must explain what the check produces, and it does not. The existence of the near-duplicate sibling detect_inconsistencies and the lack of any differentiation make this definition materially incomplete for an agent choosing which tool to invoke.

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

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

Schema coverage is 100%, with nodeId documented as 'Root node to check,' so the schema already handles parameter semantics. The phrase 'across a design' adds modest context by implying the check traverses the subtree beneath the root node, but no substantive parameter detail is added beyond that.

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

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

The description names a specific action ('Check') and a concrete scope ('inconsistent colors, fonts, spacing, and radii across a design'), which clearly states what the tool does. However, it does not differentiate from sibling detect_inconsistencies, which appears to cover nearly the same purpose, so it falls short of full sibling separation.

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 detect_inconsistencies, lint_design, compare_to_system, color_check_all, or type_audit. The description contains no conditions, exclusions, or mention of alternatives.

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

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

With no annotations and no output schema, the description carries the transparency burden itself. It does disclose the core behavior—computing a contrast ratio between two colors—but it does not state the return format, whether it evaluates WCAG compliance, or how it handles invalid or non-hex colors. This is adequate for a simple pure calculation but leaves the output contract implicit.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds semantic value, and it is appropriately sized for a two-parameter utility tool.

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

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

For a simple two-parameter tool, the description plus schema is sufficient for invoking it correctly with two hex colors. However, the absence of an output schema and any mention of the return value or WCAG interpretation leaves a meaningful gap for an agent trying to use the result correctly.

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

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

Schema description coverage is 100%, with foreground and background each documented as color hex values. The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific operation ('check color contrast ratio') and scopes it to exactly two colors, which distinguishes it from broader sibling tools like color_check_all or audit_accessibility. This is not a tautology: it adds the 'ratio between two colors' detail beyond the tool name. The purpose is immediately clear to an agent.

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

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

The description gives no guidance about when to use this tool versus alternatives such as color_check_all, get_selection_colors, audit_accessibility, or generate_a11y_report. There is no mention of prerequisites, expected input context, or cases where a broader audit tool 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?

With no annotations provided, the description carries the full behavioral burden. It communicates that the tool flags generic names and gives concrete examples, which suggests a read-only check, but it does not explicitly state side effects, return format, or whether it validates only the root node or its entire subtree.

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 deliver the purpose and a concrete example with no wasted words. The main behavior is front-loaded and immediately 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 one-parameter check tool, the description is minimally adequate: it states what is checked and gives examples of flagged names. However, with no output schema and no annotations, it leaves the return value and exact scope of the check unspecified.

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

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

The schema covers the single parameter with a clear description ('Root node to check'), so schema description coverage is 100%. The tool description adds no further parameter-level detail, keeping this at the baseline.

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

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

The description clearly identifies the tool's purpose: checking layer naming conventions and flagging generic names. It is specific enough to distinguish from rename-focused siblings like rename_node or batch_rename, though it does not explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus alternatives such as batch_rename, rename_node, lint_design, or check_consistency. The description implies its use for naming validation but provides no exclusions or decision criteria.

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

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

With no annotations, the description carries full burden, but it only says 'Remove', leaving ambiguity about recursive behavior, effect on locked layers, irreversibility, or what counts as hidden. The dryRun parameter is only in the schema, not the description, so the preview option isn't surfaced to the agent.

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

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

A single, tight sentence front-loads the action and object, with no filler. It is as concise as possible while still conveying the core 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?

The tool is destructive and lacks annotations and an output schema, so an agent needs more context about scope and consequences. The description doesn't specify recursion depth, locked-layer handling, or what 'hidden' means, leaving a non-trivial 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?

Since schema description coverage is 100%, the schema fully documents nodeId and dryRun; the description adds no further parameter meaning. Thus baseline 3 is appropriate, though the description doesn't reinforce the semantics.

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

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

The description uses a specific verb ('Remove') and a specific resource ('hidden layers from a node tree'), making the operation clear and distinct from siblings like set_visibility or delete_node. It also implies the scoping unit (node tree), which helps an agent understand what is affected.

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

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

No when-to-use or when-not-to-use guidance is provided. The description doesn't contrast with sibling tools such as delete_node or set_visibility, and doesn't specify scenarios that call for cleaning hidden layers.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Apply' is the only behavioral cue and implies mutation, but the description does not say whether it overwrites existing fills/strokes, whether it depends on a pre-created style, or what happens on failure. For a mutation tool with zero annotation coverage, this is a meaningful gap.

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

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

The description is a single front-loaded sentence with zero filler words, comparable to the efficient update_drive calibration example. It earns its place but buys no additional context for the agent, so it is efficient rather than exemplary.

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 no annotations, no output schema, and a large sibling set (set_fill, set_troke, color_create_style), the description is too sparse. It omits key runtime facts an agent needs: the target style must already exist, the application replaces the current property value, and the tool is for named styles rather than direct color assignment. The agent would have to guess these behaviors.

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

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

Schema description coverage is 100%, with all three parameters (nodeId, property, styleName) individually documented and the fill default for property stated in the schema. The description adds essentially nothing beyond what the schema already provides, so the baseline 3 for high coverage is appropriate.

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

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

The description uses a specific verb (Apply), a specific resource (color style), and a target (node), which is grammatically complete and meaningful. It implicitly distinguishes from set_fill/set_stroke (which set raw color values) and color_create_style (which creates styles), but never explicitly names these contrasts, so the distinction is inferred rather than stated.

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

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

The description gives no guidance on when to use this tool versus alternatives like set_fill/set_stroke, nor does it state prerequisites such as the style needing to already exist or how a missing style name is handled. No exclusions, contexts, or alternative routes are mentioned anywhere.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states intent, not effect. It does not say whether this is a read-only preview, whether it modifies the design, what the output looks like, or what side effects may occur.

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, waste-free sentence. It states the action, the object, and the goal without 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 tool with no annotations and no output schema, the description leaves critical context missing: what the agent will receive after invocation, whether the operation is safe/destructive, and how 'issues' are reported. An agent can glean the tool's intent but not the full contract.

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

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

Schema coverage is 100%, so the schema already documents both parameters and the type enum. The description adds no additional meaning about how nodeId is resolved or how the type affects simulation, which keeps this at the baseline.

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

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

The description uses a specific verb ('simulate') and names the resource ('a design') and outcome ('check for issues'), clearly distinguishing it from contrast-checking or accessibility-audit tools. It is slightly vague about what 'issues' means, but the core purpose is unambiguous.

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

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

The description implies it is used to preview color vision deficiencies, but gives no explicit guidance on when to choose this over sibling tools like check_contrast, audit_accessibility, or color_check_all. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden of disclosure. The verb 'Check' suggests a read-only analysis and the scope ('every text/background pair') adds behavioral context, but the description does not state whether the tool modifies anything or describe its return value. This is a partially transparent definition.

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 immediately conveys the core function with no filler. The key qualifiers ('every', 'in a frame') are front-loaded. This is an ideal length 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?

The definition is adequate for an agent to invoke the tool with the correct nodeId and standard, and the sibling list clarifies the broader toolset. However, because there is no output schema, the description should ideally indicate what is returned (e.g., a list of violations) to fully support post-call interpretation. The missing return contract is a minor but real 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?

The input schema already documents both parameters fully (nodeId as 'Root frame', standard enumerated as AA/AAA with a default). The description adds no new parameter-level information, so it stays at the baseline for high schema coverage.

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

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

The description uses a specific verb ('Check') and a precise resource ('WCAG contrast for every text/background pair in a frame'). The 'every ... in a frame' qualifier clearly distinguishes it from a single-pair check like check_contrast. It unequivocally states what the tool does.

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

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

The description implies the intended use case: a full-frame audit of text/background contrast. However, it does not explicitly contrast with sibling tools like check_contrast or audit_accessibility, nor say when not to use it. Guidance on alternatives is left to inference.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It only says 'Create a local color style,' which implies mutation but does not explain side effects, whether an existing style is overwritten, how 'local' is scoped, or what the tool returns. This is a significant transparency gap for a creation operation.

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

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

The description is a single short sentence with no fluff and front-loads the main action. However, it is so minimal that it borders on under-specification rather than earned conciseness; it does not add context that would justify its brevity for a tool with many siblings.

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 no output schema, no annotations, and a long list of sibling tools including color_apply_style and color_replace_global, this description is incomplete. It lacks guidance on where the style is created, how it relates to variables or tokens, and what happens after creation, leaving agents without enough context to invoke it correctly.

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

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

Schema description coverage is 100%, so the parameters are already documented with name examples and 'Color hex'. The description adds no additional parameter meaning or usage nuance, which lands it at the baseline of 3.

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

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

The description states a clear verb and resource: creating a local color style. It is specific enough to distinguish from applying or replacing color styles, but it does not explicitly name a sibling alternative or clarify what 'local' means relative to library/global styles.

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

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

There is no guidance about when to use this tool versus the many color-related siblings such as color_apply_style, color_replace_global, or create_design_tokens. The description simply states what it does, leaving the agent to infer appropriate usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool creates a new node or mutates the existing frame, whether the original is preserved, or what 'intelligently' means in terms of color transformations.

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 word 'intelligently' is vague and adds little, but overall the structure is appropriately concise.

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

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

With no output schema and no annotations, the description should clarify whether the tool returns a new node, modifies in place, or how brandColor is preserved. None of this is addressed, making it incomplete for an agent deciding how to invoke and interpret the result.

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

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

Schema description coverage is 100%, so the schema already documents nodeId and brandColor. The description adds no parameter-specific meaning beyond the generic notion of a frame and colors.

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

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

The description uses a specific verb ('Generate') with a clear resource ('a dark mode variant of a frame') and states the action ('mapping all colors intelligently'). It also distinguishes itself from the sibling color_lightmode tool 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 clearly implies when to use this tool: when a dark mode variant of a frame is needed. However, it does not explicitly mention when not to use it or name the alternative color_lightmode, leaving some routing to inference.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It states the main behavior—extract unique colors and organize by frequency—but neither confirms read-only status nor describes output format or potential side effects.

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

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

The description is a single focused sentence with no filler. The core operation is front-loaded, and the frequency-organization behavior follows immediately, making it easy for an agent 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?

For a one-parameter, low-complexity tool, the description covers what is extracted, the scope (a frame), and the arrangement (by usage frequency). However, with no output schema, it leaves the exact return structure and color representation unspecified.

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

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

Schema coverage is 100%, but the schema only says 'Root node.' The description's phrase 'from a frame' adds meaningful semantic value by clarifying that nodeId should identify a frame node, going beyond the bare parameter description.

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

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

The description uses the specific verb 'extract' and names the resource ('a frame'), and adds the output dimension 'usage frequency.' It clearly states what the tool does, though it does not explicitly contrast it with color-related siblings such as get_selection_colors or export_color_palette.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative tool is named. Given a large sibling set of color and export tools, the agent must infer the appropriate context from the description 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?

No annotations are provided, so the description carries the full burden. It lists the output roles but never discloses whether the tool is a pure computation returning token values or a mutating operation that writes styles/fills into the document (a real ambiguity given siblings like color_create_style and color_apply_style). It also does not describe the output format or how the 'both' mode shapes the result.

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

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

One tight sentence, front-loaded with the verb and resource, with the role list packed efficiently at the end. No wasted words and no repetition of schema content.

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

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

The core purpose and inputs are covered, but the tool has no output schema and no annotations, so the description should explain what is returned and confirm whether any document mutation occurs; neither is present. In a crowded color-tool sibling space, routing guidance would also strengthen the definition.

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

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

Schema description coverage is 100%: brandColor is documented as 'Brand color hex' and mode has a clear enum with a stated default. The description adds no meaning beyond listing brandColor as the seed, so the baseline of 3 applies.

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

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

The description states a specific verb ('Generate'), a specific resource ('full semantic color system'), and enumerates the exact roles (bg, surface, border, text, brand, status). This clearly distinguishes it from close siblings like color_palette_generate (a plain palette), color_extract, or color_harmonize, and from color_create_style which applies styles to a document.

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

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

The phrase 'from one brand color' implies the trigger condition: use this when you have a single brand seed and need a complete semantic token set. However, there is no explicit when/when-not guidance and no reference to alternatives such as color_palette_generate for a non-semantic palette or color_darkmode/color_lightmode for mode-only conversion.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a generation operation but does not disclose what the tool returns, whether it mutates state, how invalid hex values are handled, or what default scheme applies when none is selected. This is a meaningful transparency gap for an unannotated tool.

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

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

The description is a single concise sentence that front-loads the action and gives concrete examples of the output type. Every word contributes to meaning, with no filler or redundant restatement of the tool name.

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

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

For a simple two-parameter generation tool with a full enum, the input contract is largely covered. However, with no output schema and no mention of the return value, default behavior, or color format expectations, the agent cannot fully predict how to consume the result. The description is adequate but leaves clear gaps.

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

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

Schema description coverage is 100%, with baseColor documented as 'Base color hex' and scheme constrained by an enum. The description adds no per-parameter semantics beyond the schema and even omits two valid enum values, tetradic and monochromatic, so it stays at the baseline rather than exceeding it.

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

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

The description uses a specific verb and resource: 'Generate harmonious colors' followed by concrete scheme examples. It clearly identifies the tool's function, though it does not explicitly differentiate it from closely related siblings like color_palette_generate or suggest_color_palette.

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

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

There is no guidance on when to use this tool versus alternatives such as color_palette_generate, suggest_color_palette, or color_generate_semantic. The description implies usage through the tool name and scheme examples, but it never states conditions, exclusions, or preferred contexts, leaving the agent to guess.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates the conversion direction but not whether the operation mutates the original frame, creates a new node, or how brandColor is preserved. The term 'variant' is ambiguous about the side effects and lifecycle of the operation.

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

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

The description is a single sentence with no filler or redundant phrasing. The action and target resource are front-loaded, and every word contributes to the basic meaning.

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

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

For a transformation tool with no annotations and no output schema, this description is under-specified. It does not clarify whether the tool returns a new node, modifies the existing frame, or what 'variant' means in terms of child nodes, fills, and text. The required schema fields are documented, but the behavioral context an agent needs to use the tool correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds no extra semantics about how nodeId or brandColor affect the output, but the schema already documents both fields adequately at a basic level.

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 ('Generate') and a clear object ('a light mode variant of a dark frame'), so an agent can tell this tool produces a light-mode result from a dark frame. It distinguishes itself from the sibling color_darkmode through the light/dark contrast, but it does not explicitly name that alternative or call out the distinction.

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

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

The description implies the tool is for dark frames that need a light mode variant, which gives some usage context. However, it provides no explicit when-to-use guidance, no exclusions, and does not mention color_darkmode as the inverse tool for light-to-dark conversion.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, and it only supplies a one-line purpose. It does not state the return format, whether anything is mutated or persisted, or how the 'steps' parameter (default 10) maps to the claimed '50-950 shades' — a genuine ambiguity. No side-effect or output-shape disclosure 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?

The single sentence is front-loaded and contains no filler; the verb and resource are stated immediately. The brevity is a slight liability because the space saved could have held usage or output details, but as written it is efficient.

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

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

There is no output schema and no annotations, so the description must cover return values and behavioral context, and it does not. It also fails to differentiate among a sibling list dense with color-related tools (suggest_color_palette, export_color_palette, color_extract, color_harmonize, color_generate_semantic), and the steps-vs-shades ambiguity is left unresolved.

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

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

Schema description coverage is 100%: baseColor is documented as 'Base color hex' and steps as 'Number of shade steps (default: 10)', so the baseline of 3 applies. The description adds little parameter meaning, and its '50-950 shades' phrasing actually creates tension with the steps default of 10, leaving the relationship between steps and the shade count unexplained.

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

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

States a specific verb ('Generate'), a clear resource (a full color palette from a base color), and a concrete output range (50-950 shades). This is specific enough to roughly distinguish it from siblings like export_color_palette or color_extract, though it does not explicitly name or contrast alternatives.

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

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

No guidance on when to use this tool versus the many close siblings in the list, including suggest_color_palette, export_color_palette, color_harmonize, and color_generate_semantic. There are no exclusions, prerequisites, or conditions stated; usage context is only weakly implied by the verb 'Generate'.

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

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

With no annotations, the description carries the behavioral burden. It discloses the key behavior—replacing a color globally across all pages—but does not mention side effects, irreversibility, or whether it affects all color usages beyond fill/stroke. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It states the action, resource, and scope compactly without redundancy.

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

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

For a simple two-parameter global replacement tool, the description conveys the essential operation and scope. It does not describe return values or edge cases, but no output schema exists and the action is straightforward enough for an agent to invoke correctly.

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

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

The input schema already provides 100% coverage for both parameters, describing them as hex color strings. The description adds no parameter-level detail, so baseline 3 is appropriate.

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

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

The description states a specific verb ('Replace'), a clear resource ('a color'), and an explicit scope ('across the entire document (all pages)'). This clearly distinguishes it from more localized color tools like set_fill or set_stroke.

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 'across the entire document (all pages)' conveys when this tool is appropriate: for document-wide color replacement rather than per-node or per-page changes. It does not name alternatives or exclusions, but the global scope provides clear enough context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only comparison and says deviations are 'flagged', but it does not disclose whether the tool mutates anything, what scope it checks, how deviations are returned, or what constitutes the 'established design system'. This is minimal behavioral context beyond the tool's name.

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

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

The description is a single concise sentence with an active verb, a clear object, and a result, so it is front-loaded and free of filler. It loses a point because it is so terse that it omits useful context that could have been added without bloating the description.

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

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

There is no output schema, no annotations, and only vague context about what 'design' and 'established design system' mean. The description does not explain the output format, the system being compared against, whether the operation is safe/non-destructive, or how this tool relates to the many similar sibling tools. For a tool with no annotations and no output schema, this is 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?

Schema description coverage is 100%, and the only parameter, nodeId, is already described as 'Node to compare'. The description adds no extra parameter semantics, such as whether nodeId can be a frame, a component, a selection, or whether it defaults to the current selection. Baseline 3 is appropriate because the schema already handles parameter documentation.

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

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

The description states a clear action (compare), a target (a design), and a result (flag deviations against the established design system). It is specific enough to convey the tool's core function, but it does not distinguish itself from closely related sibling tools like detect_inconsistencies, check_consistency, or lint_design, and 'design' is ambiguous about whether it means the selected node or the whole document.

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

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

There is no guidance about when to use this tool versus similar alternatives. It does not mention whether to run it on a single node, a selection, or an entire page, nor does it name any alternative tools or exclusion conditions. The agent must infer usage purely from the tool name and one-line 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?

With no annotations, the description carries the full burden of behavioral disclosure. It communicates that the tool finds component issues, which implies a non-mutating audit, but it does not state side effects, output format, or whether it modifies anything. 'Missing components' is also left vague.

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 tight, front-loaded sentence with a colon and a scannable list of audit targets. There is no filler or redundant wording.

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

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

The description is too lean for a tool with no annotations and no output schema. It does not explain what 'missing components' means, what the return value looks like, or what the optional nodeId scope actually scopes. Given the large sibling set of audit/validation tools, this creates ambiguity 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?

The schema description coverage is 100%, and the description adds no extra meaning to nodeId beyond what the schema already says ('Scope'). Baseline 3 is appropriate because the schema carries the parameter documentation.

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

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

The description uses a specific verb ('Audit') with a clear resource ('components') and enumerates concrete outputs: detached instances, missing components, unused variants. This distinguishes it from sibling tools like list_components or validate_component, which have different purposes.

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

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

The description implies usage for auditing components, but it gives no explicit guidance on when to prefer this tool over alternatives such as validate_component, detect_inconsistencies, or scan_design_system. There are no exclusions or conditions provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals a mutating behavior (conversion) but does not state whether the operation is destructive or reversible, how it affects children of the frame, what constraints/sizing modes are applied, or whether it fails on non-frame nodes. For a conversion tool that modifies layout structure, 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?

One clear, concise sentence that is perfectly sized for the tool's simplicity. Every word earns its place, and it is front-loaded with the verb and resource.

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 is a structural mutation with no annotations and no output schema, the description is under-specified. It lacks information about success/failure conditions, effects on child nodes, whether layout sizing and constraints are automatically applied, and what state the node will be in after conversion. A conversion tool with this little context is hard for an agent to invoke with confidence.

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

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

Schema description coverage is 100%, so the schema already documents the single nodeId parameter with description 'Root frame to convert'. The description adds the concept of converting fixed-width to responsive auto-layout, which clarifies the intended parameter semantics. However, it doesn't add details beyond the schema about what kind of frame qualifies or how the nodeId is interpreted.

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

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

The description states a clear action ('Convert fixed-width designs to responsive auto-layout') with a specific resource (fixed-width designs) and outcome (responsive auto-layout). It distinguishes itself from related siblings like create_responsive_variant, set_breakpoint, and responsive_check, though it doesn't explicitly name alternative 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 implies the tool is for converting fixed-width designs to responsive auto-layout, which gives context for when to use it. However, it provides no explicit guidance on when not to use it, no alternatives, and no prerequisite conditions (e.g., whether the node must be a frame, whether auto-layout must already exist, or whether a fixed-width selection is required).

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 key side effect—copying to the clipboard—which is more than the name alone provides. However, there are no annotations, and the description does not clarify whether copied content is plain CSS text, whether it overwrites existing clipboard contents, or what the tool returns, leaving some behavioral ambiguity.

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

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

A single concise sentence with no filler. It front-loads the core action and destination, making the tool's purpose immediately 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 one-parameter clipboard operation, the description communicates the essential behavior and required input. It is slightly incomplete regarding the format or return value, but the simplicity of the tool and the absence of an output schema mean the core invocation context is adequately 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?

Schema description coverage is 100%, with nodeId documented as 'Node to get CSS for'. The description adds no additional parameter semantics, but the schema already provides sufficient meaning for the only parameter, so the baseline of 3 applies.

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

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

States a specific verb ('Copy'), resource ('CSS properties of a node'), and destination ('clipboard'). This distinguishes it from related siblings like read_node_css, which reads CSS but does not copy it, and generate_stylesheet, which produces stylesheets rather than copying node properties.

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 clipboard destination implies the intended use case: when the agent needs to copy CSS properties for pasting elsewhere. However, it does not explicitly contrast with alternatives such as read_node_css or mention when not to use this tool, so guidance is present but only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. Saying 'Create an arrow shape' implies mutation but does not explain where the arrow is inserted, whether it modifies the current selection, whether it requires any permissions, or what the return value is.

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 or repetition. It is terse and front-loaded, though it is minimal enough that it under-specifies contextual behavior.

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

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

For a creation tool with five parameters, no output schema, and no annotations, the one-line description leaves gaps around return values and creation context. However, the schema fully documents parameters and defaults, so the minimum information needed for basic invocation is present.

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

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

Schema description coverage is 100%, and all five parameters already have descriptions, including defaults for direction and strokeWeight. The description adds no extra parameter-level meaning, but the schema does the necessary work, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Create an arrow shape.' It clearly identifies what the tool does and is distinguishable from shape-creation siblings by naming the arrow shape type. However, it does not explicitly differentiate itself from create_line, create_vector, or other similar creation tools.

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

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

There is no guidance about when to use create_arrow versus alternatives like create_line, create_vector, or other shape tools. The description does not mention preconditions, selection requirements, or when a different tool 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?

With no annotations, the description carries the full burden. It does disclose the non-obvious technique of using a slightly larger frame behind, which hints at structural side effects. However, it does not explain whether a new frame is created, whether the node is reparented, how depth/stacking is handled, or whether this is reversible.

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

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

The description is a single, focused sentence that communicates the core action and implementation approach without filler. It is appropriately sized for the tool's simplicity and front-loads the primary 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?

The tool mutates the design tree by introducing a frame behind the target, but the description does not mention return values, side effects on layout, grouping, or what happens to existing borders. For a tool with no annotations and no output schema, this is under-specified for an agent to call confidently.

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

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

Schema description coverage is 100%, so the parameter documentation already covers nodeId, startColor, endColor, and width. The description adds no additional meaning about color format, width defaults, or units beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Create') and names the resource ('gradient border effect'), and it clarifies the implementation approach ('using a slightly larger frame behind'). This distinguishes it from related tools like set_stroke or set_gradient_fill, though it could more precisely state that it creates a new frame behind the target 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?

No guidance is given for when to use this tool versus alternatives such as set_gradient_fill, set_stroke, or create_frame. There are no conditions, exclusions, or mentions of when the frame-based approach is preferable, leaving the selection decision to the agent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only promises an outcome quality ('proper spacing and alignment'). It does not disclose where the grid is created (current page? selected frame?), whether it produces a grouped frame or freestanding cards, what happens when no cards are passed, or whether existing nodes are affected. For a node-creating tool 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?

A single ten-word sentence that is front-loaded and contains zero filler. Every word contributes. It loses a point because the sentence is efficient but thin — it does not earn its place with the kind of scoping or routing information a richer description would carry.

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 4 optional parameters, no annotations, and no output schema, the description is inadequate. An agent cannot tell where the grid lands, what node structure is produced, whether it is idempotent, or what happens on empty input. The creation context (parentId behavior, selection fallback) is entirely undresolved, and no sibling is referenced to disambiguate the design intent.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter (cards, columns, parentId, brandColor) is already documented in the schema. The description adds only loose contextual meaning ('grid,' 'spacing' imply columns and card layout) but no format, default, or relationship detail beyond the schema. It neither compensates for gaps nor harms the baseline.

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

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

The description uses a specific verb ('Create') and resource ('a grid of cards'), making the core function clear. It is distinguishable from the many sibling shape-creation tools (create_rectangle, create_text) since 'grid of cards' is a composite layout artifact. It falls short of a 5 because it does not specify what a 'card' structurally is or how this differs from composite creation siblings like create_frame or create_section.

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

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

There is no guidance about when to use this tool instead of alternatives, and no sibling is referenced. Among roughly 200 siblings including create_frame, create_section, and create_icon, an agent gets no criteria for choosing create_card_grid over a manual frame-plus-card assembly. The implied usage (pass cards and columns) must be inferred entirely from the schema.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It mentions generating a visual changelog but does not disclose whether the tool mutates the file, creates a new node, or whether the operation is reversible.

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

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

A single sentence with no filler, front-loaded with the verb and resource. Every word contributes to clarifying 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?

With no annotations and no output schema, the agent lacks critical operational context: what the changelog looks like, where it is placed, and what side effects the 'create' action has. The required parameters are clear, but the overall behavior is under-specified.

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

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

The schema already documents both parameters with clear descriptions ('Before frame', 'After frame') at 100% coverage. The tool description reinforces the before/after comparison semantics but does not add new parameter-level detail beyond the schema.

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

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

The description states a specific action ('Compare two frames') and a specific output ('visual changelog showing what changed'). This clearly distinguishes it from sibling tools like compare_to_system, which compares against a design system rather than comparing two frames.

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 the tool: when an agent needs to compare a before and after frame and produce a changelog. However, it does not explicitly name alternatives or provide exclusion criteria, leaving some selection inference to the agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the high-level creation action and does not mention side effects: whether the selected node is converted or copied, whether a parentId is required, what happens to the existing selection, or what the resulting component contains. This is a significant gap for a creation tool.

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

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

A single sentence with no filler, front-loading the core action and source condition. 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?

With 6 parameters, no annotations, and no output schema, the description is too terse to be complete. It omits essential behavioral distinctions: when fromNodeId is used versus creating a brand-new frame, whether width/height or parentId are required in each mode, and what the tool returns or changes. The close sibling tools amplify the need for richer context.

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

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

Schema description coverage is 100%, so the baseline is 3. The prose adds conceptual context ('current selection or a new frame') that loosely maps to fromNodeId, width, and height, but it does not explicitly connect these descriptions to the parameters or clarify which parameters apply to which mode.

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

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

States a clear action ('Create') and resource ('reusable component') plus a source condition ('current selection or a new frame'). It is unambiguous about what the tool does, but it does not explicitly differentiate from sibling tools like create_component_set or create_component_instance.

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 context by naming two invocation modes: converting the current selection or creating a new frame. However, it gives no exclusions or pointers to alternatives, and the sibling list contains several very similar create_component_* tools, so an agent could not confidently route to this tool versus create_component_instance or create_component_set.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only states that documentation frames are 'generated.' It doesn't disclose whether this mutates the document by inserting new frame nodes, whether frames are placed on the current page or require a selection, whether existing frames get overwritten, or whether the operation is reversible. For a creation tool this leaves significant behavioral uncertainty.

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

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

One sentence with no filler, and the verb and resource are front-loaded. The qualifier 'showing all variants, props, and usage' is informative and earns its place by telling the agent what output content to expect.

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 param, no output schema, no annotations), so the description covers the basic invocation correctly. But it leaves open where the frames are created, how this differs from sibling documentation/export tools, and what the agent should expect after invocation. These gaps are material given the absence of annotations and output schema.

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

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

Schema description coverage is 100%, with componentId documented as 'Component to document,' so the baseline is 3. The description reinforces this by mentioning 'a component' but adds no format, source, or prerequisite detail beyond the schema. The description doesn't need to compensate for a coverage gap, but it also doesn't add value.

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

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

The description uses a specific verb ('Generate') and resource ('documentation frames for a component') and enumerates the scope ('all variants, props, and usage'). This clearly states what the tool produces. However, it doesn't explicitly distinguish itself from closely related siblings like export_component_inventory, create_spec_sheet, or export_design_specs, relying on the word 'frames' to imply in-canvas artifacts.

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 no guidance on when to use this tool versus alternatives such as export_component_inventory, export_design_specs, or create_spec_sheet. There are no prerequisites (e.g., component must exist), no usage conditions, and no exclusions. An agent must infer applicability from the name and generic description alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Instantiate' and does not explain that this creates a linked instance, where the instance is placed, or what errors can occur. The description is accurate but minimally 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?

Four words, no filler, and the key constraint 'existing' is front-loaded. It is concise, though arguably too terse to carry the behavioral context needed.

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

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

A moderate three-parameter tool with no annotations and no output schema needs more than a one-line purpose statement. The description omits return value, default parent behavior, and linking semantics, leaving important context for the agent to guess.

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

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

Schema coverage is 100%, so the input schema already documents componentId, parentId, and overrides with examples. The description adds no parameter-level meaning, which is acceptable because the schema is doing the work.

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

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

The description uses the specific verb 'Instantiate' and names the resource 'an existing component', so the action is clear and distinct from creating a new component. It does not explicitly call out sibling tools or edge cases, so it stops short of full differentiation.

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

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

There is no guidance on when to choose this tool over create_component, duplicate_node, or swap_component, and no mention of prerequisites beyond the implied requirement that the component already exists. An agent must infer usage context from the schema and the long sibling list.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Combine component variants into a variant set' and does not state whether a new object is created, whether the original variants are modified, whether the IDs must belong to the same base component, or what the tool returns.

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

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

The description is seven words, front-loaded with the verb, and contains no filler. 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 simple two-parameter creation tool, the definition is minimally viable: both required parameters are fully documented and the core task is stated. However, without an output schema or annotations, an agent still lacks return behavior and practical requirements such as whether the variants must share a base component.

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

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

Schema coverage is 100%, so the description does not need to compensate for missing parameter documentation. It does add mild semantic reinforcement by implying componentIds refer to component variants and name is the resulting set name, but it adds no constraints or format details beyond the schema.

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

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

The description states a specific action ('Combine') and resource ('component variants' into a 'variant set'). The term 'variant set' clearly distinguishes this tool from sibling tools like create_component, create_component_instance, and create_smart_component.

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 scenario—use this when component variants exist and need to be combined into a set—but it provides no explicit preconditions, exclusions, or alternatives. There is no guidance on when not to use this versus related component-creation tools.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that multiple collections will be created, but it does not state whether existing tokens are overwritten, whether this creates variables/styles, whether repeated calls duplicate token sets, or what side effects occur despite the generative nature of the tool.

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

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

Two sentences with no filler; the main action is front-loaded, and the second sentence expands the scope with the exact collection types produced. This is appropriately sized 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?

The description gives a clear high-level outcome and the schema covers all inputs, so an agent can make a reasonable first call with brandColor. But without an output schema or annotation, it should also hint at the return value or side effects (e.g., created variable collection names) to be 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 100%, and the schema already documents name, withModes, and brandColor. The description adds nothing semantically new about the parameters beyond tying brandColor to the system generation, so the baseline score of 3 is appropriate.

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

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

The description names a specific action ('Generate a complete design token system from a brand color') and spells out the resulting resource types: color, spacing, radius, and typography collections. It does not explicitly contrast with sibling tools like import_tokens or create_variable_collection, but the core purpose is unambiguous.

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

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

The phrase 'from a brand color' gives clear context for when the tool is appropriate, and the optional withModes parameter implies light/dark token creation. However, there is no explicit when-not-to-use guidance or mention of alternatives for existing token sets or manual variable creation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool creates a divider line but says nothing about side effects, default placement, selection behavior, or return values. For a mutation tool, 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 wasted words or redundant information. It is appropriately sized for the tool's simplicity and fully 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?

Given the tool has no annotations, no output schema, and minimal context, the description is too sparse. It does not explain where the divider is created, how it behaves relative to siblings or parent nodes, or what the agent should expect after calling it. More context is needed for reliable tool selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning beyond what the schema already provides, but the schema includes useful descriptions like 'auto-fills parent if omitted' and default values, 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 verb and resource: 'Create a horizontal or vertical divider line.' It clearly identifies the tool's function and the two supported orientations, making it easy to understand what it does. However, it does not explicitly differentiate from similar create tools like create_line or create_vector, 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?

There is no guidance on when to use this tool versus alternatives such as create_line, create_rectangle, or other creation tools. The description simply states what the tool does, leaving the agent to infer appropriate usage without any context or exclusion criteria.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It only states the action; it doesn't reveal whether the new node lands in the current selection/board, whether it becomes selected, what happens without a parentId, or any document-state effects beyond the name default already in the 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?

A single five-word sentence with zero filler, front-loaded with the verb and object. It is efficient, though the brevity borders on under-specification; the lacking content is already penalized in other dimensions.

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

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

For a creation tool with 6 parameters, no annotations, and no output schema, this description is too thin. It doesn't explain placement context, required vs optional parameters, defaults, or return behavior, forcing an agent to open the schema and still guess at document-level 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 100% with all six parameters documented, so the baseline of 3 applies. The description adds nothing about parameters, relying entirely on terse schema descriptions like 'Width' and 'Parent node ID', which is adequate but 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 verb (Create) and resource (circle or oval) that maps directly to the tool name and distinguishes it from obvious siblings like create_rectangle or create_star. However, it doesn't address overlap with generic creators like create_vector or create_svg_node, which could also produce ellipses.

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 prefer this tool over alternatives. With dozens of create_* siblings, an agent receives no hint about when create_ellipse is appropriate versus create_vector, create_icon, or create_svg_node, and no exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning whether this mutates the document, whether it overwrites existing flows, whether a selection is required, or what response is expected. For a creation tool, 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, front-loaded sentence with no filler words. It efficiently communicates the core action and resource, making it easy for an agent 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?

For a two-parameter tool with full schema coverage, the description is minimally sufficient to attempt a call. However, the lack of annotations, output schema, and usage guidance leaves gaps around the actual document effect and how this flow relates to other prototype tools.

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

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

Schema description coverage is 100%; both parameters ('Flow name' and 'Starting frame') are adequately described in the schema. The tool description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Create a prototype flow starting point.' It clearly identifies the tool's action and differentiates it from sibling tools like create_prototype_link or list_flows by focusing on creating a flow start. However, 'starting point' is somewhat vague and doesn't explain what a flow is in Figma terms.

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

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

The description provides no guidance on when to use this tool versus alternatives such as create_prototype_link or set_transition. There are no exclusions, prerequisites, or context cues to help an agent decide between creating a flow and other prototype-related operations.

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

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

There are no annotations, so the description carries the full behavioral disclosure burden. It only states that a footer is created; it does not mention side effects, defaults, whether parentId is needed, where the footer is inserted, or any mutation implications.

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, tight sentence with no filler or repetition. It front-loads the core purpose and includes useful component details, though it remains sparse in behavioral guidance.

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 five optional parameters, no required fields, and no output schema, the description does not give enough context for an agent to know what to pass or what happens by default. Key details like required inputs, defaults, and creation location are missing.

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

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

All five parameters already have descriptions in the input schema, so the description adds little parameter-level value. The mention of columns and links aligns with the schema but does not enrich the meaning beyond it.

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

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

The description clearly identifies a specific verb ('Create') and resource ('page footer'), and lists its primary components: columns, links, and copyright. It is clear enough to distinguish from most create_* siblings, though it does not explicitly contrast itself with related tools like create_header.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no placement context. Amid a large set of create_* tools, an agent is left to infer that this should be used when a footer is needed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what is produced (a form layout) but not how the tool behaves: where the form is inserted in the document, whether parentId is required or optional in practice, whether repeated calls accumulate or replace, or what the tool returns. For a mutating create operation with zero annotation coverage, this is a significant gap.

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

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

A single 13-word sentence with zero filler; the resource and its contents are stated up front in the first clause. Every word earns its place and the structure is immediately 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?

With no annotations and no output schema, the description must stand alone, and it does not. An agent cannot tell where the form is created, what 'validation states' actually renders, whether a page or selection must exist first, or what a successful call returns. For a 4-parameter mutation tool operating on a design canvas, this is incomplete and leaves key invocation decisions to guesswork.

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

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

Schema description coverage is 100%, so the baseline is 3. The description loosely maps to parameters (labeled inputs → fields, submit button → submitLabel) and adds mild context by describing validation states, which correspond to the type/required properties in the fields array. However, it adds no extra meaning for parentId or brandColor beyond the schema's one-liners, so it neither compensates for gaps nor substantially enriches semantics.

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

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

The description states a specific verb ('Create') and resource ('form layout') and enumerates the contained elements: labeled inputs, validation states, and submit button. It is immediately distinguishable from the large pool of create_* siblings (create_nav_bar, create_card_grid, create_sidebar_layout) because no other tool targets forms. This is a specific verb+resource statement that an agent can act on.

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

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

The description gives no guidance on when to prefer this tool over alternatives, no prerequisites, and no exclusions. With roughly 150 siblings including many create_* layout tools, the agent must infer usage purely from the tool name. This matches the 'no guidance' level rather than implied usage, since no contextual signal about the design workflow 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one genuinely non-obvious behavior: auto-layout is applied automatically even if not explicitly requested. However, it stops short of describing what the 'design-intelligent defaults' actually are, where the frame lands by default, or what the call returns — all significant for a 19-parameter creation tool.

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

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

Two short sentences with no wasted words; the core purpose is front-loaded and the differentiating behavior (auto-layout defaults) follows immediately. 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 19-parameter tool with no annotations and no output schema, the description is thin: it omits return value / node-ID chaining information, the meaning of 'design-intelligent defaults', and guidance on choosing between create_frame and specialized siblings. It is minimally viable because the inline schema covers most parameter semantics, but an agent still cannot predict side effects or chain the result.

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

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

Schema description coverage is 100%, so the baseline of 3 applies; the schema already documents all 19 parameters including enums, 8px grid snapping, and hug-contents behavior. The description adds only the vague 'design-intelligent defaults' phrase, which gestures at but does not specify parameter behavior beyond the schema.

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

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

The description names a specific verb and resource ('Create a frame') and clarifies scope with parenthetical synonyms (screen, section, card, container), helping an agent recognize valid use cases. The auto-layout note hints at differentiation from non-container siblings like create_rectangle, but it does not explicitly distinguish this from specialized siblings such as create_section or create_card_grid.

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 'Automatically applies auto-layout with design-intelligent defaults' implies this is the choice when an agent wants a smart container, but no explicit when-to-use or when-not-to-use guidance is provided. It never names an alternative (e.g., create_section, create_rectangle, set_auto_layout) or states exclusions, leaving routing decisions to inference.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the main behavioral traits by enumerating the effect components: background blur, semi-transparent fill, and subtle border. However, it does not explain whether this effect replaces existing effects, whether it mutates the node permanently, or what side effects occur beyond the visible style changes.

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 that front-loads the core action and then lists the effect properties. Every word earns its place, and there is no 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 simple three-parameter style tool, the description is mostly adequate, but it lacks important context about interaction with existing effects, whether the border is configurable, and whether the effect replaces or merges with current fill/effect settings. The absence of annotations and output schema increases the need for more behavioral context.

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

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

Schema description coverage is 100%, so the schema already documents the parameters. The description adds minimal semantics beyond matching blur and opacity to the effect traits, and it does not mention the nodeId parameter at all.

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