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

No annotations are provided, so the description must fully disclose behavioral traits. It mentions performance improvement but omits critical details like execution order (sequential), atomicity, error handling (partial failure or rollback), and response format. These gaps hinder an agent's ability to use the tool correctly.

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

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

The description consists of two concise sentences, front-loaded with the core purpose and a key benefit. Every word is informative, and there is no unnecessary 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 batch tool with a nested array parameter and no output schema, the description lacks completeness. It does not explain the params object format, error behavior, or what the tool returns. Additionally, it does not guide the agent on how to construct operations using sibling command names.

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

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

The schema coverage is 100%, and the schema includes a description for the 'operations' parameter. The tool description adds no extra meaning beyond the schema, merely restating the concept of executing multiple commands. Baseline 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 the tool executes multiple Figma commands in a single batch, improving performance for bulk operations. It uses a specific verb ('execute') and resource ('multiple Figma commands'), and distinguishes itself from sibling tools that perform individual commands.

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 indicates use for bulk operations (e.g., creating many icons or setting up variables) to improve performance. It implies this tool is preferable over individual calls for such tasks, but does not explicitly state when not to use it or provide alternative tools.

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

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

No annotations are provided, so the description must cover behavioral traits. It describes a mutation ('Bind ... connects') but does not disclose whether existing bindings are overwritten, permission requirements, or error behavior (e.g., invalid variableId). This is insufficient for a mutation tool.

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

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

The description is two sentences, direct and free of fluff. However, it could be slightly more efficient by merging the two sentences without losing meaning. Still, it is appropriately sized for a simple tool.

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

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

No output schema is present. The description explains the core function but omits behavioral details (e.g., effects of rebinding, role in theming system). For a simple 3-parameter tool, it is minimally complete but could be improved with more context on return values or side effects.

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

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

Schema coverage is 100% with clear descriptions for each parameter (nodeId, field, variableId). The description adds thematic context but does not materially extend parameter meaning beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states the action: 'Bind a Variable to a node property' and explains the purpose: 'connects component properties to the theming system'. This distinguishes it from siblings like set_component_property (direct property setting) and create_variable (creation without binding).

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 theming connections but provides no explicit guidance on when to use vs alternatives like set_component_property or create_variable. No when-not-to-use or exclusion criteria are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Clone an existing node' implies a mutating operation, but it does not clarify whether the original node is preserved, where the clone is inserted, how x and y affect positioning, or what side effects occur. This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence with no wasted words, and the key action is front-loaded. However, it is so brief that it sacrifices behavioral and contextual detail, making it concise but underinformative.

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

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

The tool has no annotations, no output schema, and a description that only states the basic action. It does not explain the resulting node's placement, relationship to the original, return value, or whether x and y are optional/required together. This is incomplete for an agent expected to invoke the tool correctly in a broader design workflow.

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

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

The input schema has 100% description coverage, so the schema already explains nodeId, x, and y. The description adds no extra parameter semantics beyond confirming the nodeId refers to an existing node. Baseline 3 is appropriate because the schema handles the burden.

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

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

The description states a specific verb ('Clone') and a clear resource ('an existing node in Figma'), which makes the core purpose understandable. It does not explicitly differentiate from siblings like create_rectangle or move_node, but the verb 'clone' semantically implies duplication of an existing node, distinguishing it from creation or transformation tools.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention when not to use it. An agent must infer from the name and description that this is for duplicating an existing node, and there is no comparison with sibling operations such as create_frame or create_component_instance.

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 adds value by stating that children and properties are preserved, which is key behavioral information beyond the schema. However, it does not disclose side effects (e.g., whether the original node is replaced) or any destructive aspects.

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

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

Two sentences, front-loaded with action and result, no unnecessary words. Every sentence serves a 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?

For a single-parameter tool with no output schema and no annotations, the description is fairly complete. It explains the operation and key behavior (preservation). A minor gap is no mention of return value or confirmation, but 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?

The schema already provides a description for the only parameter (nodeId). The tool description adds context about conversion and preservation, but does not offer new semantic meaning beyond what the schema covers.

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 'convert', the resource ('Frame or Group'), and the result ('Component'). It distinguishes from sibling tools like 'create_component' which creates from scratch, making its purpose specific and unambiguous.

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

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

The description indicates when to use the tool (for converting existing Frame or Group nodes) but does not explicitly state when not to use it or mention alternatives. However, given the sibling tool names, 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 are provided, so the description carries the full burden. It states creation of a boolean operation but does not disclose side effects (e.g., whether original nodes are preserved or replaced), required permissions, or whether the operation is destructive. This is insufficient for a creation tool that modifies existing nodes.

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

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

Two sentences, front-loaded with the core purpose and usage context. Every word earns its place; no fluff or repetition.

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

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

Given 3 parameters with full schema descriptions and no output schema, the description is minimal but covers the essential action. However, it omits details like whether nodes must be on the same layer, the resulting object type, or error conditions. For a tool combining multiple nodes, this leaves gaps for reliable agent 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% with clear parameter descriptions. The description adds no extra meaning beyond the schema, such as formatting constraints, order dependencies, or examples. Baseline of 3 is appropriate as 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 the verb 'Create' and the resource 'boolean operation' with explicit enumeration of operation types (union, subtract, intersect, exclude). It differentiates from sibling creation tools by specifying a unique functionality and mentions practical application ('complex icon shapes').

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 a usage hint ('useful for complex icon shapes') but lacks explicit guidance on when not to use it or alternatives. Among siblings, no other boolean operation tool exists, so implicit uniqueness helps, but no exclusions or context-driven selection cues are given.

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

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

No annotations are provided, so the description must cover behavioral traits. It fails to mention side effects (e.g., adding nodes to the document, permissions required, undo behavior). Only the basic creation action is 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, front-loading the core purpose and key distinction. 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?

Given the tool's complexity (18 parameters, no output schema, no annotations), the description is insufficient. It omits return value, error handling, default behaviors, and prerequisites.

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 50%, with many parameters lacking descriptions (e.g., padding, layoutSizing). The tool description does not add any meaning to these parameters; it only repeats the name convention for 'name'.

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 new Component (not an instance) in Figma, specifying it's for building a component library. This distinguishes it from sibling tools like create_component_instance.

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

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

The description implies usage for creating reusable components as a foundation, but it doesn't explicitly provide when to use this tool versus alternatives like convert_to_component or batch_create, nor gives exclusion criteria.

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

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

No annotations provided, so description carries the burden. Discloses performance trade-off (fast vs slower) and optional parent, but lacks information on error outcomes, prerequisites (e.g., file access), or side effects. Adequate but not comprehensive.

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

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

Two sentences: first states purpose, second provides usage guidance. No unnecessary words, front-loaded with key information. Every sentence earns its place.

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

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

Given 5 parameters and no output schema, the description covers core functionality and parameter distinctions well. However, it does not specify the return value (expected for a create tool) or error handling, but overall completeness is high for a tool with good schema descriptions.

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 with descriptions. The tool description adds value by explaining the practical difference between componentId and componentKey, which is not in the schema, and clarifies the optional parent's default behavior.

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

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

The description clearly states 'Create an instance of a component in Figma' with a specific verb and resource. It also distinguishes between local and library components via componentId and componentKey, differentiating from sibling tools like clone_node or convert_to_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?

Explicitly advises when to use componentId (fast local) vs componentKey (library imports), providing clear usage context. Does not mention when not to use the tool or alternatives, but the guidance is sufficient for most scenarios.

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

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

Without annotations, the description carries full burden. It only reveals the naming constraint but omits behavioral traits such as whether components are modified, error handling, or outcome of non-conforming names.

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

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

Two concise sentences, front-loaded with action and resource. Every sentence adds necessary context without superfluous 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 tool with no output schema and few parameters, the description covers the core action and a key constraint. However, it lacks behavioral details like reversibility, error cases, and what happens to original components, leaving gaps for an agent.

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

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

Schema coverage is 100%, providing a baseline of 3. The description adds value by specifying the variant-style naming requirement for components, which is not in the schema. This clarifies the 'componentIds' parameter usage beyond its schema description.

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

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

