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

No annotations provided, so description carries full burden. It discloses the binding behavior for TEXT and BOOLEAN types but does not mention error handling, side effects (e.g., overwriting existing properties), or required permissions. Examples provide some insight but gaps remain.

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?

Description is well-structured with a brief header, bullet points for parameters, and separate examples. While it could be slightly more concise (e.g., removing redundant 'Parameters:' header), it is efficient and easy to parse.

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

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

No output schema is present, and the description does not mention return values or confirmation of success. For a mutation tool, specifying what happens on successful execution (e.g., returns the updated component) would improve completeness. Otherwise, it covers purpose, parameters, and examples adequately.

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 covers all 5 parameters with descriptions (100% coverage). Description adds value by explaining how the 'type' parameter affects binding behavior (TEXT->text, BOOLEAN->visibility) and provides concrete examples. This contextual enrichment goes 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?

Description clearly states verb ('Add') and resource ('component property') and specifies binding to child node. Differentiates from sibling tools like 'create_component' or 'list_component_props' by detailing the binding mechanism.

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

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

Provides explicit guidance on when to use each type (TEXT binds to text, BOOLEAN binds to visibility) and includes practical examples. However, lacks explicit when-not-to-use or alternative tool references.

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

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

No annotations exist, so the description fully discloses behavior: return format (answers array or freeText), UI behavior (auto-injected 'Other', visual cap, auto-focus), conventions, and recommended option placement.

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

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

Well-structured with sections: purpose, usage, return, question details, conventions, example, skip note. Every sentence adds value without redundancy.

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

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

Comprehensively covers all aspects given no output schema: return values, parameter nuances, behavioral context, and usage guidelines. Leaves no gap for agent decision-making.

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?

Despite full schema coverage, the description adds critical context: conventions for recommended option, bundling, not adding own 'Other', and detailed return format. Goes well beyond schema explanations.

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 tool asks the user 1-3 questions in a single form. It distinguishes itself from sibling tools like 'describe' or 'help' by focusing on interactive decision-making.

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?

Explicitly provides when to use (ambiguity, need for decision, multiple valid approaches) and when to skip (prompt already actionable). Includes bundling advice and examples.

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 provided, so description must carry the burden. It discloses that COLOR variables are not bound here and explains workarounds, plus mode selection logic. However, it does not mention that binding is a mutating operation or any required permissions, which would improve transparency.

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

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

Well-structured: starts with main action, then details props, color exclusion, mode selection, and ends with examples. Every sentence adds unique value with no redundancy.

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

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

Covers major aspects: supported types, prop list, color exclusion, mode selection, and examples. Lacks description of return value (e.g., success/error), but for a simple binding tool this is acceptable. Overall complete given complexity.

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

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

Schema covers all three parameters with descriptions, but the description adds significant value: lists example prop values, shorthands (gap→itemSpacing), exclusions (colors), and context for mode selection. This goes well 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 clearly states the tool binds FLOAT/BOOLEAN/STRING variables to node properties, lists supported properties (e.g., fontSize, paddingTop), and explicitly excludes COLOR variables with references to set_fill/set_stroke. This distinguishes it well from sibling tools.

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

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

Provides explicit when-to-use (binding non-color variables) and when-not-to-use (color variables, with alternative tools named). Also gives mode selection guidance for Tablet/Mobile variants, helping agents choose the correct mode column from list_variables.

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

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

No annotations exist, so the description must convey behavior. It discloses deep-copy nature and optional overrides. However, it omits what the tool returns (e.g., cloned node ID) and error conditions.

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?

Extremely concise: one sentence plus five short examples. All content is front-loaded and relevant. No redundant or missing 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?

Covers the main use case well with examples for root, custom parent, name, and overrides. Lacks specification of return value (likely new node ID), but overall adequate for the tool's complexity.

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

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

The input schema has 100% coverage with descriptions, so baseline is 3. The description adds value through five examples showing parameter combinations and defaults, going beyond schema alone.

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

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

The description clearly states 'Deep-copy a node with optional property overrides,' which is a specific verb (clone) and resource (node). This purpose is distinct from sibling tools like move_node or delete_node.

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

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

The description provides examples but no explicit guidance on when to use this tool versus alternatives (e.g., copy vs move vs create). Usage context is implied but not 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 behavioral traits disclosed beyond the basic action. No mention of side effects, permissions, or constraints. Since no annotations are provided, the description fails to fill the 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 plus an example. Front-loaded, 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?

Given the simplicity of the tool (2 parameters, no output schema, no annotations), the description is mostly complete with the example. However, it lacks details on return values or error conditions.

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 baseline is 3. The example adds some value by showing typical usage, but the description itself adds no extra semantics 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 clearly states the verb 'Combine' and the resource 'multiple components into a variant set (ComponentSet)'. This action is distinct from sibling tools like create_component or create_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?

No guidance on when to use this tool versus alternatives like create_component. No exclusions or prerequisites mentioned.

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

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

No annotations provided, but the description discloses important behavior: the first mode becomes default, and the return structure includes mode IDs for use with set_variable_value and set_variable_mode. It does not mention side effects or reversibility, but for a creation tool, this is adequate.

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 succinct: one sentence for purpose, one for return and usage, and two example calls. No extraneous 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?

