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

With no annotations provided, the description carries the full burden. It discloses important behavioral details: x/y default to parent-relative, positionMode 'frame' converts absolute canvas coordinates to parent local space, and the response returns both parent-relative and absolute bounding box positions. This goes beyond a simple tautological description, though it does not mention potential side effects (e.g., whether the clone is selected).

Agents need to know what a tool does to the 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 and front-loaded with the core action. It explains the default behavior and the alternative mode in a clear, efficient manner without wasted words. Every sentence adds value.

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

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

The tool has no output schema, but the description states what the response returns (parent-relative position and absolute bounding box), partially filling that gap. It explains the coordinate systems and positionMode, covering the main behavioral complexity. It does not discuss error cases or prerequisites (e.g., existence of the node), but the description is otherwise complete for a moderate-complexity clone operation.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds context about the coordinate interpretation (parent-relative vs. frame) but this is largely redundant with the parameter descriptions. No new syntax or format details beyond the schema are provided.

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 'Clone an existing node in Figma' — a specific verb and resource. It also distinguishes itself from sibling creation tools (create_rectangle, create_frame, etc.) by focusing on cloning an existing node, making its 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 implies usage when you want to clone a node and explains coordinate behavior, but it does not explicitly compare with alternatives or state when not to use this tool. There are no exclusions or 'instead of' guidance, so 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?

There are no annotations, so the description carries the full burden of disclosing side effects. It only says 'Create an instance' and does not mention whether a new node is returned, what happens if neither componentId nor componentKey is supplied, where the instance is placed when parentId is omitted, or whether the operation modifies the current file permanently.

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

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

Two sentences with no filler: the first states the action and resource, the second gives the critical parameter disambiguation. It is front-loaded and 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?

The parameter semantics are well-covered by the schema and the local/library distinction is useful. However, with no annotations and no output schema, the description omits what the tool returns and what happens in edge cases (missing both IDs, both IDs provided, no parentId), so an agent may lack enough context to handle non-happy paths.

Complex tools with many parameters or behaviors need more documentation. 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. The description reinforces the componentId vs componentKey distinction, but that information is also present in the schema, so it adds no truly new semantic value.

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

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

The description states a specific verb and resource ('Create an instance of a component in Figma') and immediately differentiates the two component sources (local vs published library). This clearly separates it from sibling creation tools like create_frame or create_rectangle.

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

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

It gives concrete selection guidance: use componentId with id for local components and componentKey with publishedKey for published library components. It does not explicitly name alternative tools or describe when not to use this tool, but the local-vs-library context is clear enough for an agent to proceed.

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?

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 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?

With no annotations, the description carries the behavioral transparency burden. It discloses that Inter is the default font family and implies that relying on defaults may not match design-system layers. This is useful for the agent to anticipate the tool's behavior. However, it does not mention the return value (e.g., the created node's ID) or any side effects beyond creating a node. Still, the default font and override guidance add meaningful 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 only two sentences: the first states the core function, the second offers a focused tip. There is no redundant wording or restating of schema details. Every sentence 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?

Given the tool's complexity (15 parameters) and lack of an output schema, the description is reasonably complete. It clearly states the action and provides a real-world workflow tip. It does not explain return values or interaction with parentId, but these are less central for a create operation. The detailed schema and the practical example compensate for missing context, though a brief note on what the tool returns would enhance completeness.

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

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

The schema already covers 100% of parameters with detailed descriptions, so the baseline is 3. The description adds value by identifying a specific subset of parameters (fontFamily, fontStyle, textAlignHorizontal, width, lineHeight) and explaining their combined purpose when matching a design-system layer. This strategic guidance helps the agent decide which parameters to set, going beyond the schema's individual property 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 opens with 'Create a new text element in Figma,' using a specific verb and resource that clearly identifies the tool's function. It distinguishes itself from sibling tools like create_rectangle and set_text_content by focusing on text creation rather than other shapes or updates. The additional guidance about matching a design-system layer further clarifies its intended use.

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

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