The description clearly states the tool combines multiple Component variants into a ComponentSet, with a specific verb and resource. It also provides a crucial constraint on naming convention, distinguishing it from generic creation tools.

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

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

No guidance is given on when to use this tool versus alternatives like create_component or convert_to_component. The description does not mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says connections are created with the default connector style; it does not state whether creation is additive, whether duplicates are allowed, how invalid node IDs are handled, or whether the default style can be overridden per connection. The optional text field in the schema hints at per-connection text, but runtime behavior is not disclosed.

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

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

The description is a single tightly worded sentence that front-loads the core action and adds the relevant style qualifier. It contains no filler, restates nothing from the schema, and 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 tool's simplicity and complete input schema, the description is serviceable for basic invocation. However, with no output schema and no annotations, it omits useful behavioral context such as the dependency on set_default_connector for style, behavior on invalid node references, and what the call returns. It is minimally adequate but not fully complete.

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

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

Schema description coverage is 100%, so the schema already documents startNodeId, endNodeId, and text clearly. The description adds little beyond confirming the semantic relation of 'nodes' to the IDs. This meets the baseline for schema-covered parameters but does not enhance parameter understanding further.

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

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

The description states a specific action ('Create'), a specific resource ('connections between nodes'), and a qualifier ('using the default connector style') that distinguishes it from related style-configuration tools like set_default_connector. It is unambiguous about what the tool does without restating the tool name.

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

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

No explicit guidance is given about when to use this tool versus alternatives or when not to use it. The phrase 'default connector style' implies a relationship with set_default_connector, but that relationship is never named or explained. The agent gets no help choosing between this and related connection/style tools.

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

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

No annotations provided, and the description only mentions creation without detailing behavioral traits like mutation side effects, required parent node, or whether width=height is enforced for circles. Minimal 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?

Extremely concise: one sentence for purpose and one for use cases. No wasted words, front-loaded with key 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?

No output schema, and the description does not mention return values or error handling. For a creation tool, agents benefit from knowing what is returned (e.g., node ID). Adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already documents parameters adequately. The description adds no additional semantic meaning 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 it creates an ellipse/circle and gives specific use cases (avatars, radio buttons, status indicators), distinguishing it from sibling tools like create_rectangle or create_line.

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

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

Provides contextual use cases but lacks explicit guidance on when not to use it or alternatives. No exclusion criteria or comparison with sibling tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the core creation action. It does not mention where the frame is created (e.g., current page vs. parentId), whether it becomes selected, what defaults apply, or any side effects on the document tree, which are important for a mutation tool with no safety hints.

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

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

The description is a single, front-loaded sentence with no redundancy. It is appropriately concise, though it could include a bit more context without becoming verbose.

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

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

Despite a detailed 20-parameter schema, the one-sentence description lacks high-level context such as where the frame is inserted, how it interacts with the current selection, and what the tool returns. With no output schema and no annotations, an agent needs more behavioral context to invoke this tool correctly, especially given the complex auto-layout parameters.

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

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

Schema description coverage is 100%, so all 20 parameters are fully documented in the schema. The tool description itself adds no parameter-specific information, but the high schema coverage means the baseline of 3 is appropriate.

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

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

The description states a clear action ('Create') and a specific resource ('a new frame in Figma'), which distinguishes it by resource from sibling creation tools like create_rectangle and create_text. It is not a tautology and conveys the object and environment, though it does not explicitly contrast with the conceptually similar create_section.

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

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

The description provides no guidance on when to use this tool over alternatives like create_section or create_rectangle. No context about scenarios, prerequisites, or exclusions is given, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations, the description carries full burden. It lists behaviors (inserts, flattens, resizes, sets fill, converts) but does not disclose potential side effects (e.g., destructive nature of flattening rate limits, or auth requirements). It provides basic but not comprehensive 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?

The description consists of two concise sentences. The first states purpose, the second lists actions. No redundant words, and key information is front-loaded.

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

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

The description covers input (SVG), actions, and output (returns component ID and key). However, it lacks details on default behaviors (e.g., what 'standard size' means) and does not mention any constraints or edge cases. For a tool with 7 parameters, more completeness would be beneficial.

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 description adds context for some parameters (e.g., 'resizes to standard size' for size, 'sets fill color' for fillColor) but does not significantly enhance understanding 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 creates an icon component from SVG content, listing specific steps (inserts SVG, flattens, resizes, sets fill, converts to component). This distinguishes it from siblings like 'insert_svg' (just inserts) and 'create_component' (generic).

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

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

The description implies usage when you have SVG content and want a component, but does not explicitly state when to use this tool over alternatives like 'insert_svg' or 'create_component'. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states 'Create a line in Figma' without mentioning side effects (e.g., node creation, mutation), required permissions, or return values.

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

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

The description is very short (two brief phrases), front-loading the action. It is concise but could include more detail without sacrificing brevity.

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 (8 parameters, no output schema, no annotations), the description is insufficient. It lacks essential context about required inputs, defaults, behavior, and what the tool returns.

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 only 25%, and the description adds no information about the 8 parameters, including their meanings, defaults, or relationships. Parameters like x, y, parentId, strokeColor, and strokeWeight are left unexplained.

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

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

The description clearly states 'Create a line in Figma', specifying the verb and resource. It adds context ('useful for dividers') but does not explicitly differentiate from sibling create tools beyond the shape type.

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 a use case ('useful for dividers') but offers no guidance on when to use this tool versus alternatives like create_rectangle or set_stroke_color, nor any exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only repeats the basic action. It does not mention default parenting behavior, coordinate system, units, selection handling, or side effects beyond the creation itself.

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

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

The description is a single sentence with no wasted words. It is front-loaded and immediately communicates the core action.

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

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

For a tool with 6 parameters, no output schema, and no annotations, this description is too minimal. It omits important context such as what happens when parentId is omitted, what coordinate space x/y refer to, and what the tool returns after creation.

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

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

The input schema provides descriptions for all 6 parameters, so the schema fully documents semantics. The description adds no additional parameter-level meaning, making the baseline score of 3 appropriate.

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

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

The description 'Create a new rectangle in Figma' states a specific verb and resource, clearly identifying the operation. It does not explicitly contrast with sibling creation tools like create_frame or create_text, but the resource type is unambiguous.

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

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

No usage guidance is provided. The description does not explain when to choose create_rectangle over alternatives such as create_frame or create_section, nor does it mention any preconditions or context in which this tool should be used.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a new element is created but does not mention side effects, whether the node is placed on the current page or requires a parentId, how naming works, or whether the operation is reversible.

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

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

The description is a single, front-loaded sentence with no redundant words. It is concise and easy to parse, though slightly underspecified for the number of optional parameters and the lack of added behavioral context.

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

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

Given 8 parameters, a nested fontColor object, no output schema, and no annotations, the one-sentence description is not complete enough. It does not explain how parentId affects placement, what the default behavior is, what the tool returns, or how the new text node relates to the current selection or page.

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

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

Schema description coverage is 100%, so every parameter already has a description in the schema. The tool description itself adds no parameter-level meaning, which is acceptable given the schema's coverage, but it does not go beyond the baseline.

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

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

The description clearly states the action ('Create') and the resource ('a new text element in Figma'). It is specific enough to distinguish from create_rectangle and create_frame, though it does not explicitly call out sibling differentiation.

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

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

There is no guidance about when to use this tool versus alternatives such as set_text_content, create_rectangle, or create_frame. The description provides no context about preconditions, suitable scenarios, or when another sibling tool would be more appropriate.

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

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

Description provides no behavioral traits beyond the basic action. It does not disclose permissions, reversibility, naming conflicts, or side effects. Since annotations are absent, the description carries full burden but falls short.

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

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

Single sentence, no wasted words. Information is front-loaded and precise.

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 3 required parameters and no output schema, the description is minimal. It does not explain the purpose of variables, return behavior, or integration into the variable system.

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% description coverage for all three parameters. Description adds no extra meaning beyond the schema, so baseline score applies.

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

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