Given the tool has only two simple parameters, no output schema, and no annotations, the description covers the core information needed to use it correctly: what it does, what it returns, and how to use the return values.

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 covers both parameters fully (100% coverage), and the description adds value by clarifying that the first mode in the array becomes default, and with examples showing typical usage patterns.

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 tool creates a VariableCollection with named modes, distinguishing it from siblings like create_variable (creates a single variable) and ensure_collection (which would create or retrieve).

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

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

The description explains how to use the returned modeIds with other tools and provides examples, but does not explicitly state when to use this tool versus alternatives like ensure_collection, 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. It only says 'convert' without disclosing side effects like whether the original node is modified or if children are affected. This is insufficient for an action that likely mutates state.

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

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

The description is short and includes a concise example, which is beneficial. However, it could be slightly more structured with a clear summary.

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

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

Despite only one parameter, the description lacks information about return values (e.g., confirmation, new component ID) and behavioral context. Given no annotations or 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 coverage is 100% and the description adds only an example, which does not provide additional meaning beyond the schema's description of the node parameter. 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 clearly states it converts a frame or group to a Figma component, which is a specific action on an existing node. This distinguishes it from sibling tools like create_instance or combine_components.

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

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

No guidance on when to use this tool versus alternatives such as create_instance or combine_components. Only an example is provided, but no context for selection 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?

With no annotations provided, the description fully discloses behavioral traits: it mutates the canvas, appends as last child of parent or page root, creates a linked instance so edits propagate, and explains optional parent effects (auto-layout vs root placement, potential overlap). Return format is also documented.

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 well-organized: succinct purpose, detailed behavior, usage conditions, return type, parameter details, skip cases, and examples. Every sentence contributes valuable information 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?

Given the tool's complexity (instance creation, linking, optional parent behavior), the description covers all necessary aspects: purpose, behavior, parameters, return value, and edge cases. The lack of an output schema is compensated by an explicit return format example.

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?

Both parameters have 100% schema coverage, but the description adds significant extra meaning: node must be a Component node (not Frame/Text/Instance), with a method to discover such nodes; parent is optional with behavioral consequences (auto-layout vs detached position, need for editing). This goes well 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 clearly states the verb ('Create') and resource ('instance of an existing component'), and explains the action (creates an InstanceNode linked to the component master). It distinguishes from sibling tools like clone_node and jsx by specifying when to use each.

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

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

Explicit 'Use when' and 'Skip when' sections provide clear context: when to use (spawning runtime copies, reusing design system components, programmatic instantiation) and when not to use (non-component nodes, building subtrees with jsx). Alternative tools are named (clone_node, jsx).

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

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

No annotations exist, so description carries full burden. It discloses creation in existing collection, no value set, and return format {data: {id}}. However, it omits error conditions, idempotency, or permission requirements, leaving some behavioral gaps.

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

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

Description is three sentences plus two examples, front-loaded with the main purpose. Every sentence adds value, no redundancy. Examples are compact and illustrative.

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 creation tool with three fully-described parameters, the description covers purpose, post-creation step, and return value. Lacks details on error handling or permissions, but is reasonably complete given the tool's simplicity and absence of 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 all three parameters documented. Description adds value beyond schema by explaining that slashes in name denote hierarchy in Figma UI and provides concrete examples with different types. This extra context pushes the score above 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?

Description clearly states 'Create a variable in an existing collection' with specific verb and resource. It further distinguishes from sibling 'set_variable_value' by noting that no value is set here, and provides examples demonstrating usage.

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?

Description explicitly says to use set_variable_value after creation, providing clear when-to-use guidance. It does not mention alternatives like ensure_variable, but the directive is sufficient for a well-scoped tool.

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

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

No annotations are provided, so the description bears full burden. It discloses default fill transparency, mutual exclusivity of points/data, and references to stroke/fill formats from other tools. However, it does not discuss side effects, authorization needs, or potential errors, which would enhance transparency.

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?

Very concise: purpose sentence, examples, path input details, stroke/fill, and when-not-to-use. Each section is useful and well-organized 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 tool with 13 parameters, no output schema, and no annotations, the description covers essential behavior: path input methods, defaults, stroke/fill format references, and usage guidance. Examples and prohibitions make it complete for an AI 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?

Schema description coverage is 100%, but the description adds significant value by explaining use cases, the two exclusive path input methods, default values, and stroke/fill formats with examples. It greatly enriches the schema information.

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

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