The description provides clear contextual guidance: when the goal is to match an existing design-system layer, set specific properties (fontFamily, fontStyle, textAlignHorizontal, width, lineHeight) rather than relying on Inter defaults. However, it does not explicitly state when to use this tool over alternatives like set_text_content, nor does it mention exclusions or prerequisites. This is strong context but lacks explicit alternative comparison.

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 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but the description does not state whether there are side effects, authentication requirements, or any details about what 'detailed information' includes or how it is returned.

Agents need to know what a tool does to the 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. It front-loads the action and resource clearly, earning its place without redundancy.

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

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

For a parameterless tool, the description is minimally adequate, but it leaves the agent without a clear sense of what 'detailed information' means or what the output will contain. With no output schema and no annotations, more specificity about the returned content would make it 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 the schema already fully covers this dimension. The description adds no parameter semantics, but none are needed for a parameterless tool; the baseline 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 verb 'get' and the resource 'current Figma document,' which identifies the tool's function. However, 'detailed information' is vague and does not specify what is included, and it doesn't explicitly distinguish itself from sibling tools like get_node_info or read_my_design.

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 get_selection, get_node_info, or read_my_design. The description gives a general purpose but no context, exclusions, or selection criteria, leaving the agent to infer usage.

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

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

The description transparently discloses that the tool is a stub, that the parameter is ignored, and that no plugin-based equivalent exists. This goes far beyond the annotations (readOnlyHint, openWorldHint) by explaining the underlying reason and expected behavior, which is crucial for an agent to avoid invoking it expecting results.

Agents need to know what a tool does to the 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, immediately starts with 'Stub', and packs essential information without any fluff. Every word contributes value, 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?

For a stub tool with one parameter, no output schema, and read-only annotations, the description is fully complete. It covers the tool's unavailability, the cause, and the consequence, leaving no ambiguity about what to expect.

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

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

Although the schema description already covers the 'ignored' nature of fileKey at 100% coverage, the tool description adds rationale by explaining that the REST API is disabled. This gives the agent a deeper understanding of why the parameter is ignored, slightly elevating it above the schema-only 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 explicitly states that this is a stub for reading Figma comments and that the REST API is disabled, making it clear the tool does not actually retrieve comments. It identifies the resource (Figma comments) and the tool's non-functional role, distinguishing it from working siblings like 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 implies that the tool should not be used for actually getting comments because the required REST API is disabled, but it does not explicitly say 'when to use' or suggest alternatives like using the REST API outside this build. The guidance is clear enough to avoid false expectations, but no direct comparison to sibling tools is provided.

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

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

No annotations are provided, so the description carries the 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?

No annotations are provided, so the description carries the full burden. It clearly signals a read-only list operation via 'Get,' but it does not define what qualifies as 'local,' whether nested/variant components are included, or what the returned component data contains.

Agents need to know what a tool does to the 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. Every word adds value, and the key scoping terms 'local' and 'Figma document' are included.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, the description is mostly sufficient to invoke the tool correctly. However, with no annotations and no output schema, the agent is left to infer the exact return structure and the precise boundary of 'local components.'

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

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

The tool has zero parameters, so there is no schema to elaborate on and no parameter meaning to clarify. Baseline 4 applies because no input documentation is 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 states a specific verb and resource: 'Get all local components' scoped to 'the Figma document.' It is clear and distinguishable from siblings like get_selection, get_styles, or get_node_info, though it does not explicitly name an alternative.

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

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

There is no explicit guidance about when to use this tool instead of related tools like scan_nodes_by_types or get_styles. The term 'local' implies it excludes library/team components, but this distinction is 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?

No annotations are provided, so the description carries the full disclosure burden. It only says 'get detailed information'; it does not disclose what fields or depth of data are returned, whether authentication/access is required, or how invalid node IDs are handled. The verb 'get' implies read-only, but no additional behavioral detail is given.

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

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

A single, front-loaded sentence with no filler. Every word contributes to stating the action and the target resource.

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

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

For a one-parameter read tool, the description is minimally sufficient to make a call, but it does not specify what 'detailed information' contains and does not route the agent away from get_nodes_info. With no output schema and no annotations, that leaves a real gap in selecting and interpreting the call.

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

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