Description clearly states the action (create), the resource (Variable), and the prerequisite context (existing Variable Collection). It effectively distinguishes from sibling tools like create_variable_collection and set_variable_value.

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, no prerequisites stated beyond the implied requirement of a collection ID, and no exclusions or conditions.

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

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

No annotations are provided, so the description bears full responsibility. It implies mutation (creation) but does not disclose potential side effects like overwriting existing collections or error conditions. This is adequate but lacks depth.

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, well-structured sentence that conveys purpose and usage without unnecessary words. Every part contributes 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?

The description lacks information about return values (e.g., collection ID) and scope (e.g., current file). Given no output schema, an agent might benefit from knowing what to expect after creation. However, for a simple creation tool, it is minimally sufficient.

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, baseline is 3. The description mentions 'modes' but adds no new details beyond the schema. It does not elaborate on name format or mode constraints, so it meets but does not exceed the baseline.

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

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

The description clearly states 'Create a new Variable Collection with modes' and provides concrete theming examples (Colors, Spacing, etc.), effectively distinguishing this tool from siblings like create_variable which create individual variables.

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 advises 'Use this to set up the theming system', giving clear use context. It does not explicitly mention when not to use or contrast with alternatives, but the context is sufficient for an agent to infer differentiation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is a deletion, which implies destructiveness, but it does not mention irreversibility, permission requirements, cascade effects on child nodes, or failure behavior when one node ID is invalid.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently communicates the tool's core purpose without unnecessary elaboration.

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

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

For a destructive batch operation with no annotations and no output schema, the description is too thin. An agent still lacks essential operational context such as whether the deletion is permanent, what happens if one node ID is invalid, and whether all deleted nodes must belong to the same document or page.

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

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

Schema description coverage is 100%, so the parameter nodeIds is already documented as an array of node IDs to delete. The description adds only the notion of batch processing ('multiple nodes...at once'), which adds minimal semantic value 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 'Delete' and the resource 'multiple nodes from Figma', and distinguishes this tool from its sibling delete_node by emphasizing batch deletion. This gives an agent a precise understanding of the tool's scope.

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

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

The phrase 'at once' implies this tool is for batch deletion rather than single-node deletion, but it does not explicitly state when to prefer it over delete_node or when not to use it. The usage context is implied, not spelled out.

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 bears the full burden of behavioral disclosure. It only states the basic delete action and omits critical traits such as irreversibility, whether child nodes are deleted, or any side effects. For a destructive operation, this is a significant transparency gap.

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

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

The description is a single, direct sentence with no filler words. It is front-loaded with the action and resource, but it is so minimal that it omits useful behavioral context; still, as far as structure and brevity, it is clean.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It fails to mention the irreversible nature of the operation, whether children are affected, or how this tool differs from 'delete_multiple_nodes'. An agent is left without key information for safe invocation.

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

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

Schema description coverage is 100% and the 'nodeId' parameter is clearly described as 'The ID of the node to delete'. The tool description does not add extra parameter semantics beyond the schema but does not need to, so the baseline 3 applies.

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

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

The description states a specific verb ('Delete'), a resource ('node'), and a context ('from Figma'), making the core action clear. It does not explicitly differentiate from the sibling tool 'delete_multiple_nodes', so the specificity is slightly incomplete, but the singular phrasing and tool name carry that distinction.

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

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

No guidance is provided about when to use this tool versus alternatives such as 'delete_multiple_nodes'. The description gives no context for choosing between single and batch deletion, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the tool name without adding behavioral context. It does not state whether the operation is read-only, what response format to expect, what limits exist, or how unsupported nodes are handled.

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

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

The description is one short, front-loaded sentence with no wasted words. It is easy to parse, though the brevity sacrifices useful behavioral context.

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

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

The tool has no annotations and no output schema, so the description is the only place to communicate return behavior, side effects, and constraints. It provides none of that, leaving an agent uncertain about what happens after invocation beyond the parameter contract.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters adequately. The description adds no additional meaning to nodeId, scale, or format beyond what the schema provides, which aligns with the baseline of 3.

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

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

The description states a specific verb ('Export'), resource ('a node'), and result ('as an image'), making the core purpose clear. It is distinct from sibling tools, though it does not explicitly differentiate itself from alternatives by name.

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

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

There is no guidance about when to use this tool versus siblings, no prerequisites, and no mention of exclusions or alternatives. Usage is only implied by the tool's purpose, not explained.

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

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

No annotations are provided, so the description carries full burden. It states the tool flattens a node into a single vector, implying a destructive merge, but does not disclose reversibility, resource effects, or required permissions. The description is too brief to ensure the agent understands the behavioral 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, consisting of two short sentences with no wasted words. It efficiently conveys the core purpose and a typical use case.

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), the description is adequate but not complete. It omits important behavioral details (e.g., whether the operation is reversible, what happens to child nodes) that would help an agent use it correctly.

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

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

Schema coverage for parameters is 100% (nodeId has a schema description). The tool description does not add extra meaning beyond the schema's 'Node ID to flatten'. Baseline 3 is appropriate since the schema already documents the parameter, but the combined information is minimal.

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

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

The description clearly states the action ('Flatten a node (or group) into a single vector'), which is a specific verb+resource. It distinguishes this tool from siblings like 'group_nodes' or 'convert_to_component' by using 'flatten', implying merging into a vector path. However, it could be more precise about what 'flatten' entails.

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 a use case ('cleaning up imported SVG icons'), which gives context. However, it lacks explicit guidance on when not to use this tool or alternatives, such as grouping vs flattening.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates a read operation but does not clarify how 'current document' works when nodeId is required, what happens when there are no annotations, whether permissions are needed, or what the response shape looks like.

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

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

The description is a single concise sentence with no filler or redundant phrasing. It loses a point because 'current document or specific node' is compact but ambiguous, especially in light of the required nodeId parameter.

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 and no annotations, the description is not complete enough for confident invocation. The unresolved 'current document' mode versus the required nodeId is a significant gap, and the description does not state the return behavior or any special values needed for document-level retrieval.

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

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

Schema description coverage is 100%, so the schema already documents nodeId and includeCategories. The description adds only the high-level notion of 'current document or specific node' and does not explain behave includeCategories affects the result beyond the schema's own wording.

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

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

The description uses a specific verb ('Get') and names the resource ('annotations'), with a clear read-vs-write contrast against siblings like set_annotation and set_multiple_annotations. However, the phrase 'current document or specific node' is ambiguous because nodeId is required in the schema, making the document-level mode unclear.

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

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

Usage is implied by the tool's read-only name and by the presence of set_annotation/set_multiple_annotations as siblings, so an agent can infer it is for reading annotations. But there is no explicit when-to-use guidance, no exclusions, and no mention of when to choose this over get_node_info or get_selection.

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

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

With no annotations, the description carries full burden. It discloses read-only behavior ('List', 'Shows') and what information is returned. It does not mention permissions or rate limits, but the scope is appropriate for a simple query tool.

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

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

Two sentences—front-loaded with action and resource, no redundancy, every phrase adds value.

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

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

For a parameterless tool with no output schema, the description fully covers what the tool does and what it returns. 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?

No parameters exist, so the baseline is 4. The schema coverage is 100% trivially, and description adds no parameter info needed.

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 'List' and the resource 'all Figma design files currently connected via the FigmaExporter plugin', and adds that it shows active file. This distinguishes it from siblings like get_document_info or set_active_file.

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

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

The description implies when to use (to see connected files), but does not explicitly state when not to use or compare with alternatives among many siblings. No exclusions or prerequisites noted.

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

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

No annotations are present, so the description must carry the burden of disclosing behavior. It only states 'get detailed information', which implies a read, but does not explain what details are returned, permissions needed, or any limitations. This is under-informative for an agent.

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

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

One concise, front-loaded sentence with no unnecessary words. Every word contributes to the purpose.

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

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

The tool is simple, but with no output schema or annotations, the description should clarify what 'detailed information' includes. The current text is vague and leaves the agent guessing about the response structure. It is minimally acceptable but not complete.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The description does not need to add parameter semantics, and the baseline of 4 applies.

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

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