The description explicitly states 'Create a vector node from SVG path data or a list of points' and provides specific use cases like chart lines and custom shapes. It also distinguishes from sibling tools by listing when not to use (standard shapes use jsx, existing vectors use edit/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?

Clear when-to-use and when-not-to-use sections with explicit alternatives. Examples demonstrate typical usage, and the description explains the relationship between 'points' and 'data'. It provides practical guidance for an AI agent.

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

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

No annotations exist, so the description must fully disclose behavior. It only states the deletion, but does not mention permanence, side effects, permissions, or whether the operation is reversible. This is insufficient for a destructive tool.

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

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

The description is a single sentence with an example, which is efficient and front-loaded. However, it is perhaps too terse, but it 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?

Given no annotations and no output schema, the description fails to cover essential context such as return value, recursive behavior confirmation, or error conditions. It is not complete enough for a deletion 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 coverage is 100%, and the schema already describes the parameter as 'Node ID (e.g. "1:2").' The description adds no extra meaning beyond the schema, resulting in a 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 clearly states the action 'Delete a node and its children,' which is a specific verb and resource. This distinguishes it from sibling tools like clone_node or move_node.

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

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

The description provides no guidance on when to use this tool over alternatives, nor does it mention when not to use it. No context on prerequisites or constraints is given.

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

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

Despite no annotations, the description transparently discloses the tool's behavior: it validates and returns per-node data including issues with severity levels. It implies a read-only operation without side effects, though not explicitly stated.

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

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

The description is concise and well-structured: purpose sentence, bullet list of checks, parameter details, return description, and examples. No superfluous 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 tool with no output schema, the description adequately covers return values and includes examples. It could mention that the tool does not modify state, but overall it's complete for understanding usage.

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 adds little beyond schema defaults and examples. It restates the default depth value (3) and max (8), which is helpful but not substantial.

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 tool validates a design subtree with semantic description, role detection, and lint rules. It lists specific checks (layout conflicts, overflow, missing properties, structural issues), distinguishing it from sibling tools like inspect or find_nodes.

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

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

The description implies use for validation but does not explicitly state when to use this tool versus alternatives like inspect or discover_props. No exclusion criteria or usage 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 carry the full burden. It discloses that the tool discovers unique values and lists searchable properties, but it does not mention whether the operation is read-only, potential side effects, error scenarios, or performance 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 extremely concise: one sentence, one example, and a list of searchable properties. Every element is informative, and there is no wasted text. The structure is front-loaded with the purpose and then provides immediate practical 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?

Given the tool's simplicity (2 required parameters, no output schema), the description is quite complete. It explains the purpose, provides an example, and lists acceptable property names. However, it could mention the output format (e.g., an array of unique values) or behavior on missing nodes, though this is partially mitigated by the example.

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 both parameters (node and props) with clear descriptions. The description adds value by explicitly listing valid property names (e.g., fillColor, fontSize), which goes beyond the schema's generic 'Property name' and helps the agent select correct values.

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

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

The description clearly states the tool's purpose: 'Discover unique property values in a subtree.' It includes an example and lists searchable properties, making the action and resource unmistakable. The tool is distinct from siblings like 'list_component_props' which lists props rather than discovering values.

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

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

The description does not explicitly state when to use this tool versus alternatives or provide any contextual guidance. While the example suggests a typical use case, there is no explanation of prerequisites, when not to use it, or how it fits into a workflow.

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

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

Despite no annotations, the description discloses important behavioral traits: automatic resolution of component property display names, practical limits on batch size due to stream length, and the ability to mix component props with Figma props. It does not mention reversibility or undo, but covers the key aspects for an edit 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 well-structured with clear sections, bullet points, and a code example. Every sentence adds value, and the main purpose is front-loaded. It is appropriately sized for the tool's complexity.

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

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

Given the tool's complexity (4 parameters, nested objects, no output schema), the description covers all necessary aspects: single/batch modes, examples, node ID format, stream limits, and component prop resolution. It is complete enough for an agent to use correctly.

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

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

With 100% schema coverage, the description adds substantial nuance: explains node ID format, shows example usage, clarifies that props should be an object not stringified, and details the structure of the nodes array. This goes well beyond the schema's field descriptions.

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

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

The description clearly states 'Batch update properties on multiple nodes' and distinguishes itself from focused setters like set_text, set_fill, set_stroke, set_layout. It provides specific use cases and examples, making the purpose 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?

Explicitly instructs to 'prefer focused setters' for single-property changes and lists them, then defines when to use edit: 'batch fixes or properties not covered by setters'. This provides clear when-to-use and when-not-to-use guidance with named alternatives.

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

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

No annotations provided, but the description fully discloses idempotent behavior, return shape (including reused flag), canonical key computation, and rejection of placeholder strings. All critical behavioral traits are covered.

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

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

Concise and well-structured: starts with core concept, then conditions, return format, and an example. Every sentence adds necessary information 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?

Despite no annotations or output schema, the description covers all needed aspects: idempotency, parameter usage, return shape, and an example. An agent can confidently invoke this tool with the given information.

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%, baseline 3. Description adds value by explaining the idempotency_key's role and the 'canonical' computation, warning against manual SHA-256, and clarifying that the first mode becomes default. This goes beyond the schema descriptions.

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

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

The description clearly states it's for 'Idempotent VariableCollection creation' and distinguishes itself from the sibling 'create_collection' by explaining that it returns an existing collection instead of duplicating. The verb 'ensure' implies idempotency, and the description reinforces this.

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?

Explicitly advises 'Prefer this over create_collection' for idempotent creation, and provides guidance on when to omit or pass the idempotency_key. No ambiguity about use cases.

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 fully bears the burden of behavioral transparency. It explains idempotent behavior in detail (four bullet-pointed cases), return structure, and special handling of mode coverage and fallback scenarios. The description is comprehensive and leaves no ambiguity about the tool's behavior.

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

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

The description is relatively long but justified by the tool's complexity (7 parameters, nested objects, multiple behavioral cases). It is well-structured with clear sections and bullet points. Every sentence adds value, though some minor redundancy exists in repeating parameter details already in the schema. Overall, it strikes a good balance between completeness and conciseness.

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

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

Given the tool's complexity (7 parameters, nested objects, no output schema), the description provides complete coverage. It explains the return value structure, behavioral edge cases, and mode coverage policy in detail. The absence of annotations and output schema is fully compensated by the rich description, making the tool easy to use correctly.

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

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

The input schema has 100% description coverage, but the description adds significant value beyond the schema. It clarifies that values_by_mode keys can be mode names or modeIds, explains the type matching requirement, and provides examples of valid values. The description also expands on the mode_coverage_required and fallback_reason parameters with behavioral details not present in the schema.

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

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

The description clearly states it is for idempotent variable creation, specifying the action (create variable) and resource (variable), and explicitly distinguishes from the sibling tool create_variable by recommending 'Prefer this over create_variable'. The verb 'ensure' combined with the behavior description gives a specific, non-ambiguous 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 description explicitly recommends preferring this tool over create_variable, explains when to use idempotency_key (only for strict concurrency-safety), and details mode coverage policy with explicit conditions for 'all' versus 'opt-in-fallback'. It provides clear context for when to use and when not to use 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?

Discloses scoping constraint (current page) and default scope behavior, but no annotations exist to cover read-only or side effects. Does not state whether operation is safe or idempotent, 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?

Two succinct sentences plus two examples. No wasted words. Purpose and critical constraint front-loaded immediately.

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

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

Covers essential context: purpose, parameter defaults, page-scoping prerequisite. No output schema exists, so return format is not expected. Could mention case-sensitivity or partial matching, but overall adequate.

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?

Input schema already has full coverage (100%). Description adds value by clarifying scope default ('entire page') and providing a concrete node ID format example ('1:2'), which schema lacks.

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

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

Description clearly states 'Search nodes by name or type' with specific verb+resource. Examples reinforce purpose. Distinguishes from sibling tools by explicitly noting scoping to current page and referencing switch_page for cross-page searches.

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?

Explicitly tells agent to call switch_page if target is on a different page, providing clear when-to-use guidance. Examples show typical usage patterns.

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

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

Discloses scan scope (currentPage), behavior (invisible nodes skipped), and types of bindings returned. Lacks explicit read-only hint, but non-destructive nature is clear. No annotation contradiction.

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

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

Well-structured with clear sections, examples, and minimal redundancy. Every sentence adds value.

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

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

Complete for a single-parameter tool with no output schema; description explains return structure and path examples. No gaps.

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

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

Schema coverage is 100%, description adds example and source hint ('Get IDs from list_variables'), providing value beyond 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?

Clearly states it finds nodes referencing a variable, with a specific verb and resource. Differentiates from sibling 'inspect' by contrasting reverse behavior.

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?

Explicitly says when to use (renaming, auditing, swapping tokens) and contrasts with inspect. Also specifies scope and default skipping of invisible nodes.

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?

Notes return format (base64 PNG) and unsupported page root. No annotations provided, so description carries burden; it adequately discloses behavior without contradictions.

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?

Concise lead sentence, followed by usage guide, return info, parameter list, and examples. No redundant or unnecessary 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?

Covers purpose, when to use, parameters, and return format. With no output schema, it sufficiently describes output. Complete for a capture 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 coverage is 100%, but description adds examples, default value, and notes on padding (future use), providing significant added value beyond 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?

Clearly states it captures a PNG screenshot of a node, distinct from sibling tools that deal with properties, components, or other operations.

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

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

Provides explicit guidance to use after style changes for visual verification, implying alternative of reading properties. Does not name a specific sibling, but context is clear.

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

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

Discloses that calling with no selection returns nothing and wastes a turn, which is key for an AI agent. Also describes return content (names, types, IDs). No annotations exist to contradict. Could mention error cases or behavior on multiple selections, but overall 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?

Concise with clear front-loading: purpose, then usage guidance, then example. No superfluous sentences; every part adds value.

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

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

Despite no output schema, description explains return values. Covers when to use and when not. With zero parameters and clear purpose, the description provides complete context for an agent to decide and 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?

No parameters in schema, so baseline 4. Description adds no parameter info, which is acceptable as there are none to describe.

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 'Get the user's currently selected nodes in Figma', a specific verb and resource. It differentiates well from sibling tools by focusing on reading selection rather than modification or creation.

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?

Explicitly lists when to call (modifying existing elements, references to 'this', 'the selected', 'it') and when to skip (fresh design requests). Provides concrete examples of user intents and warns about burning iterations on empty canvases.

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 states the tool loads a guideline but does not disclose any behavioral traits (e.g., read-only, side effects, error behavior, or what happens if the name is invalid). The example suggests a return, but no details.

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

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

The description is two sentences plus an example, with no redundant information. It front-loads the purpose and immediately gives a concrete usage example.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is nearly complete. It covers purpose, parameter usage, and a use case. Missing a brief note on return value or outcome, but not critical.

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 a detailed description for the 'name' parameter. The description adds an example and categorization of guidelines, but does not significantly enhance the schema's clarity. 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 clearly states the verb (load) and resource (page-type design guideline) and gives concrete examples of guideline types (landing pages, dashboards, forms). It distinguishes itself from sibling tools, none of which load guidelines.

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 an example invocation, which implies usage, but does not explicitly state when to use this tool vs alternatives or when not to use it. No guidance on preconditions or 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?

With no annotations, the description carries full burden. It implies a read-only operation (loading help) but does not disclose any behavioral traits such as side effects, authentication needs, or rate limits. The basic purpose is clear but transparency is minimal.

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

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

The description is extremely concise: two sentences and an example. Every part is useful, and it is front-loaded with the core purpose. No wasted words.

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

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

For a simple one-parameter tool, the description is adequate. However, it does not mention what the tool returns (e.g., help text). Given no output schema, a hint about the return value would improve completeness. Still, it covers the essential usage.

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

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

While the input schema already describes the 'name' parameter well, the description adds value by specifying the kind of help content and providing a concrete example. This aids correct invocation beyond schema alone.

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

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

The description clearly states the tool loads 'narrow how-to / process help' and specifies the content types (tool usage rules, edge cases, naming conventions). It is specific and distinguishes from siblings implicitly as the only help 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?

No guidance on when to use this tool versus alternatives like 'describe' or 'inspect', nor any mention of situations where it should not be used. The description lacks usage context.

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

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

With no annotations provided, the description fully discloses behavior: it's a read-only operation that returns a skeleton or specified facets. It explains what each facet returns, parameter constraints (depth max 10), and default output. No destructive or side effects are implied, and the examples clarify usage.

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 well-organized: a one-sentence summary, default behavior, a bulleted list of facets with explanations, parameter descriptions, and a set of examples. Every sentence is informative and earns its place without redundancy or unnecessary detail.

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

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

Despite no output schema, the description explains return values in detail: skeleton fields and facet contents. It covers all 3 parameters with defaults and constraints. Examples illustrate various use cases. The tool's complexity is fully addressed without 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%, but the description adds significant value beyond the schema: it explains the node parameter format ('/' for root, node IDs), the meaning and grouping of facets (e.g., 'paint|fill' combined), and provides concrete examples that illustrate parameter combinations. The facets enum is elaborated with plain-English descriptions.

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

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

The description starts with 'Read design node(s)' — a specific verb and resource. It explains the facet system to control output granularity. The last line explicitly distinguishes from sibling tools like get_screenshot and describe, providing clear 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 details when to use the tool (reading node properties) and explicitly recommends alternatives: 'Use get_screenshot for visual verification. Use describe for lint/validation.' It also explains default behavior versus facet usage, guiding the agent on when to supply facets.

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 provided, so description carries full burden. Discloses atomic build behavior, replacement semantics (delete old node), supported/unsupported gradient patterns, effect merging, and self-closing rules. Missing details on error handling or auth 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?

Well-structured with front-loaded purpose, then examples, then detailed sections. Slightly verbose in listing all supported elements and attributes, but justified given the tool's complexity.

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

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

Covers purpose, parameters, syntax, behavioral nuances, and references sibling tools. Missing return value description and error handling, but overall comprehensive for a complex tool with no 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 coverage is 100%, but description adds significant value: explains mutual exclusivity of parent and replaceId, inherit behavior of insertIndex with replaceId, and provides extensive markup syntax examples, attribute lists, and special cases for gradients, effects, and variable binding.

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 tool creates design trees with nested JSX markup, building complete subtrees atomically. It distinguishes from sibling tools like edit and help by specifying that jsx is for tree creation, not property updates or grid layout queries.

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

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

Explicit guidance on when to use this tool (tree creation, replacement) versus alternatives (edit for property updates, help for grid layout, help for grid-layout). Includes examples and specific use cases like swap with replaceId.

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 provided; the description states it's a read operation (listing) but does not mention behavior for invalid nodes, permissions, or response format.

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?

Extremely concise with two sentences, including an example. No redundant information.

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

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

The description is sufficient for a simple read tool but could be improved by mentioning output format or error conditions given no 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 coverage is 100% and describes the parameter well. The description adds no extra semantic meaning beyond the example.

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 verb 'list' and identifies the resource as 'properties and variants of a component, component set, or instance', clearly distinguishing it from siblings like add_component_prop.

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 an example but lacks explicit guidance on when to use this tool versus alternatives such as discover_props or add_component_prop.

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 explains the return shape (variables[], collections[], nextCursor?), clarifies that collections only include referenced ones, and mentions pagination via cursor. This provides sufficient transparency for a read-only list 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 concise with no wasted words. It front-loads the purpose, then leverages bullet-style parameter explanations and examples, making it easy to scan. Every sentence adds value.

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

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

Given the tool has 4 optional parameters, no output schema, and no annotations, the description is complete. It covers the return shape, all parameters with additional context, pagination, and provides diverse examples. No gaps are apparent.

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 description adds meaningful details: 'case-insensitive' for filter, 'default 100' for limit, and 'opaque pagination cursor' for cursor. This goes beyond the schema descriptions, adding practical usage information.

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 'List variables as a flat array with referenced collections.' It identifies the specific verb (list) and resource (variables), and the mention of 'referenced collections' differentiates it from other variable-related tools like bind_variable or create_variable, 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 provides examples and parameter details, implying usage scenarios, but it does not explicitly state when to use this tool versus alternative listing methods (e.g., if there were a search_variables tool). No guidance on when not to use it or which situations are inappropriate is given.

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

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

With no annotations, the description discloses key behavioral traits: preservation of IDs, bound variables, and component instances. It does not detail failure modes or permissions, but covers essential identity-preserving behavior.

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

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

The description is concise, well-structured with a clear start, bullet-point use cases, and concrete examples. Every sentence adds value without redundancy.

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

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

The description covers purpose, usage, parameters, and behavior. However, without an output schema, it does not describe return values or error conditions, which slightly lowers completeness.

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 description adds significant value beyond schema descriptions through examples that show parameter combinations and index semantics (-1 for last). This helps the agent understand usage patterns.

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 tool relocates a node while preserving IDs, bound variables, and component instances, distinguishing it from clone_node or delete_node. Examples clarify specific use cases like reordering or changing parent.

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 explicitly lists three scenarios (changing child order, moving subtree, fixing placement) where the tool should be used. It does not mention when to use alternatives, but the context of sibling tools provides options.

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 explains the return value `{value: ''}` for missing keys and notes Figma's API never throws. It also clarifies the difference between private and shared data. No mention of auth or rate limits, but these are typical for the platform.

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

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

The description is concise and well-structured: purpose, use cases, parameter behavior, return value, and examples. Every sentence serves a clear 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?

Given no output schema, the description fully covers return value behavior and parameter semantics. Examples provide practical context. No obvious gaps are 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 coverage is 100%, so baseline is 3. Description adds value by explaining how to resolve node_id and how namespace controls private vs shared access. Examples further clarify parameter usage.

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 'Read plugin data (private or shared) from a Figma node' with specific verb and resource, and distinguishes itself from siblings like write_plugin_data. Provides explicit use cases such as i18n metadata and design-system tags.

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

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

The description explains when to use private vs shared plugin data via the namespace parameter. It includes examples but lacks explicit when-not-to-use guidance relative to sibling tools, though the context is clear.

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

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

No annotations exist, so description carries full burden. It discloses destructive nature (no preview/undo), exact-match behavior, no error on zero matches, and bypassing variable bindings.

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?

Description is lengthy but well-structured with sections, bullet points, and examples. Every sentence adds value; front-loaded 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?

Given no output schema, the description provides return format and match counts. It also suggests using discover_props for sanity checks, covering important context for a destructive batch 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 covers 100% of parameters, but description adds meaning: node recursion, exact-match string, typed props as strings, batch application of rules, and examples.

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

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

The description clearly states the tool performs bulk find-and-replace on property values across a subtree, with specifics on being destructive and batch. It distinguishes from siblings like set_fill, set_text, and edit.

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?

Explicitly provides when to use (theming, token migration) and when to skip (single node, variable-bound values, fuzzy match), with alternative tools named.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It explains persistence across turns, auto-merge behavior for backward-looking slots, deletion semantics, and the merged flag on writes. This leaves no ambiguity about tool behavior.

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

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

The description is well-structured with clear sections (Actions, Slots, Backward-looking slots, Required behavior, Examples) and front-loaded with the core purpose. While lengthy, every part serves a purpose given the tool's complexity. It could be slightly shorter but remains 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?

Given the tool's complexity (three actions, slot conventions, auto-merge, turn-cycle requirements, examples) and the absence of an output schema, the description covers all necessary behavioral aspects. It ensures an agent can correctly invoke the tool in any scenario, including edge cases like deletion and auto-merge.

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?

Although schema coverage is 100%, the description adds significant meaning beyond the schema: it defines the three actions with expected parameters, explains slot conventions (plan, decisions, etc.), details auto-merge mechanics, and provides examples. This greatly enriches semantic understanding.

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 tool's purpose: 'Read / write your own session scratchpad.' It differentiates from sibling tools by emphasizing its role as a persistent state carrier across turns. The three actions (read, write, list) are explicitly defined, making the purpose unmistakable.

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 explicit, actionable usage guidelines: first turn write decisions before jsx, subsequent turns read decisions and learnings before jsx, and every turn end write at least one backward-looking slot. It also explains when not to use (e.g., clearing slots before overwriting) and offers examples for correct invocation.

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 burden. It discloses accepted color formats (hex, gradients, variable tokens, transparent), explicitly rejects certain gradient patterns (e.g., 'circle at X% Y%'), and notes that 'transparent' is bg-only. This is highly transparent about tool behavior and limitations.

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 fairly long but well-structured with examples, bullet points, and clear sections. Every sentence adds value, and the format specifications are necessary given the complexity. Minor verbosity prevents a perfect score, but it remains readable.

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 thoroughly covers all parameters, usage modes, and format constraints. However, it does not mention return values or error cases (e.g., what happens with invalid input). Given the absence of an output schema, this is a minor gap, but the core functionality is well-explained.

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 description adds substantial meaning beyond the schema: it explains the semantic difference between fill and bg, provides concrete examples, details accepted formats, and describes the batch parameter structure. This significantly aids correct usage.

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 tool sets fill or background color on a node, with examples for single and batch modes. It distinguishes between fill (text/shape fill) and bg (frame background) and differentiates from sibling 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 description provides explicit alternatives ('For stroke color, use set_stroke') and includes example calls. It does not explicitly state when not to use the tool, but the examples and format restrictions serve as implicit guidance.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the operation is destructive (overwrites existing settings), what permissions are needed, or any side effects. Partial information is given for grid mode (children fill in insertion order), but overall insufficient.

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 moderately sized and front-loaded with examples followed by a clear summary. It is not overly verbose, though some examples could be trimmed without losing meaning.

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

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

Given the complexity (12 parameters, no output schema), the description covers main use cases with examples and grid-specific details. However, it lacks information on return values, error handling, or default behaviors, leaving gaps for an AI 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 baseline is 3. The description adds examples that illustrate parameter combinations but does not provide additional semantic meaning beyond what the schema already provides.

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

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

The description clearly states it sets auto-layout properties on a container and lists the controlled aspects (spacing, padding, direction, alignment). It distinguishes itself from sibling set_* tools by focusing on container layout.

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 examples for different layout modes and batch usage, but does not explicitly state when to use this tool versus alternatives or when not to use it. Usage context is implied but not clearly defined.

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

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

With no annotations, the description carries the full burden. It discloses behaviors like shorthand syntax, gradient/variable support, and the fact that the shorthand parser silently drops bare-name tokens. It does not mention mutation effects or permissions, but the level of detail is strong.

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 well-structured with a clear opening, examples, and syntax breakdown. It is slightly lengthy due to multiple examples, but every sentence adds value and it is front-loaded with 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?

Given the tool's complexity (6 parameters, no output schema), the description covers all parameters, provides extensive examples, and explains edge cases like gradients and variable binding. It is complete for the agent to use correctly.

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

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

Schema description coverage is 100%, baseline 3. The description adds significant value by explaining shorthand format, color format details, and batch structure beyond what the schema provides.

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

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

The description clearly states 'Set stroke (border) on a node' and provides multiple examples including batch usage, making the purpose unmistakable. It implicitly distinguishes from sibling tools like set_fill by focusing on stroke-specific 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 description offers explicit usage patterns (single, batch, shorthand) and explains accepted color formats. It does not explicitly state when to avoid this tool vs alternatives, but the examples provide clear context for appropriate use.

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 provided, so description carries full burden. It only states basic mutation without disclosing additional traits like whether text overwrites, permissions needed, or side effects.

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

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

Three short sentences: one statement, two examples, one usage guideline. No redundancy, 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?

Covers main use case and provides examples. Lacks return value info but no output schema; still adequate for agent use.

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

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

Schema coverage is 100%, but description adds value with examples showing usage of 'node'/'text' and 'nodes' array, clarifying batching behavior beyond 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?

Clearly states verb 'set' and resource 'text content on nodes', with examples. Explicitly distinguishes from sibling tool 'edit' for styling.

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?

Directly says 'Use this when changing what text says' and 'For text styling, use edit', providing explicit when-to-use and alternative.

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

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

No annotations are provided, so the description carries the full burden. It states the tool 'sets' a mode, implying mutation, but does not disclose any behavioral traits like reversibility, error conditions, or required permissions. For a mutation tool, this is insufficient.

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

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

The description is concise: two sentences plus two examples. It is front-loaded with the action and purpose, and every sentence earns its place without fluff.

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

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

The tool is simple with three required parameters and no output schema. The description explains the effect and provides examples, which is sufficient for most use cases. It does not mention return values, but for a setter, this is acceptable.

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 three parameters are described in the input schema (100% coverage), but the description adds value with concrete examples showing the format of node, collection, and mode IDs. This helps the agent understand the expected input beyond the schema's brief descriptions.

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

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

The description clearly states the tool sets a node to a specific mode of a variable collection, using the verb 'set' and specifying the resource. It provides a concrete example, distinguishing it from siblings like set_variable_value or bind_variable.

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

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

The description explains that the tool controls which variable values the node displays, providing clear context for when to use it. However, it lacks explicit guidance on when not to use it or alternatives, such as using bind_variable for binding variables.

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. It explains the thin wrapper nature, acceptable value types (raw values or alias objects), and hex color normalization. The 'Call once per mode' constraint is noted. This is good but could mention side effects or restrictions.

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

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

The description is concise, front-loading the purpose, then detailing behavior, and finally providing clear examples. Every sentence adds value with no filler.

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

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

The description covers the tool's behavior, parameter details, and constraints (call once per mode). No output schema exists, but for a setter tool, this is adequate. Could mention return value or errors.

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 baseline is 3. The description adds significant meaning beyond schema: it explains the value parameter can be a raw value or alias object, hex normalization, and provides examples. This extra context raises the 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 clearly states the tool's purpose: 'Set a variable's value for a specific mode.' The phrase 'Call once per mode' and the mention of being a thin wrapper over Figma's API help distinguish it from other variable-related tools (e.g., set_variable_mode, create_variable).

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 a single mode but does not explicitly compare with sibling tools like bind_variable or set_variable_mode. No direct guidance on when to use this tool versus alternatives is provided.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'load' without explaining side effects, state changes, permissions, or safety implications. The agent cannot tell if this is a read-only or mutating 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 two concise sentences plus an example, with no wasted words. The purpose is front-loaded, and the structure is clear and easy to parse.

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

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

The tool loads a skill but does not specify what happens afterward—whether it returns skill contents, executes actions, or modifies state. With no output schema and no annotations, this is a significant omission for a tool that likely has consequences.

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 a detailed description for the 'name' parameter (100% coverage). The tool description adds only an example ('restyle'), which is helpful but not essential. Baseline of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states that the tool loads a procedural skill consisting of a workflow, tool sequence, and anti-patterns. The verb 'load' is specific and distinguishes it from sibling tools that perform direct actions like 'set_fill' or 'create_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 explicitly advises using this tool 'FIRST' when adjusting an existing canvas or before creating a new design if a matching skill exists. This provides clear context for when to use it, though it does not name specific alternative tools.

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

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

With no annotations, the description carries the burden of disclosing behavioral traits. It explains the tool loads a style as inspiration, but does not clarify whether it mutates the current selection or just returns style information. The example suggests it applies the style, but the effect on the design state is not explicitly stated.

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

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

The description is concise with two sentences and an example. It is front-loaded, to the point, and every sentence adds relevant information 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 tool with one parameter and no output schema, the description covers purpose, usage, and provides an example. It is nearly complete, though it could explicitly state what the tool affects (e.g., current selection) for full clarity.

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 a clear description for the 'name' parameter. The description adds value beyond the schema by providing an example and explaining the inspiration philosophy, which aids correct usage.

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 tool loads a visual style preset for inspiration. It specifies the resource (visual style preset), the action (load as inspiration), and distinguishes from siblings by emphasizing it's a reference library, not a rigid constraint.

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 clear guidance on how to use the tool: pick wholesale, mix elements, or invent your own. It implies the tool is for inspiration rather than strict application, but does not explicitly mention when not to use it or name alternative tools for direct styling.

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?

While no annotations are present, the description discloses behavioral traits: each agent type has its own tools, iteration budget, and behavioral constraints, plus the spin-up cost. It doesn't detail return values or side effects, but the transparency is adequate for delegation 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 well-structured: a concise opening sentence, a bullet-like list of agent types, and a clear usage guideline. Each sentence serves a purpose 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?

The description covers purpose, agent types, and usage guidelines. It lacks explicit mention of return values or detailed constraints (iteration budget), but given the complexity and absence of output schema, it provides sufficient context for correct tool 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%, but the description adds value beyond the schema by explaining each agent type's purpose (create, audit, token) and implying the prompt should be specific about what to create/modify/audit. This adds meaningful context for parameter usage.

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 tool delegates a focused sub-task to a typed child agent, lists three agent types with specific purposes (create, audit, token), and explicitly differentiates from inline calls for 1-2 operations. This provides clear verb+resource and distinguishes it from siblings.

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

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

The description explicitly states when to use (3+ distinct regions or specialized behavior) and when not (1-2 tool-call operations finish faster). It provides clear context and exclusions, guiding the agent to choose appropriately.

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?

Despite no annotations, the description fully discloses behavior: ID-driven (names not addressable), two modes, return fields, side effects (switching page), and that most operations default to current page. No contradictions.

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

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

Well-structured with sections and bullet points, but slightly verbose. Front-loaded with key behaviors and modes, which is good. Could trim redundant phrasing.

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?

Complete despite no output schema: explains all return fields, two modes, typical flow, and operational context (default page scope). No gaps left for 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 covers the single parameter fully with description identical to the tool description. No additional parameter-level insight beyond schema, but the overall description provides context for parameter usage. Baseline 3 due to 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?

Clearly defines the tool as navigating between pages in a Figma file, with two distinct modes (roster-only vs switch). Distinguished from siblings by focusing on page-level navigation, which no other tool does.

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

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

Provides explicit when-to-call scenarios (user mentions different page, node on non-current page) and when not to call (current page, repetitive exploration). Includes a typical flow and caching advice.

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

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

No annotations provided, so full burden on description. Discloses mutation via setPluginData/setSharedPluginData and delete behavior. However, does not explicitly state overwrite behavior or potential errors (e.g., missing node). Adequate but leaves some gaps.

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

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

Very concise: two short paragraphs and two examples. Front-loaded with main action and key distinction. Every sentence adds value without redundancy.

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

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

No output schema, but tool is a write operation so return value likely minimal. Covers both modes and deletion. Could mention that node must exist or that data is overwritten, but overall sufficient for common use.

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

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

Input schema has 100% coverage for all 4 parameters. Description adds meaning: explains namespace optionality for shared vs private, and value empty string for deletion. Examples demonstrate correct usage and parameter combinations.

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

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

Description clearly states action: writing plugin data to a Figma node, distinguishes between private and shared based on namespace. Verb 'write' and resource 'plugin data' are specific. Sibling read_plugin_data implies this is the write counterpart.

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

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

Provides clear context on when to use namespace (shared data) vs omit (private data), and how to delete a key with empty string. Examples illustrate common usage. Could mention prerequisite that node_id must exist, but not required.

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