The input schema already documents nodeId with 100% coverage, so the baseline is 3. The description adds 'specific node' but no extra meaning about the ID format, nesting, or addressability of nodes.

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 and resource: get detailed information about a specific node in Figma. It is not as strong as it could be because it does not explicitly contrast itself with the plural sibling get_nodes_info or with get_document_info, leaving the distinction to inference.

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

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

There is no guidance about when to choose this tool over get_nodes_info, get_selection, or get_document_info, and no mention of prerequisites or cases where it should not be used. The intended usage is only implicit in the verb 'get'.

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 implies a read-only operation but does not reveal what 'detailed information' contains, whether there are limits on the number of node IDs, how errors are handled, or what the response format looks like. This is a minimal, somewhat tautological statement.

Agents need to know what a tool does to the 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 redundant filler. It is front-loaded with the core action and resource. While it could include more useful detail, it does not waste words, so conciseness is good.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, the description should clarify what information is returned for the requested nodes, but it does not. It also omits any mention of limits, error behavior, or relationship to sibling tools. For a tool with one parameter, the definition is underspecified and leaves important operational context unknown.

Complex tools with many parameters or behaviors need more documentation. 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 complete coverage (100%) for the single parameter, and the description adds no additional semantic detail beyond what the schema already says. The baseline of 3 applies because the schema documents the parameter adequately.

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 ('Get') and resource ('detailed information about multiple nodes in Figma'), which distinguishes it from singular sibling get_node_info by indicating multiplicity. However, 'detailed information' is vague about what exactly is returned, and it does not explicitly reference or contrast with similar 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 about when to use this tool versus siblings like get_node_info, get_selection, or get_document_info. The description does not mention any conditions, exclusions, or alternatives, leaving the agent to infer usage solely from the tool name and parameter.

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 provided, the description must carry the behavioral disclosure burden. It signals a read operation through 'Get information' but does not disclose return fields, side-effect freedom, or any prerequisites like needing an open document. This is minimal extra value beyond the tool's name.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to stating the tool's 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?

This is a simple zero-parameter getter, so the description is nearly sufficient. However, with no output schema present, the vague term 'information' leaves the agent guessing about the return shape, such as whether it returns node IDs, types, or 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?

There are zero parameters and schema coverage is effectively complete, so the description has nothing to add. The baseline of 4 applies because no parameter semantics are 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 states a clear verb ('Get') and resource ('current selection in Figma'), making the tool's basic purpose understandable. It is distinct from siblings such as set_selections, get_node_info, and get_document_info, though it does not enumerate exactly what information is returned.

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 or alternative tool guidance is provided. The name and sibling list imply it is for reading the active selection rather than mutating it with set_selections or querying a specific node with get_node_info, but this is left to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get', implying a read operation, but does not clarify what kinds of styles are included (fill, text, effect, grid), whether library styles are returned, or what the response contains. This is minimal behavioral detail.

Agents need to know what a tool does to the 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 earns its place, and the verb-resource-scope structure makes 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?

For a simple zero-parameter getter, the description is largely sufficient: an agent knows what action to take and what resource to expect. The main gap is the ambiguous scope of 'styles', which could be interpreted in multiple ways, but the overall call is straightforward.

Complex tools with many parameters or behaviors need more documentation. 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 schema requires no documentation. The baseline of 4 applies because there are no parameter semantics to clarify; the description does not need to add parameter-level meaning.

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

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

The description uses a specific verb ('Get'), a clear resource ('all styles'), and a scope ('current Figma document'). It is immediately distinguishable from sibling tools like get_local_components or get_document_info, which target different resources.

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 get_local_components or get_document_info. The phrase 'from the current Figma document' gives some context, but no explicit conditions, exclusions, or alternative-tool routing are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the server auto-joins the default channel on startup and that this tool is only a fallback. This is valuable context, though it doesn't mention edge cases like invalid channel names or side effects on the current channel.

Agents need to know what a tool does to the 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. It leads with the purpose ('Optional: switch...'), then adds conditional usage context. Every word earns its place, with no redundancy or filler.

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

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