Uses a specific verb ('get') and resource ('document') with scope ('current Figma document'). Clearly distinguishes from siblings like get_node_info and get_selection.

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?

Implies usage for document-level information through the description, but does not explicitly mention when to use it versus alternatives such as get_node_info or read_my_design. No exclusions or contextual guidance provided.

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

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

No annotations are provided, so the description carries the behavioral burden. It communicates that this is a retrieval operation and that the overrides are reusable, but it does not explicitly state read-only behavior, side effects, or what happens when no instance is selected—though the schema covers the selection fallback.

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

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

The description is two concise sentences with no filler. The primary action is front-loaded, and the second sentence provides valuable purpose context without unnecessary length.

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

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

For a tool with one optional parameter and no output schema, the description plus schema provides enough information to call it correctly: what it returns, where it gets data from, and how the result can be used. It does not detail the override data structure, but the stated purpose is sufficient for this simple tool.

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

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

The only parameter, nodeId, has 100% schema description coverage, including its optionality and fallback to the current selection. The description adds contextual meaning about how the overrides can be used, but does not need to repeat parameter-level details.

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

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

The description uses a specific action, 'Get all override properties', and identifies the exact resource, 'a selected component instance'. This clearly separates it from the sibling set_instance_overrides, which performs the inverse write operation.

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

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

The description explains that the retrieved overrides can be applied to other instances, giving a clear use case for the tool. It does not explicitly name alternatives or exclusion conditions, but the intent is clear enough for an agent to choose this over set_instance_overrides.

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 bears full responsibility for disclosing behavior. It states the scope ('local components' and 'from the Figma document') but does not describe return format, pagination, or what constitutes 'local' versus imported components.

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

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

The description is a single concise sentence with no irrelevant details, making it highly efficient.

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

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

For a zero-parameter getter with no output schema, the description is largely adequate, specifying the resource and scope. However, it omits any detail about the return value or whether components from all pages are included, though 'from the Figma document' implies full document scope.

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

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

The tool has zero parameters, so the input schema is empty. The description appropriately avoids parameter explanation; per the baseline for zero-parameter tools, a score of 4 is appropriate.

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

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

The description clearly states the tool retrieves all local components from the Figma document. The verb 'get' and specific resource 'local components' distinguish it from sibling tools like get_styles or get_document_info.

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

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

The description offers no guidance on when to use this tool versus alternatives like get_styles or create_component_instance. There is no mention of prerequisites, intended use cases, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It correctly indicates a read operation with no side effects, but it does not mention any constraints like scope (e.g., current file) or permissions. The transparency is adequate but not rich.

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

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

The description is two sentences with no wasted words. It efficiently communicates the purpose and utility, earning the maximum score.

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

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

Given the tool has no parameters, no output schema, and no annotations, the description is sufficiently complete. It tells what the tool does and why it is useful. An explicit mention that it retrieves collections in the current document could improve completeness, but the current description is nearly sufficient.

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 no parameters with 100% coverage. Since there are no parameters to explain, the description does not need to add parameter semantics. Baseline 4 is appropriate.

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

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

The description clearly states the verb ('Get'), the resource ('all local Variable Collections and their variables with values'), and the context ('inspecting the current variable/theming setup'). It effectively distinguishes this tool from sibling tools like create_variable or set_variable_value.

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

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

The description implies when to use the tool ('useful for inspecting'), which sets clear context. It does not explicitly mention when not to use it or name alternatives, but the sibling list and the read nature make the usage fairly obvious.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'get detailed information' without mentioning side effects (none expected), authorization needs, data volume, or performance implications. The complex options affecting output are not summarized.

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

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

The description is one sentence that front-loads the core purpose. It is concise and contains no redundant words. However, it could include more context without sacrificing 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 (multiple boolean options affecting output), no output schema, and lack of behavioral context, the description is insufficient. It does not explain what 'detailed information' includes, how options interact, or the nature of the response.

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

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

The input schema already provides descriptions for all parameters, including the nested options object. The tool description adds no extra meaning. Since schema_coverage is listed as 50% (though actual coverage appears higher), baseline is 3; the description does not compensate for any gaps.

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 ('get'), the resource ('detailed information about a specific node'), and the scope ('in Figma'). This distinguishes it from siblings like 'get_nodes_info' (for multiple nodes) and 'get_document_info' (for document-level info). It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, such as 'get_nodes_info' for multiple nodes or other tools for different operations. There is no mention of prerequisites (e.g., how to obtain a nodeId) or typical 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?

No annotations are provided, and the description does not disclose behavioral traits such as authentication needs, rate limits, side effects, or what 'detailed' entails. The agent lacks critical operational context.

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

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

The description is a single sentence with no wasted words. It is concise but could be more informative without losing brevity.

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 a nested options parameter and no output schema, the description is too minimal. It fails to explain what information is returned, how the options affect the result, or how it differs from similar tools. Incomplete for effective 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 description coverage is 50%, meaning half of parameters lack explanations in the schema. The tool description does not compensate by explaining parameters; it only restates 'multiple nodes'. The options object's sub-parameters are already described in the schema, but the description adds no value beyond what is structured.

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 gets 'detailed information about multiple nodes in Figma', specifying the verb 'Get', the resource 'nodes', and that it handles multiple nodes. This distinguishes it from sibling tools like get_node_info (singular) and other read tools.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., get_node_info for a single node), no prerequisites, and no exclusions. It only implies usage for multiple nodes without 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 the behavioral burden. It conveys a read-only getter and adds a valuable behavioral constraint (output must be transformed before use), but it does not disclose return format, error behavior, or permissions. Some behavior is disclosed, 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?

The description is two sentences, front-loaded with the core action and followed by a necessary cross-tool pipeline warning. No repeated schema content; the critical instruction earns its place despite its emphasis.

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

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

For a one-parameter tool, the definition is usable: it states what to do and what to do with the result. However, with no output schema and no annotations, the absence of any description of the returned reaction data leaves an agent dependent on the named strategy prompt for interpretation.

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 single nodeIds parameter is already documented as an array of node IDs. The description's 'from multiple nodes' reinforces the parameter but adds no new format or constraint details, so baseline 3 is appropriate.

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

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

The description names a specific resource ('Figma Prototyping Reactions') and the scope ('from multiple nodes'), which clearly distinguishes it from sibling getters like get_node_info or get_selection. The verb 'Get' plus the unique resource makes the tool's function immediately identifiable.

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 CRITICAL instruction explicitly states that the output must be processed by the reaction_to_connector_strategy prompt and passed to create_connections, giving an unambiguous downstream workflow. It does not name alternative tools or exclusion criteria, but none are needed for this niche getter, so the usage context is clear.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. 'Get information' implies read-only, but it doesn't specify the return format, behavior with an empty selection, or any other edge cases. This is minimal for a tool with no annotation support.

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

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

The description is a single well-structured sentence, front-loaded with the verb and subject, and contains no extraneous words. It is as concise as possible while conveying the core purpose.

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

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

The tool is simple, but the lack of output schema and the vagueness of 'information' leaves significant gaps. The description does not explain what the returned data looks like, how to handle an empty selection, or any prerequisites, making it incomplete for an agent to fully rely on.

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

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

The input schema has zero parameters, so schema coverage is effectively 100%. The description adds no parameter semantics, but with no parameters the baseline of 4 is appropriate; there is nothing to explain.

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

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

The description uses the specific verb 'Get' and the resource 'current selection' in Figma, clearly distinguishing it from sibling tools like set_selections (which sets selection) and get_node_info (which targets specific nodes). It is concise and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention exclusions or alternatives, leaving the agent to infer usage context from sibling names rather than explicit direction.

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 itself must convey behavior. It implies a read-only operation via 'Get', but it does not disclose what constitutes a 'style' (e.g., paint vs text styles) or any error conditions. This is minimal but not misleading.

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

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

The description is a single sentence with no filler, front-loading the action and resource. Every word earns its place, making it highly concise and well-structured.

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

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

While the tool is simple and the description captures the core action, it omits details about the output format or whether library styles are included. Given no output schema, a bit more context would improve completeness, but the low complexity prevents a lower score.

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 is empty, so there are no parameters to explain. The description correctly focuses on the tool's action, and with zero parameters, no further semantic detail is necessary.

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 'Get' and the resource 'all styles' scoped to 'the current Figma document', which distinguishes it from sibling tools that create, apply, or rename styles. There is no ambiguity about what the tool does.

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

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

The description provides no explicit guidance on when to choose this tool over alternatives like create_paint_style or apply_paint_style. The usage is implied by the name and semantics, but there is no mention of prerequisites or exclusions, so the agent must infer.

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, and the description provides no behavioral details such as whether grouping modifies the original nodes, creates a new parent node, or affects layout.

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

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

The description is a single, concise sentence with no unnecessary words. It is front-loaded and immediately understandable.

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

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

Given the lack of output schema and annotations, the description is too minimal. It does not explain return values, side effects, or how grouping interacts with other features, leaving significant gaps 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?

Schema coverage is 100% with descriptions for both parameters ('Group name', 'Node IDs to group'), which is adequate. The description adds no further context beyond what the schema already provides, so baseline score of 3 applies.

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

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

Description clearly states 'Group multiple nodes together' which indicates the verb 'group' and resource 'nodes'. However, it does not differentiate from similar sibling tools like 'create_component' or 'create_component_set', leaving ambiguity about whether this creates a group layer or something else.

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

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

No usage guidelines provided. The description does not specify when to use this tool over alternatives, nor does it mention any prerequisites or conditions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the SVG will be converted to Figma vector nodes, which is useful. However, it does not mention any side effects, authorization requirements, or constraints on SVG complexity, which would be valuable for an agent to know.

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

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

Two concise sentences with no wasted words. The description is front-loaded with the action and purpose, making it easy to parse quickly.

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

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

Given the tool has 6 parameters and no output schema, the description lacks context on how parameters like x, y, size, and parentId influence the insertion. For example, it doesn't mention that parentId determines where the SVG is placed or that size scales the SVG. This omission could lead to incorrect 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 description coverage is 100%, so the baseline is 3. The description adds no parameter-level information beyond what the schema already provides. It does contextualize the overall operation (conversion to vector nodes) but does not explain how parameters like 'size' or 'parentId' affect the result.

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 it inserts an SVG string into Figma and converts it to vector nodes. It's specific about the input (SVG markup) and the use case (creating icons). However, it doesn't explicitly differentiate from sibling tools like create_ellipse or create_frame, which would create shapes from parameters rather than SVG.

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 a usage hint ('Use this to create icons from SVG markup'), indicating when to use the tool. But it does not specify when not to use it or mention any alternative tools among the siblings, leaving the agent to infer without explicit guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the move action and does not explain whether the move is absolute or relative, what coordinate system is used, whether the node must already exist, how the move interacts with parent/child relationships, or whether the operation is reversible.

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

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

The description is a single, direct sentence with no filler or redundant detail, and the core action is front-loaded. It loses one point because the text is so minimal that it fails to include contextual guidance that would make the conciseness genuinely useful.

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

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

The tool is simple and all three required parameters are fully documented in the schema, so the one-line description is minimally viable. However, with no annotations, no output schema, and sibling tools that overlap semantically, the description is not complete enough: it leaves the meaning of 'position' ambiguous and gives no usage or side-effect 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 description coverage is 100%, and the schema already defines nodeId, x, and y with clear descriptions. The tool description adds no additional parameter meaning, but it does not need to compensate because the schema already provides the essential semantics. 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 uses a specific verb and resource — 'Move a node to a new position in Figma' — and the x/y parameters make it clear this is a coordinate move. It is not fully a 5 because 'new position' could be confused with moving a node in the hierarchy, especially given the sibling tool set_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?

There is no guidance on when to use this tool versus alternatives such as set_parent, resize_node, or clone_node. The description does not mention exclusions, prerequisites, or any decision context, so the agent gets no help selecting between overlapping siblings.

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

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

No annotations are provided, so the description must carry the full burden of behavioral transparency. The description does not disclose whether the tool is read-only, whether it has side effects, rate limits, or any other behavioral traits beyond the basic purpose.

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

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

The description is a single sentence, which is concise but insufficiently detailed for a tool with complex parameters. It sacrifices completeness for brevity.

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

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

There is no output schema and no description of the return value. The phrase 'including all node details' is vague. The description is inadequate given the complexity of the tool and the lack of supporting structured fields.

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 a nested 'options' object with many properties, but the description does not mention any parameters. Schema description coverage is 0%, so the description fails to add meaning or provide guidance on how to use the parameters.

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

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

The description clearly states it gets detailed information about the current selection in Figma, including all node details. However, it does not differentiate from sibling tools like 'get_selection', 'get_node_info', or 'get_nodes_info', which have similar 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 no guidance on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Resize a node in Figma' only implies mutation; it does not disclose whether the operation is reversible, how it interacts with auto-layout, constraints, or child nodes, or any side effects. For a mutating tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single front-loaded sentence with zero filler: 'Resize a node in Figma' conveys the purpose immediately. It earns its place, though the terseness borders on under-specification rather than deliberate brevity backed by richer content elsewhere.

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

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

With no annotations and no output schema, the one-sentence description must carry all context, but it omits what the tool returns, whether changes are undoable, and how resizing affects constraints or auto-layout parents. An agent calling this tool would have to guess at side effects and expected confirmation behavior, which is inadequate even for a simple 3-parameter mutation.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters with clear descriptions ('New width', 'New height', 'The ID of the node to resize'). The description adds no additional parameter meaning beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description states a specific verb (resize) and resource (a node in Figma), making the core action unambiguous. It distinguishes from sibling tools because move_node, rename_node, delete_node, and clone_node each carry different verbs, so there is no overlap in what this tool does. It stops short of a 5 because it adds no scope detail (e.g., which node types are resizable) or explicit differentiation language.

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

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

The description gives no guidance on when to use this tool versus alternatives such as move_node, set_layout_sizing, or set_layout_mode. There are no conditions, exclusions, or references to siblings, leaving the agent to infer appropriateness entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the scan is recursive or direct-child-only, what happens when no matches are found, whether node types are case-sensitive, or what the response contains. 'Scan' suggests searching, but the exact behavior is left ambiguous.

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

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

The description is a single concise sentence that communicates the core function without filler. The word 'selected' is slightly ambiguous because the actual parameter is nodeId, but the overall structure is efficient.

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

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

With no annotations and no output schema, the description leaves out important operational details such as traversal depth, return format, matching behavior, and whether 'selected' refers to the current selection or the provided nodeId. An agent could call it, but may misinterpret scope or results.

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

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

Schema coverage is 100%; both nodeId and types already have descriptions in the schema. The tool description adds only the context of scanning child nodes and does not expand on allowed type values, format, or edge cases, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Scan for child nodes'), a specific resource ('selected Figma node'), and a specific filter ('specific types'). It is clear enough to distinguish from general node-read tools like get_node_info, though it does not explicitly differentiate itself from scan_text_nodes.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention scan_text_nodes or any other sibling, nor does it state conditions, trade-offs, or exclusions. The usage context is only implicit.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It implies a read-only scan but does not explain whether the scan recurses through all descendants, what data is returned, or how results are formatted. 'Scan' alone is too vague for an agent to predict behavior reliably.

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

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

The description is a single front-loaded sentence with no filler. It conveys the essential action and object efficiently, though it could include more behavioral detail without becoming bloated.

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

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

Given there is no output schema and no annotations, the description should explain what the tool returns or how the scan behaves. It does not mention return values, traversal depth, or any side effects, leaving significant ambiguity for a tool that an agent needs 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%, with nodeId described as 'ID of the node to scan.' The description adds only the phrase 'selected Figma node,' which maps loosely to the parameter but provides no extra semantic value. Baseline 3 is appropriate since the schema already documents the parameter.

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

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