For a simple tool with one optional parameter and no output schema, the description provides complete context: what it does, why it exists, and when to use it. The auto-join behavior and recovery scenario fully explain the tool's niche, leaving no major 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 schema covers 100% of the parameter, so the baseline is 3. The description adds some context (default channel name and recovery use case) but does not add new parameter-specific semantics beyond what the schema already states ('The name of the channel to join').

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 ('switch') and resource ('Figma communication channel'), clearly distinguishing it from all sibling tools. It also clarifies the tool's role relative to the default channel, leaving no ambiguity about what it does.

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

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

Explicit guidance is given: the tool is optional, only needed for non-default channels or recovery after connection issues. It also explains the auto-join behavior, so the agent knows when to invoke it and when to avoid it. No alternatives are mentioned, but no real alternatives exist among 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?

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?

It openly discloses that this is a stub and that the message parameter is ignored, adding context beyond the neutral annotations. It does not specify the exact runtime behavior (e.g., whether it throws an error or silently does nothing), but the stub nature is clearly communicated.

Agents need to know what a tool does to the 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, front-loaded with 'Stub' to immediately signal unsupported status. It efficiently conveys the limitation without unnecessary 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 stub tool, the description is complete: it explains why the tool exists, the external dependency, and that no plugin equivalent is possible. No output schema is needed, and the minimal schema aligns with the stub nature.

Complex tools with many parameters or behaviors need more documentation. 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 full coverage for the single parameter 'message' with an explanatory description that it is ignored. The tool description does not add additional parameter detail, so a baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as a stub for posting Figma comments, explicitly stating that the REST API is disabled and there is no plugin-based equivalent. It distinguishes itself from get_figma_comments by indicating that posting is unsupported while getting may be available.

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 states that posting comments requires the REST API which is disabled, making it clear that this tool should not be relied upon for creating comments. It explains that there is no plugin-based alternative, giving users context to avoid this tool, though it does not explicitly name an alternative within the plugin.

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

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

Since 'Get' indicates a read-only operation, the basic behavior is clear, and there is no annotation contradiction. But with no annotations and no output schema, the description does not disclose edge cases such as behavior with an empty selection, whether children are included, or what 'all node details' concretely covers.

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

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

A single front-loaded sentence communicates the tool's purpose without wasted words. 'Including all node details' is slightly redundant with 'detailed information,' but the overall structure is clean and immediately actionable.

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

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

For a zero-parameter tool, the description is adequate for a basic invocation and clearly identifies the subject as the current selection. However, it leaves sibling-tool differentiation unaddressed and does not describe the return shape or selection edge cases, so it is 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?

The tool has zero parameters and an empty input schema, so the description cannot add parameter-level meaning. A baseline of 4 is appropriate because parameter semantics are irrelevant here.

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

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

The description clearly identifies the action ('Get') and the resource ('current selection in Figma'), with 'including all node details' signaling a comprehensive read. It does not explicitly distinguish itself from similar sibling tools like get_selection or get_node_info, so it falls short of a 5.

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

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

The description implies the tool should be used when an agent needs detailed information about the current selection. However, it provides no explicit guidance about when to prefer this over get_selection, get_node_info, or get_nodes_info, and it names no alternatives 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 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 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?

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?

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.

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

Given the low complexity (2 simple parameters, full schema coverage, no output schema), the description is mostly sufficient for an agent to invoke the tool correctly. It clearly targets existing text nodes. However, a brief note about overwriting the existing text or batch alternatives would round out the context.

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

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

Schema coverage is 100%, so the schema already documents both parameters and their meanings. The description adds minimal semantic value beyond reinforcing that the node must already exist and be a text node. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Set'), a precise resource ('text content of an existing text node'), and the domain ('in Figma'). The word 'existing' distinguishes this from create_text, and the singular 'a text node' contrasts with set_multiple_text_contents.

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 modifying one existing text node, but it does not explicitly explain when to prefer this over siblings like set_multiple_text_contents or create_text. There is no when/when-not guidance, only a contextual cue via 'existing'.

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