The description states a specific verb ('scan') and a clear resource ('all text nodes in the selected Figma node'), so an agent can understand the core function. It does not explicitly differentiate from the sibling scan_nodes_by_types, but the focus on text nodes makes the purpose reasonably distinct.

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

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

No guidance is provided about when to use this tool instead of alternatives like scan_nodes_by_types or get_node_info. The context of when this tool is appropriate is left entirely to inference.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It only states what the tool does (switch active file), but omits details like whether it affects UI selection, what happens on multiple matches, or any destructive potential. 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 two sentences long, front-loaded with the core purpose, and contains no extraneous information. Every word is necessary.

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 (1 parameter, no output schema), the description is mostly adequate but lacks behavioral details such as error handling or response behavior. It is minimally complete but has clear gaps.

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

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

The description adds no additional meaning beyond the schema's parameter description. Since schema coverage is 100%, the baseline is 3. The description merely restates 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 'Switch' and the resource 'active file', making the tool's purpose obvious. However, it does not explicitly differentiate from siblings like set_focus, so it is not a perfect 5.

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

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

The description provides basic usage instructions (pass a keyword) but offers no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. There is no mention of 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?

With no annotations at all, the description carries the full burden. It discloses that the tool mutates state (create/update) but does not reveal idempotency behavior, whether annotationId is required for updates, what happens if the nodeId does not exist, or whether categoryId is mandatory. The double-action nature also leaves ambiguity about whether an update without annotationId silently creates a duplicate.

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

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

The description is a single, short sentence with no filler. It front-loads the essential verb and resource. Given the schema carries the parameter details, this level of conciseness is appropriate.

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, no annotations, and a mutation tool with create/update dual semantics. The description does not explain update rules (e.g., what happens when annotationId is omitted for an existing node), merge behavior, or required preconditions like node existence. For a tool with 5 params and two possible operations, this level of context is insufficient.

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 parameters are already documented. The description does not add semantics beyond the schema, but the schema descriptions are clear enough. The phrase 'create or update' does imply annotationId is relevant for update, slightly reinforcing the schema, but no extra semantics are added. 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 'Create or update an annotation' clearly states the verb and resource: it both creates and updates an annotation, which is a specific, common Figma-like operation. It distinguishes itself from siblings like get_annotations (read) and set_multiple_annotations (bulk variant) by explicit create/update semantics, though it does not name those siblings.

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

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

The description implies usage: use when you need to create a new annotation or update an existing one, as indicated by 'Create or update'. There are no explicit exclusions, alternatives, or when-to-use versus set_multiple_annotations guidance, but the context is fairly clear given the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly indicates a mutation ('Set'), but it does not mention whether the frame must already be an auto-layout frame, what happens if it is not, whether existing alignment values are overwritten, or whether there are side effects. This is a minimal description for a write operation.

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

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

The description is a single, front-loaded sentence with no redundant words. It names the action, the object, and the target frame type in an efficient, scannable way.

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 plus a fully self-documenting schema is enough to identify the core operation and parameters. However, there are no annotations, no output schema, and no guidance about preconditions, failure behavior, or what alignment defaults will be used when optional parameters are omitted. It is minimally viable but leaves meaningful gaps.

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

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

Schema description coverage is 100%, and the parameter descriptions are already detailed, including enums and the SPACE_BETWEEN behavior note. The tool description itself adds no extra parameter meaning, so the baseline 3 applies.

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

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

The description uses a specific verb ('Set'), a clear resource ('primary and counter axis alignment'), and specifies the target ('auto-layout frame'). It is immediately distinguishable from siblings like set_item_spacing or set_layout_mode, which address different layout 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 phrase 'for an auto-layout frame' implies the tool is meant for use on frames that have auto-layout enabled, but it does not explicitly state when to choose this tool over related siblings such as set_layout_mode or set_item_spacing. No alternatives or exclusions are mentioned, so usage is inferred rather than explicitly guided.

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 reveals specific behaviors for INSTANCE_SWAP (key vs node ID, linking child instance). It does not disclose mutation consequences or auth requirements but goes beyond the schema.

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

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

Two sentences with no redundant words. The first sentence covers the broad use, the second adds critical detail for a special case. Extremely 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 all 5 parameters implicitly or explicitly, addressing the special INSTANCE_SWAP case. Missing details on default behavior for other types and what happens if property already exists, but given no output schema and high schema coverage, this is reasonably complete.

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

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

Schema description coverage is 100%, baseline is 3. The description adds nuance beyond the schema, such as clarifying that defaultValue for INSTANCE_SWAP is a component key and that targetChildId sets mainComponent automatically.

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 ('Add') and the resource ('Component Property') along with the specific types (Boolean, Text, Instance Swap, Variant). It distinguishes from sibling tools like set_component_property_references by focusing on adding a property rather than referencing.

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 for INSTANCE_SWAP type, specifying that defaultValue must be a key and targetChildId is required. However, it does not mention when not to use the tool or compare with alternatives for other property types.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether references are overwritten, what happens if the component property does not exist, or any side effects. The description only states the action and allowed keys, omitting key behavioral traits like destructiveness or reversibility.

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 composed of two efficient sentences: the first states the action, the second explains the purpose and lists keys. There is no extraneous information, and the critical details are front-loaded, making it easy to parse.

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

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

While the schema covers parameters well, there is no output schema and the description does not explain return values or error conditions. For a tool that modifies references, behavior on failure or when references already exist is missing. The description is adequate but not fully complete for an agent to use without further inference.

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

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

Schema coverage is 100%, and the description adds value by explicitly listing the allowed keys ('visible', 'characters', 'mainComponent'), which reinforces the schema's example. This helps the agent understand the exact mapping without ambiguity, exceeding the baseline score of 3.

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

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

The description clearly states the tool sets component property references on a sublayer, linking a child node's property to an existing component property. It specifies the allowed keys ('visible', 'characters', 'mainComponent'), making the purpose specific and distinct from sibling tools like set_component_property or set_instance_overrides.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., set_component_property, set_instance_overrides). There is no mention of prerequisites, exclusions, or typical use cases, leaving the agent to infer context from the purpose alone.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral expectations. 'Set the corner radius' conveys a basic mutation, but it does not mention that the change is persistent, whether unsupported node types will error, how the optional corners parameter interacts with the radius, or whether existing radius values are overwritten. For a mutation tool with no annotation coverage, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to identifying the tool's action and target. The under-specification of behavioral details is a completeness issue, not a conciseness issue.

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

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

For a simple three-parameter tool with complete schema coverage, the core invocation details are present. However, with no annotations and no output schema, the description leaves important context unstated: how to obtain a valid nodeId, whether all nodes support corner radius, and what happens when corners is omitted. This is adequate but not robust.

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

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

Schema description coverage is 100%, so the schema fully documents nodeId, radius, and the optional corners array. The description adds no parameter-specific meaning beyond echoing the general concept of corner radius. This is the expected baseline when the schema already handles parameter documentation.

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

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

The description clearly states a specific verb ('Set') and resource ('corner radius of a node in Figma'). This meaningfully distinguishes it from sibling tools like set_fill_color, resize_node, or set_padding. Even without a title, the purpose is immediately unambiguous.

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

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

The intended use case is implied by the tool name and description: use it when you need to change a node's corner radius. However, there is no explicit guidance about when not to use it, what node types support corner radius, or how it relates to alternative tools such as resize_node or set_padding. It meets the threshold for implied usage but provides no explicit routing or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation but does not mention that this is a mutation, whether it affects the underlying design, any required permissions, side effects, or failure conditions. The word 'set' implies state change but provides no transparency beyond that.

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

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

The description is a single, front-loaded sentence with no filler or redundant details. Every word earns its place, and the key constraint ('copied') is included without bloating the text.

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

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

For a one-parameter setter with no output schema and no annotations, this is minimally adequate: the agent knows what to do and which parameter to provide. However, it lacks behavioral context such as side effects, when the node is considered 'copied', and what being 'default' entails, leaving meaningful gaps for correct invocation and expectation-setting.

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 clear description for connectorId, and coverage is 100%, so the baseline is 3. The tool description adds the important constraint that the connectorId must refer to a copied connector node, which goes beyond the schema's generic 'connector node' description.

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

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

The description clearly states the action ('set'), the resource ('connector node'), and the desired outcome ('as the default connector'). It is specific enough to distinguish this tool from most siblings, though it does not explicitly contrast it with any alternative or define what 'default connector' means in this context.

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

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

The phrase 'copied connector node' implies that the tool should be used after copying a connector node, giving some usage context. However, there is no explicit guidance about when to prefer this tool over alternatives, nor any exclusions or workflow 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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states 'Set effects' but does not clarify whether this replaces existing effects entirely, merges with them, or requires certain permissions. The behavioral implications (e.g., overwriting vs. appending) are not addressed.

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

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

The description is a single concise sentence that conveys the core functionality. It is front-loaded and efficient, but could be slightly more informative without becoming verbose.

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

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

Given the tool's moderate complexity (2 required params, no output schema), the description is minimally viable. It lacks details on whether effects are replaced or merged, how to remove effects, or what happens if invalid parameters are provided. The return value is also unexplained.

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 coverage is 100%, so the schema fully documents both parameters. The description enumerates effect types, but the schema's enum for the 'type' field already lists exactly those values. Thus, the description adds minimal additional meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Set effects on a node' and lists the specific effect types (drop shadow, inner shadow, layer blur, background blur). This differentiates it from sibling tools like set_fill_color or set_stroke_color, which modify other visual 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 implies when to use this tool (when setting effects), but provides no explicit guidance on when not to use it or how it compares to other set tools that might affect appearance (e.g., set_opacity, set_fill_color). No alternatives or exclusions are mentioned.

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

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

Annotations are absent, so the description carries the full behavioral burden. It adds the supported node types, but does not disclose whether existing fills are replaced, what happens for unsupported node types, or how the optional alpha parameter behaves. 'Set' implies mutation, but deeper behavioral context is missing.

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

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

The description is short and front-loaded with the action and target, avoiding unnecessary detail. However, the grammar is slightly awkward in the trailing clause, which prevents a higher score.

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

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

For a simple setter with fully documented parameters and no output schema, the description is mostly adequate. It is missing edge-case behavior details, especially around the optional alpha parameter and unsupported node types, but remains functional for basic invocation.

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

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

Schema description coverage is 100%, with clear parameter descriptions, ranges, and required flags. The tool description adds no additional parameter-level meaning, so the baseline 3 is appropriate.

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

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

The description states a concrete action ('Set') and target ('fill color of a node'), and adds supported node types (TextNode or FrameNode). This is clear enough to distinguish it from stroke-related or image-fill siblings, though it does not explicitly name alternatives.

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

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

No when-to-use or when-not-to-use guidance is provided. It does not mention alternatives such as set_stroke_color or set_image_fill, leaving an agent to infer appropriate usage from the tool name and schema alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly mentions both side effects—selecting the node and scrolling the viewport—which is strong transparency for this type of tool. It does not discuss error cases or whether document state changes, but the main observable behavior is disclosed.

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

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

The description is a single front-loaded sentence with no filler. It states the operation, the target, and the mechanism in an efficient and scannable way.

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

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

For a simple, one-parameter tool with no output schema, the description provides sufficient context: what action is performed and what visible effects occur. It does not mention return behavior or failure handling, but for a focus/selection action this is a minor gap rather than a critical omission.

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

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

Schema description coverage is 100%, and the nodeId parameter is already described as 'The ID of the node to focus on.' The tool description does not add additional parameter meaning, format details, or constraints, so it stays at the baseline for fully schema-documented parameters.

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

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

The description clearly states a specific action—set focus on a node—and adds concrete behavioral detail: selecting the node and scrolling the viewport to it. This distinguishes it from related selection tools, though it does not explicitly reference any sibling tool by name.

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

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

There is no guidance about when to use this tool instead of alternatives such as set_selections or move_node. The description implies a use case, but it does not state prerequisites, exclusions, or conditions that would route an agent to a different 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly reveals the main mutating effect: target instances will be swapped to the source component and all copied override properties will be applied. It does not discuss reversibility, errors, or permissions, but the core behavioral transformation is clearly stated, which is strong for a tool with no annotation support.

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

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

The description is two concise sentences with no filler. The main action is front-loaded in the first sentence, and the second sentence adds the essential behavioral detail. Every word contributes to the agent's understanding.

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

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

For a tool with two required parameters, no annotations, and no output schema, the description covers the action, the target selection context, and the resulting transformation. It could mention prerequisites more explicitly or describe failure behavior, but the essential information needed to invoke the tool correctly is present.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The tool description adds minimal parameter-level meaning beyond restating that target instances are involved; it does not clarify the relationship between sourceInstanceId and targetNodeIds beyond what the schema already provides. Thus the baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Apply previously copied overrides to selected component instances') and then states the concrete outcome: target instances are swapped to the source component and all copied overrides are applied. This clearly distinguishes it from the sibling get_instance_overrides, which reads rather than applies.

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

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

The phrase 'previously copied overrides' and 'selected component instances' conveys the intended workflow context, making it clear the tool is used after copying overrides and on a current selection. It does not explicitly state when not to use it or name alternatives like get_instance_overrides, but the context is sufficient for an agent to infer the correct situation.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states the basic mutation ('Set distance') and does not describe failure modes for non-auto-layout frames, side effects, or behavioral caveats like itemSpacing being ignored under certain alignment settings.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to identifying the operation's target and scope.

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

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

The schema covers parameter semantics well, and the description names the target context, but with no annotations and no output schema, an agent still lacks guidance on alternatives and behavior beyond the basic mutation. It is adequate but not fully complete.

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

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

Schema description coverage is 100%, and each parameter already has meaningful descriptions, including caveats for itemSpacing and counterAxisSpacing. The tool description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Set') and identifies the exact resource ('distance between children in an auto-layout frame'). This clearly differentiates it from related siblings like set_padding and set_axis_align, even though no sibling is named explicitly.

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

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

The description gives a clear applicable context: it only applies to auto-layout frames, which tells an agent when the tool is relevant. However, it does not explicitly mention alternatives or exclude cases such as fixed-layout frames.

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

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

No annotations are provided, so the description must disclose side effects and constraints on its own. It only says 'set', with no mention that this mutates design state, that layoutWrap may only apply when layoutMode is not NONE, or any other behavioral consequences. For a mutation tool, this is a significant transparency gap.

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

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

The description is a single sentence with no filler or repetition. It front-loads the action and resource, making it easy to scan and understand quickly.

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

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

The description plus the fully covered schema give an agent enough basics to invoke the tool, but there are no behavioral notes, no usage context, and no output expectations. Since it is a simple three-parameter mutation, this is minimally viable but still leaves selection ambiguity among similar sibling tools.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds no meaning beyond restating that layout mode and wrap behavior are affected. Baseline 3 is appropriate because the schema carries the burden, and the description neither adds nor conflicts with parameter details.

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

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

The description names a specific verb ('Set'), a resource ('a frame in Figma'), and the affected properties ('layout mode and wrap behavior'). It is clear enough to identify the tool's core function, but it does not distinguish itself from sibling layout-related tools like set_axis_align or set_layout_sizing.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites such as the frame needing to be an auto-layout frame, and no exclusions. The only usage signal is implied by the verb and resource, which is not enough for an agent to reliably choose between this and similar layout 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 provided, the description carries the full burden of behavioral disclosure. It states the action but does not explain side effects, requirements (e.g., node must already be an auto-layout frame), or consequences of changing sizing modes. This leaves the agent without important behavioral context for a mutation operation.

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

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

The description is a single, clear, front-loaded sentence with no redundant words. It efficiently communicates the core purpose without unnecessary elaboration.

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 setter with a fully documented schema, the description plus schema is mostly adequate. However, the lack of usage guidance and behavioral caveats means the agent may not know when to prefer this tool or what assumptions to make about the target node, leaving minor but notable 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%, so the schema already documents each parameter and its enum meanings. The description adds the high-level context of setting sizing modes but does not add meaning beyond the schema descriptions for the individual parameters.

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

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

The description uses a specific verb ('Set') and resource ('horizontal and vertical sizing modes for an auto-layout frame in Figma'), making the tool's function immediately clear. It also distinguishes itself from siblings like set_layout_mode, which focuses on layout mode rather than sizing modes.

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

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

The description implies the tool is for auto-layout frames, giving some context for when to use it. However, it does not explicitly state when to use this tool over alternatives such as set_layout_mode or resize_node, nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Set' implies mutation, but the description does not state whether existing annotations are replaced, whether updates require annotationId, how partial failures are handled, or any other side effects.

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

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

The description is a single short sentence with no filler words, making it easy to parse. It is concise rather than bloated, though it sacrifices useful detail for brevity.

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 involves a nested annotations array with optional categorization and update IDs, yet the description only says to set multiple annotations. There is no guidance on how updating existing annotations works, what 'in a node' means relative to the nested nodeId, or what happens after the operation. With no output schema and no annotations, this is insufficient for reliable invocation.

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

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

The input schema provides thorough descriptions for the top-level parameters and most nested fields, so the description adds little beyond schema. A baseline of 3 is appropriate since the schema does the heavy lifting; the description does not clarify ambiguous points like how categoryId/annotationId relate to creating versus updating.

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

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

The description states a clear verb and resource: 'Set multiple annotations' in a node, which conveys a batch mutation operation. It is implicitly distinct from the singular sibling tool set_annotation, though it does not explicitly name the alternative.

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

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

No explicit guidance is provided about when to use this tool versus set_annotation, get_annotations, or other annotation-related tools. The word 'multiple' implies batch usage, but there is no stated condition, exclusion, or alternative recommendation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only reveals that the operation sets multiple text contents 'parallelly', but does not state whether existing text is replaced, whether the node must contain text nodes, or whether the operation is atomic.

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

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

The description is a single sentence with no filler and the action verb is front-loaded. However, 'parallelly' is an awkward modifier and 'text contents' is imprecise, so it is concise but not maximally polished.

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

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

For a mutation tool with no annotations and no output schema, the description is thin. It omits how this tool relates to set_text_content, what 'parallelly' means in terms of execution, and any side effects or prerequisites, though the schema covers the parameter mechanics.

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 little beyond the schema: 'parallelly' and 'in a node' hint at the relationship between the parent node and the array, but the schema already documents both parameters and their roles.

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

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

The description uses a specific verb ('Set') and resource ('multiple text contents') and scopes the operation to 'a node'. The word 'multiple' differentiates it from the sibling set_text_content, though 'parallelly' is vague and 'text contents' is slightly ambiguous.

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

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

No explicit when-to-use guidance or alternatives are stated. The term 'multiple' implies this is the batch counterpart to set_text_content, but the description never clarifies when to choose this over the singular tool or what types of nodes are valid.

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 only states 'rename' without disclosing side effects, permissions, reversibility, or any constraints. This is insufficient for safe agent invocation.

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

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

The description is a single sentence that efficiently conveys the core purpose with no redundant or irrelevant content. It is well front-loaded and concise.

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

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

Given the simplicity of the operation (renaming a node) and full schema coverage, the description is minimally adequate. However, it lacks context about Figma-specific behavior such as impact on references or constraints, which would be useful.

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 (nodeId, name) have schema descriptions ('Node ID', 'New name') achieving 100% coverage. The tool description adds no extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description 'Rename a node in Figma' clearly states the action (rename) and the resource (node). It distinguishes itself from sibling tools, none of which directly rename a node, 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?

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The agent has no context to decide between this and other mutation tools.

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

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

No annotations exist, so the description carries full responsibility. It mentions the opacity range but does not disclose side effects (e.g., whether the change persists, triggers re-render, or what happens on invalid nodeId). It is minimally 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 extremely concise with a single front-loaded sentence that efficiently conveys the essential information without 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 setter with no output schema and good parameter descriptions, the description is adequate but lacks context about side effects, permissions, or relationship to sibling tools. It is not fully complete given the complexity of the environment.

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

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

Schema description coverage is 100% and both parameters are well-documented. The description does not add meaning beyond the schema (the range is already in the schema). Baseline 3 applies.

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

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

The description clearly states the action 'Set' and the resource 'opacity of a node' along with the valid range (0 to 1). It is specific and differentiates from sibling tools like 'set_visibility'.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, scenarios, or related tools among the many sibling 'set_' functions.

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

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

There are no annotations, so the description carries the full behavioral burden. It only states that padding values are set, but does not disclose whether unspecified padding values are preserved or reset, whether the frame must already have auto-layout enabled, or what happens if the node is not a valid auto-layout frame.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. It has no wasted words, though it is somewhat minimal and leaves out behavioral 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 there are no annotations or output schema, the description should provide more behavioral context for this mutating tool. It does not explain partial-update behavior, constraints on the target frame, or error conditions, so an agent lacks important information for correct invocation.

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

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

The input schema covers all parameters with descriptions, giving a baseline of 3. The description adds no extra meaning beyond the schema, but it does not need to since the schema already defines nodeId and each padding side clearly.

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

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

The description uses a specific verb ('Set'), a clear resource ('padding values'), and a precise scope ('auto-layout frame in Figma'). It is easy to distinguish from sibling tools like set_item_spacing or set_layout_mode because padding is uniquely identified.

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

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

The description implies the tool is for auto-layout frames, giving some context, but it does not explicitly say when to choose this tool over alternatives or when not to use it. There is no mention of related tools for spacing or layout adjustments.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the core side effect (selecting nodes) and the viewport scrolling behavior, which is exactly the kind of non-obvious effect an agent needs to know. It does not mention whether the prior selection is replaced, but that is strongly implied.

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

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

A single sentence that front-loads the primary action and immediately adds the important viewport behavior. Every word earns its place and there is no filler.

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

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

For a tool with one fully documented parameter and no output schema, the description is complete. An agent knows what it does, what side effects occur, and what input is required. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%: nodeIds is fully described as 'Array of node IDs to select'. The description does not add extra parameter-level detail, but it does not need to because the schema already documents the only parameter sufficiently.

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

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

States a specific action ('Set selection') on a specific resource ('multiple nodes in Figma') and adds the scroll-viewport effect. This clearly distinguishes it from the sibling get_selection and other node-scoped tools without needing to open the schema.

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

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

The description makes it clear the tool is used when the agent wants to select multiple nodes and bring them into view. It does not explicitly name alternatives or conditions when not to use it, but the use case is unambiguous among the sibling tools.

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

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

With no annotations and no output schema, the description carries the full burden of behavioral disclosure. It only states that the stroke color is set, without explaining whether the stroke already must exist, whether multiple strokes are affected, whether the change replaces or adds to the existing style, or what happens on invalid input. Basic mutation is conveyed, but no meaningful behavioral depth is added.

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

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

The description is a single, tightly written sentence with no filler or repetition. It is front-loaded with the core action and resource, making it easy for an agent to scan and understand quickly.

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

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

For a mutation tool with six parameters, no annotations, and no output schema, the description is too thin. It does not mention what the tool returns, whether it requires a selected node, how the optional weight parameter interacts with the stroke, or any failure modes. The schema covers the parameters, but the surrounding context needed for safe invocation is largely absent.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description adds no extra parameter-level meaning beyond 'stroke color', which is sufficient given the schema's thorough per-property descriptions. The baseline score of 3 applies.

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

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

The description uses a specific verb and resource: 'Set the stroke color of a node in Figma'. This clearly distinguishes it from sibling tools like set_fill_color and set_corner_radius. The intent is immediately understandable and unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives such as set_fill_color, nor any mention of prerequisites like having a selected node or an existing stroke. The purpose implies usage in a basic way, but the description provides no explicit context or exclusions.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It states the action ('set text content') but does not disclose that existing text will be overwritten, possible error cases for invalid node IDs, permissions, or any side effects. The description mostly restates what the tool name already conveys.

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

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

The description is a single, front-loaded sentence with no filler. It states the action, target, and context efficiently.Purpose and scope are clear without any wasted words.

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