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

With no annotations, the description carries the full behavioral burden. It usefully discloses the type-to-node binding semantics (TEXT controls characters, BOOLEAN visibility, INSTANCE_SWAP the main component of a nested instance), which is real behavioral context, but says nothing about side effects, whether adding a duplicate property name errors, permission requirements, or what the response 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?

Two dense sentences with zero filler; the core operation is front-loaded and the type-specific binding rules follow immediately. Every clause carries information an agent needs.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral context. It explains the operation and the meaning of the optional binding well, but omits error conditions, return shape, and prerequisites for a five-parameter mutation tool.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema, and the enum on 'type' is captured there. The description reinforces the type/target pairing semantics but adds no syntax or format detail beyond what the schema already states, so 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?

States a specific verb and resource ('Add a component property') and immediately constrains the domain: only TEXT, BOOLEAN or INSTANCE_SWAP on a COMPONENT or COMPONENT_SET. No sibling tool performs this operation, so the agent can identify it unambiguously from the name plus first sentence.

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 optional child-node linkage is described ('Optionally link it to a child node'), which implies the main use case, but there is no explicit when-to-use vs alternatives, no prerequisite such as the target must be a component rather than an instance, and no note on when to omit targetNodeId.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the append-vs-replace behavior ("Appends to existing reactions unless replace is true") and structural preconditions for destinations. It omits error behavior, permission needs, and what the tool returns, so it is not exhaustive.

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?

Purpose is front-loaded in the first clause, followed by tightly packed conditional rules, each earning its place. No filler sentences, no redundancy despite the density.

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 complex 10-parameter tool with a nested transition object and no output schema or annotations, the description covers the key calling constraints (action preconditions, directional transitions, append behavior). Remaining gaps are error/return behavior, which is a minor omission for an interaction-adder.

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, but the description adds genuine cross-parameter semantics the schema cannot: which actions require destinationId, that directional transitions require a direction, and the timeout-for-AFTER_TIMEOUT relationship. It adds relational meaning beyond per-field docs.

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+resource ("Add a prototype interaction (trigger + action) to a node"), which precisely identifies the operation. This distinguishes it from siblings like set_reactions, get_reactions, and remove_interactions without ambiguity.

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

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

It gives clear conditional context per action type: which actions need a top-level frame, SCROLL_TO's frame constraint, CHANGE_TO's component-set requirement, and direction requirements for directional transitions. It doesn't explicitly name alternative siblings (set_reactions) or when-not-to-use, so it stops short of a 5.

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 usefully discloses that results are reported per node (partial-failure semantics) and that an empty styleId detaches, but it says nothing about permissions, whether detaching loses prior effect data, or what happens to nodes that fail.

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

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

Three short sentences, front-loaded with the core action, then the detach special case, then the result semantics. No filler or repetition.

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

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

For a mutation tool with no annotations and no output schema, the description covers scope (multiple node types), the detach escape hatch, and per-node result reporting. It leaves permission requirements and failure causes unstated, but the essentials for correct invocation are present.

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

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

Schema description coverage is 100%, so nodeId/nodeIds/styleId are already documented. The description adds the node-type scope and reiterates the detach convention, but adds no new syntax or format detail beyond the schema, 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?

Specific verb (apply) plus resource (effect style) with an explicit enumeration of supported node types, and it clearly separates itself from sibling mutators like set_effects (direct effect values) and apply_text_style (different style domain). An agent can identify the operation without opening the schema.

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

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

Usage is implied by the description (attach via styleId, detach via empty string), but it never states when to prefer this over sibling set_effects or how it relates to create_effect_style/update_effect_style. No explicit when/when-not guidance or alternatives.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses that the tool covers text inside instances (with the 'I<instanceId>;<textId>' ID form) and that it reports per-node success, but says nothing about permissions, behavior on non-text nodes, reversibility, or error handling.

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 plus a tight parenthetical example; every clause carries information (target node type, instance edge case, per-node result reporting). 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 mutation tool with no annotations and no output schema, the description covers the salient behavioral bits (instance support, per-node success) but omits safety affordances such as required permissions and what happens on partial failure. Adequate but with clear gaps.

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

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

Schema coverage is 100%, so the baseline is 3, and the description goes beyond it by clarifying the single-vs-multiple node intent and the instance-scoped ID syntax that the schema does not explain. It stops short of describing styleId resolution or required-parameter behavior.

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

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

Names a specific verb and resource (apply a text style) and scopes it to TEXT nodes, including the instance-nested case. The purpose is unambiguous, though it never contrasts itself with siblings like create_text_style, update_text_style, or set_text_content.

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 guidance is given, and no alternative is named. The reader is left to infer that styleId must reference an existing style (get_styles/create_text_style) and cannot tell how this differs from other text-mutating siblings.

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

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

No annotations are provided, so the description carries the full burden. It discloses useful behavior: fills/strokes bind to the first paint as COLOR, shortcut field semantics, and null variableId unbinds. But it omits whether rebinding overwrites, permission/type prerequisites, error behavior, and idempotency.

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?

Front-loaded with the action, followed by relevant field, shortcut, and unbind details in a single efficient paragraph. The field enumeration duplicates the schema enum, but the shortcut definitions and unbind instruction earn their place.

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

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

With no annotations and no output schema, the description must carry more responsibility. It covers purpose, field targets, shortcuts, and unbind, but misses usage context and prerequisites like matching variable types or node eligibility. Adequate but with clear gaps for a mutation tool.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description still adds meaning beyond the schema by expanding the shortcut fields ('padding' = 4 sides, 'cornerRadius' = 4 corners) and clarifying that fills/strokes bind to the first paint as COLOR. It repeats the null-to-unbind behavior already in the schema, keeping it from a 5.

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

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

States a specific verb ('Bind') and resources ('variable', 'node property'), and the field list clarifies the scope of binding targets. However, it does not explicitly distinguish this operation from sibling variable tools like set_variable_value or create_variable, 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?

Provides only parameter-level guidance (pass variableId null to unbind). It never says when to use this tool versus alternatives, nor does it mention prerequisites such as node type or variable type compatibility.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

With no annotations provided, the description carries the burden and does well: it discloses the post-operation layout behavior (grid, max 4 columns, 24px gap, 24px padding) and the resize behavior including the auto-layout exception. It does not state permission/auth needs or error behavior, but the transformation it performs is well conveyed.

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

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

Three sentences, front-loaded with the core action, then the naming requirement, then the layout side effects. Every sentence adds information an agent needs, with no padding.

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 exists, and the description covers purpose, prerequisites, and the layout/transform behavior — enough for an agent to call it correctly. Minor gaps (return value shape, error cases) are acceptable for a mutation tool without declared annotations.

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

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

Schema coverage is 100% (baseline 3), and the description adds a meaningful constraint by explaining the required variant-naming convention that governs valid componentIds. The name and parentId parameters are left to schema descriptions but are minor and adequately documented there.

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 precise verb and resource: 'Combine multiple main Components into a Component Set (variants).' This clearly distinguishes it from siblings like create_component_from_node, create_component_instance, and add_component_property, which do related but different operations.

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

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

Provides a strong precondition — each component name must use the 'Prop=Value' variant format so Figma can derive properties — which is essential context for success. However, it does not explicitly route the agent away from related siblings (e.g., when to use create_component_from_node instead), so alternative selection is left 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?

With no annotations, the description must carry the behavioral burden, and it does disclose the key trait: the node is replaced in place by the new component, so an agent knows the original node no longer exists. It omits other useful traits such as permission requirements, effect on children, or error behavior, so it adds real value but is not rich.

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

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

Two short sentences, zero filler, and the core action ('convert an existing node into a main Component') is front-loaded ahead of the in-place replacement note.

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

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

For a simple two-parameter tool with no annotations and no output schema, the description covers the essential action and its main side effect. It leaves the return value unaddressed (no output schema to fall back on), which is a minor gap rather than a serious 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% for both parameters, so the schema already documents nodeId and the optional name. The description adds no syntax, default-naming, or format detail beyond that, which is the correct baseline-3 case when the schema does the heavy lifting.

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

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

The description names a specific verb (convert) and target resource (an existing node into a Figma main Component), and the term 'main Component' conceptually separates it from sibling instance tools like create_component_instance. It stops short of explicitly naming or contrasting any sibling, so it lands at a clear-but-undifferentiated 4.

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 when-to-use guidance, no prerequisites, and no alternative named (e.g. versus create_component_instance or clone_node). The example 'e.g. a frame' only faintly implies the input scenario, leaving routing to inference.

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

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

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?

No annotations are provided, so the description carries the full behavioral burden. It does add genuine value by noting the style is 'local' (not a published library style) and by describing the return value, but it says nothing about required permissions, duplicate-name behavior, or what happens on invalid effect input.

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 compact sentences, zero filler, with the resource type and example front-loaded and the follow-on action named last. Nothing could be removed without losing information.

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

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

For a 3-parameter creation tool with a fully documented schema and no output schema, the description covers what it makes and what it returns. The only gap is failure-mode behavior (duplicate names, invalid effect combos), which an agent would need but which is not essential to calling it.

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

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

Schema description coverage is 100%, with each parameter and nested effect field already documented in the schema, so the baseline is 3. The description's only added signal is the 'Shadow/lg' naming example, which duplicates the schema's own 'Shadow/md' example rather than adding new 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?

Specific verb+resource ('Create a local effect style') with a concrete example value and a stated effect ('Returns the style id for apply_effect_style'). It is clearly distinguishable from sibling tools update_effect_style, apply_effect_style, and create_text_style.

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 closing clause implicitly tells the agent this is the creation step that must precede apply_effect_style, which gives real workflow context. It stops short of explicit when/when-not guidance, e.g. how to handle an already-existing style of the same name vs. update_effect_style.

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. It does disclose a genuinely non-obvious behavioral trait: Figma wraps the result in a FRAME containing the vector paths. But it omits failure behavior (invalid SVG), permission needs, and how position/parenting resolves beyond what the schema states.

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 tight sentences, zero waste, with the core action front-loaded and the FRAME-wrapping behavior following as supporting 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?

No output schema exists, and the description partially compensates by explaining what gets produced (a FRAME containing vector paths). Remaining gaps – coordinate behavior and error handling – are minor given the fully documented schema.

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

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

Schema description coverage is 100%, so all five parameters are already documented in structured data. The description adds no format or syntax detail beyond the schema (the SVG sizing hint is already in the param description), 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?

Specific verb+resource: 'Create vector nodes from SVG markup'. The parenthetical use case and the note about FRAME wrapping make it immediately distinguishable from sibling creation tools like create_rectangle, create_frame, and create_text.

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 parenthetical '(e.g. to replace raster PNG icons with editable vectors)' gives a concrete triggering scenario, which is clear context. However, it offers no explicit when-not-to-use guidance or named alternatives among the many creation 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?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create a section' implies a mutating operation, but the description does not state what the tool returns (no output schema exists), whether the section is auto-populated with selected content or created empty, or whether it becomes the active selection. Core behavioral details an agent needs post-invocation are absent.

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

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

A single, efficient sentence with zero filler. The content is appropriately front-loaded: the action ('Create a section') comes first, followed by its purpose. It could arguably be slightly richer given the missing usage context, but as pure conciseness it is tight and well-ordered.

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

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

For a creation tool with five parameters, no annotations, and no output schema, this description is underspecified. It does not cover return value, interaction with the current selection, relationship to frames/sections in Figma's hierarchy, or how it fits with sibling tools like set_parent or move_node. An agent cannot confidently predict the outcome of calling this tool.

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

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

Schema coverage is 100% (all five parameters are described in the schema), so the baseline is 3. The description adds nothing about parameter semantics beyond the schema's own field descriptions — no mention of coordinate units, origin reference, or how name is used. Since the schema already documents each field adequately, the description's silence is acceptable but not additive.

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

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

The description states a specific verb and resource ('Create a section in Figma') and adds a purpose ('to group related content on the canvas'). This broadly distinguishes it from siblings like create_rectangle or create_text. However, it does not differentiate from create_frame, which also groups content in Figma, so the intent is clear but the boundary with the nearest sibling is fuzzy.

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 a section versus a frame or another container tool, despite create_frame being an obvious alternative for grouping content. There is no mention of prerequisites (e.g., whether it needs a selected node or a parent), nor any exclusion criteria. The usage context is entirely left to the agent to infer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the style is 'local' (file-scoped) and that it returns a style id for apply_text_style, which is genuinely beyond the schema. It omits edit-permission requirements, whether creation mutates current document state, duplicate-name behavior, and error conditions.

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

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

Three short sentences with zero padding; the core action is front-loaded, followed by the naming convention and the return value. 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?

For an 11-parameter create tool with no annotations and no output schema, the description does well to state the return value ('style id') and the naming convention. It still leaves behavioral gaps around permissions, mutation scope, and failure modes that an agent creating document assets would benefit from knowing.

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 baseline is 3, but the description adds a real naming convention ('use slashes to group styles, e.g. Heading/H1') that the schema does not codify as a grouping rule. Other parameters are left entirely to the schema, which is acceptable given full coverage.

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

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

States a specific verb and resource ('Create a local text style (typography token)'), which is unambiguous and distinct from update_text_style or create_effect_style. It does not explicitly name a sibling to contrast against, so it falls short of the top mark.

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 mention of 'apply_text_style' implies this is the precursor to applying that style, giving implied usage context. However, there is no explicit when-to-use/when-not-to-use guidance, no mention of update_text_style for modifying existing styles, and no prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that creation happens and a value is optionally set, but says nothing about conflict behavior, whether the created variable is returned, required permissions, or how name collisions 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?

Three tight sentences, front-loaded with the core action followed by two genuinely useful conventions (grouping slashes, RGBA range). No filler or 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?

Parameters are fully documented by the schema, but with no annotations and no output schema the description should say more about the mutation's effects and result. Behavior on name conflicts and the return value of the newly created variable are left unaddressed.

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 six parameters, including RGBA 0-1 ranges and the aliasOf variant. The description reinforces the slash-grouping convention and RGBA range, but adds little beyond what the schema already states, landing at the baseline of 3.

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

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

The description gives a specific verb (create) and resource (variable in a collection) plus the optional value-setting behavior. It is clear what the tool does, though it does not explicitly contrast itself with close siblings like set_variable_value or create_variable_collection.

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 offers a practical naming convention (slashes for grouping) and a color format note, which is genuine guidance. However there is no explicit when-to-use / when-not-to-use statement and no routing to alternatives such as set_variable_value for updating an existing variable.

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

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

With no annotations, the description carries the full burden, and it does disclose two genuinely useful behaviors: the default mode is renamed to modes[0] and the rest are appended, plus a paid-plan caveat for multiple modes. It omits permissions, reversibility, and return value (e.g., the new collection's id), which an agent would want before chaining calls.

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 tight sentences with the primary action front-loaded and the mode-index behavior following immediately. Every clause carries information; nothing is padding.

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 small two-parameter creation tool with a fully covered schema and no output schema, the description conveys the key behavioral nuance (mode handling and the plan constraint). It stops short of stating where the collection is created or what identifier is returned, but otherwise it is sufficient to call correctly.

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

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

Schema coverage is 100%, so the baseline is 3, and the description goes beyond it by explaining the semantics of the modes array: index 0 overwrites the default mode while later entries are added. That is real meaning the schema's one-line description does not convey.

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

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

States a specific verb and resource ('Create a local variable collection') that is immediately distinguishable from sibling create_variable or delete_variable_collection. It does not explicitly position itself relative to those siblings, but the resource noun 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?

There is no when-to-use guidance, no prerequisites (e.g., needing an existing file/page context), and no mention of alternatives such as create_variable for populating the collection afterward. The only conditional note concerns paid plans, not tool 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. 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, the description carries full behavioral burden, and it delivers the key non-obvious trait: dependent nodes 'keep their current values but are detached' rather than being modified or deleted. It omits irreversibility/permission details, but the disclosure of the detachment side effect is the most important behavior for this mutation.

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

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

Two short sentences, zero waste, with the core action front-loaded and the consequential side effect second. Every clause earns its place.

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

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

For a single-parameter mutation tool with no output schema and no annotations, the description covers purpose and the important side effect on dependent nodes. Remaining gaps (whether deletion is recoverable, behavior on an unknown ID) are minor for a tool of this simplicity.

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% for the single required styleId parameter, so the schema already documents it fully. The description's 'by ID' adds no syntax or format detail beyond the schema 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?

States a specific verb (Delete), a precise resource (local style), and enumerates the style subtypes it covers (text, paint, effect, grid) plus the lookup key (ID). An agent can distinguish this from siblings like delete_node, delete_variable, and create_text_style without opening any 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 implies usage ('delete ... by ID') but offers no explicit when-to-use/when-not guidance and no prerequisites, and it doesn't reference any alternative sibling such as get_styles for discovery. Adequate but leaves routing to inference.

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

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

With no annotations, the description carries the full burden and does well: it flags permanence, irreversible-through-this-tool, and the side effect that bound nodes lose their binding. It stops short of permissions, error behavior (e.g., failure on bound variables), or return value, so not a 5.

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

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

Three short clauses, front-loaded with the DESTRUCTIVE warning, then the side effect, then irreversibility. Every sentence earns its place with no filler.

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

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

For a single-parameter delete tool with no annotations and no output schema, the description covers purpose, destruction scope, and reversibility adequately. It omits permission requirements and error scenarios, a minor gap against such a simple surface.

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 is one parameter, variableId, and schema description coverage is 100%, so the schema already documents it fully. The description adds no format, ID-source, or lookup guidance beyond the schema, 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?

States a specific verb (delete) and resource (local variable), and the word 'local' plus the singular resource distinguishes it from the sibling delete_variable_collection. An agent can route correctly without opening the schema.

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

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

The destructive framing implies when it should be used (removing a variable), but there is no explicit when-to-use guidance or named alternative such as delete_variable_collection for collection-level removal. Usage is implied rather than stated.

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

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

With no annotations present, the description carries the full behavioral burden and does well: it discloses destruction, cascading removal of all contained variables and modes, loss of node bindings, and irreversibility through this tool. It omits permission requirements and failure/idempotency behavior, so it falls short of a 5.

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, zero waste, and the most important signal ('DESTRUCTIVE') is front-loaded before the consequences. Every clause adds decision-relevant information.

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

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

For a single-parameter, no-annotation, no-output-schema mutation tool, the description covers the critical facts an agent needs: severity, cascade scope, binding side effects, and irreversibility. It could still note how to obtain the collectionId (e.g., from get_local_variables), which is the only notable gap.

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

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

Schema description coverage is 100%, so the schema already documents collectionId fully. The description adds cascade context but no parameter-specific syntax, sourcing guidance, or format details beyond the schema, 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 and resource ('permanently delete a local variable collection') and explicitly scopes the cascade to 'ALL variables and modes inside it', which cleanly distinguishes it from sibling delete_variable (single variable) and delete_style/delete_node.

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

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

It gives clear context for when caution is required (destructive, cascading, irreversible) but does not name alternatives or state when a lighter-weight tool like delete_variable should be used instead. Clear context with no explicit exclusions maps to a 4.

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

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

No annotations are provided, so the description carries the full burden. It discloses the write-to-local-folder behavior and the source-mode routing, but says nothing about overwriting existing files, error/partial-failure behavior, or the shape of the result for a 5-parameter mutation tool.

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

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

Two sentences, zero waste, with the core action and destination front-loaded and the source-routing rule following. Every clause earns its place.

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

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

For a tool with no output schema and a nested items array, the description covers purpose, destination, and source-mode selection adequately. It stops short of describing return values or failure handling, but that gap is minor against the schema's field-level detail.

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 high (~80%), so the baseline would be 3, but the description adds real meaning: it explains the semantic distinction between the 'plugin' and 'rest' source modes and ties url/fileKey specifically to the rest path. This goes beyond the schema's terse per-field descriptions.

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

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

States a specific verb and resource (download icons, illustrations, image fills from Figma) plus destination (local folder) and rationale (so generated code can reference them). This clearly distinguishes it from siblings like export_node_as_image, which renders a single node rather than batch-downloading referenced assets.

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

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

Explicitly routes the agent: use source 'plugin' for designs read with get_design_context, or 'rest' (with url/fileKey) for designs read with get_figma_design_from_url. The condition and the relevant alternatives are named directly, leaving little 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, 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?

With no annotations, the description carries the full burden and does well: it discloses the returned spec's structure, the shared-value indirection (styles referenced by id via layout*/fill*/stroke*/effect*/text*), CSS-like layout semantics, the exportAs:svg convention, and the designStyles/variables token exposure. It omits read-only/auth permissions and any rate/scope limits, but the read nature is clear.

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

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

Front-loaded with purpose, then dense but purposeful detail on spec format and token mapping. Every clause is substantive, though the single long paragraph could be slightly tightened without loss.

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 exists, so the description must explain the return value, and it does so thoroughly: the spec's node/style indirection, layout conventions, asset markers, and token names. An agent has enough to call and interpret the result correctly.

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

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

Schema coverage is 100%, so nodeIds, maxDepth, and includeHidden are already documented. The description confirms that nodeIds defaults to the current selection but adds no depth/hidden-layer guidance, and it mentions an 'exportAs' option that isn't an actual input parameter. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb ('Read'), resource (a Figma design from the open file), and a precise deliverable: a 'compact, code-oriented spec (layout, styles, text, components, variables, assets) for generating UI code.' This differentiates it from generic readers like read_my_design, get_node_info, and get_nodes_info by its code-generation orientation.

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?

Explains input routing ('Uses the given nodeIds or the current selection') and hands off a related task ('assets lists icons and image fills to download with download_design_assets'). It does not, however, explicitly state when to prefer this over siblings like read_my_design or get_node_info, so routing is implied rather than 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 present, so the description must carry the burden of disclosing behavior. It only states 'get detailed information', which implies a read, but does not explain what details are returned, permissions needed, or any limitations. This is under-informative for an agent.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

No annotations are provided, so the description carries the full burden and does well: it discloses the auth requirement, the two distinct return modes (spec vs file outline), the shared-styles indirection, the exportAs:svg marker, and the assets list. It stops short of pagination/rate-limit notes, keeping it at 4.

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?

Front-loaded with the core purpose and prerequisite, then the mode distinction. Dense but every sentence covers a distinct concept (mode, spec format, assets, tokens); the return-format detail is legitimately needed given no output schema.

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 complex, no-output-schema read tool the description covers return shapes, token/auth needs, and asset handling well. Minor residual gaps are pagination limits and how maxDepth/includeHidden affect the spec, but nothing essential to 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 coverage is 100%, so baseline is 3, but the description adds value by showing the URL format example, the fileKey+nodeId alternative, and the behavioral consequence of supplying a node. maxDepth and includeHidden are left to the schema, which is acceptable.

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

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

States a specific verb and resource ('Read a Figma design') plus the method ('Figma REST API, no plugin needed'). It is clearly distinguishable from siblings like read_my_design (plugin-based) and get_node_info by naming its URL-driven read path.

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?

Explains the token prerequisite (FIGMA_ACCESS_TOKEN) and the node-vs-no-node selection rule with the purpose of each mode ('pick one'). It routes to download_design_assets for assets, though it doesn't explicitly contrast with read_my_design or get_design_context siblings.

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

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

No annotations are provided, so the description carries the full burden. 'Get ... of the current page' implies a safe, read-only, page-scoped operation with no parameters, which sets reasonable expectations, but it says nothing about the shape of the returned list or whether inherited/remote flows are included.

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; the scope qualifier appears exactly where it is needed.

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

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

For a zero-parameter query tool with no annotations and no output schema, the description is minimally complete but does not clarify what a 'flow starting point' record contains or how results relate to the page's prototype settings.

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

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

Zero parameters, so the baseline is 4. The description usefully documents the implicit scope — 'the current page' — which is the only contextual input an agent could otherwise get wrong.

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?

Specific verb 'Get' plus resource 'prototype flow starting points' scoped to 'the current page'. The verb alone distinguishes it from the write-side siblings set_flow_starting_point and remove_flow_starting_point, though the description never names them 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?

Usage is implied by the read-only 'Get' framing, but there is no statement of when to reach for this versus set_flow_starting_point/remove_flow_starting_point or any prerequisites. Adequate but leaves routing to inference.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

With no annotations provided, the description bears full responsibility for disclosing behavior. It states the scope ('local components' and 'from the Figma document') but does not describe return format, pagination, or what constitutes 'local' versus imported components.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

With no annotations, the description carries the full behavioral burden. It does add useful return-shape context ('Color values are returned as hex, aliases as { aliasOf }'), which is valuable since there is no output schema. But it omits other behavioral traits such as what happens when the document has no variables or whether remote/library variables are included.

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 tight sentences, front-loaded with the core purpose and followed by the most decision-relevant detail (return format). No filler or 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 zero-parameter, read-only getter with no output schema, the description covers the essential scope ('local', 'current document') and the notable return encodings (hex colors, aliasOf aliases). It is close to complete, though scope questions like local-only vs remote variables could be clearer.

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 takes zero parameters, so per the rubric the baseline is 4. Schema coverage is 100% and there is nothing for the description to compensate for regarding 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?

States a specific verb and resource: 'Get all local variable collections (with modes) and variables in the current document.' This clearly distinguishes it from get_styles and get_local_components, which retrieve different design artifacts. However, it does not name those siblings explicitly, 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?

Usage is implied by the resource: an agent can infer this is the read tool for local variables. There is no explicit when-to-use/when-not-to-use guidance, no mention of alternatives (e.g. get_styles for styles), and no preconditions stated. Adequate but with clear gaps.

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. 'Return' implies a read-only operation and 'read directly in the plugin (no REST API)' adds a genuine behavioral note about how the data is fetched. However, it says nothing about what happens for non-instance inputs or failure behavior, so it only partially covers the gap.

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

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

A single front-loaded sentence with no filler; the parenthetical cleanly lists return fields and the delivery mechanism. Slightly dense but nothing wasteful.

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

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

With no output schema, the description usefully enumerates return values, which is the main thing an agent needs. But both parameters are optional with no stated relationship or default behavior, and no error/edge-case handling is described, leaving a meaningful gap for a 2-param lookup tool.

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

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

Schema description coverage is 100%, so nodeId and nodeIds are already documented in the schema. The description corroborates by noting 'one or more INSTANCE nodes', but adds no new semantics such as mutual exclusivity between the two optional params. 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?

States a specific verb (Return) and resource (main component of INSTANCE nodes) and enumerates the returned fields (id, name, variant name, component set). It does not explicitly contrast with near siblings like get_local_components or get_instance_overrides, so it lands at a clear-but-undifferentiated 4.

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 scope ('INSTANCE nodes') implies when the tool applies, and the one-or-more framing hints at batch use, but there is no explicit when-to-use guidance and no named alternative. Usage must be inferred.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

No annotations are provided, so the description itself must convey behavior. It implies a read-only operation via 'Get', but it does not disclose what constitutes a 'style' (e.g., paint vs text styles) or any error conditions. This is minimal but not misleading.

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

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

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

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

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

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

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

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

The input schema is empty, so there are no parameters to explain. The description correctly focuses on the tool's action, and with zero parameters, no further semantic detail is necessary.

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

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

The description clearly states the verb 'Get' and the resource 'all styles' scoped to 'the current Figma document', which distinguishes it from sibling tools that create, apply, or rename styles. There is no ambiguity about what the tool does.

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

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

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

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

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

No annotations are provided, so the description carries the full burden of explaining side effects, permissions, idempotency, or state changes. The description only says 'Join a specific channel' and gives no indication of what happens when joining, whether it is reversible, whether authentication is required, or what observable effects occur.

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

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

The description is a single sentence with no redundant clauses, making it concise and easy to parse. The phrase 'specific' is slightly filler-like, but overall the structure is clean and front-loaded with the 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?

Given one optional parameter, no output schema, no annotations, and a tool that is disjoint from the many sibling node/manipulation tools, the description is too thin for an agent to understand when or how to call it. It does not explain what channels exist, where the channel name comes from, what a successful join looks like, or what conditions cause failure.

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

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

Schema coverage is 100% with a parameter description ('The name of the channel to join'), so the schema already handles the basic meaning. The tool description adds no extra information about channel format, naming rules, valid values, or how to discover available channels. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a concrete action ('Join a specific channel') and identifies the resource (a channel), but the purpose is vague: 'to communicate with Figma' does not explain what joining the channel accomplishes, what a channel is in this context, or how this relates to the other Figma tools. It is not a tautology, but it lacks enough specificity to be fully clear.

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

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

The description provides no guidance on when to use this tool, what problem it solves, or which situations warrant joining a channel. It does not mention any prerequisites, exclusions, or alternatives. An agent has no context to decide when this tool is the right choice.

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

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

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

With no annotations provided, the description carries the full burden. The name and verb 'Get' imply a read-only operation, but the description does not disclose what happens when there is no selection, whether multiple nodes are returned, or the exact structure of the returned 'node details'. It remains somewhat vague about the tool's behavior beyond the basic read action.

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

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

The description is a single, front-loaded sentence that immediately states the action and subject. It is concise with no wasted words or redundant phrasing.

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

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

The tool has no parameters and no output schema, so the description is the only source for return expectations. It says 'detailed information' and 'all node details' but does not enumerate the details or mention edge cases like empty selection. While the tool is simple, the description could be more precise about the returned content and error behavior.

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

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

The input schema is empty with zero parameters, so there are no parameter semantics to explain. The description does not need to compensate for undocumented parameters, and the baseline for 0 parameters is 4, which is appropriate 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 states the verb 'Get' and the resource 'detailed information about the current selection in Figma', and adds 'including all node details' which specifies the scope. This distinguishes it from sibling tools like 'get_selection' which likely returns only the selection IDs, and 'get_node_info' which targets specific nodes rather than the current selection.

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

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

The description implies usage when the current selection's details are needed, but it does not explicitly state when to use it versus alternatives like 'get_selection' or 'get_node_info'. There is no exclusionary guidance or mention of alternatives, so the usage context is only implied.

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 states the mutation but omits side effects, reversibility, permission requirements, or what happens if no flow starting point exists.

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

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

A single, front-loaded sentence with zero waste. It communicates the action and target immediately.

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

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

For a simple one-parameter mutation with full schema coverage, the description covers the core purpose. However, with no annotations and no output schema, it should disclose more about behavior (e.g., errors if no starting point) to be fully complete.

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

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

Schema coverage is 100% and the single nodeId parameter is fully documented in the schema. The description adds no format or constraint details beyond what the schema already provides, so 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?

States a specific verb (Remove) and resource (prototype flow starting point of a frame), clearly distinguishing it from sibling set/get flow starting point tools by verb. No explicit sibling naming, but the verb makes the operation 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 when-to-use guidance, prerequisites, or alternatives are mentioned. Usage is only implied by the tool name and description.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about reversibility, permissions, or side effects of a destructive removal, and the 'all vs. trigger type' scoping it does mention is already stated in the triggerType schema field.

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 waste; the two operating modes are stated economically in one clause.

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

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

For a simple two-parameter, schema-complete removal tool with no output schema, the description is sufficient to invoke it correctly. The remaining gap is the absence of any behavioral/safety context for a destructive operation with no annotations.

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

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

Schema description coverage is 100%: nodeId is documented as 'ID of the node' and triggerType explicitly notes 'omit to remove all' with a full enum. The description adds no format or constraint detail beyond the schema, 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?

States a specific verb (remove) and resource (prototype interactions) scoped to a node, which clearly positions it as the deletion counterpart to add_interaction/set_reactions. It does not name any sibling explicitly, so it stops short of full differentiation.

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

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

The description implies usage by explaining the two removal modes (all vs. filtered by trigger type), but it never states when to prefer this tool over siblings like set_reactions or set_reactions-based overwrites, nor any prerequisites (e.g., the node must be a prototype/frame).

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a node is renamed and does not mention side effects, return behavior, reversibility, or failure cases. For a mutating operation, this is a meaningful transparency gap.

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

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

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

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 low complexity and the complete parameter schema, the description is sufficient for an agent to invoke the tool correctly. It lacks some behavioral context, such as return/error behavior, but that is a minor gap for such a simple 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?

Both parameters are fully described in the input schema, so schema coverage is 100%. The tool description adds no extra parameter-level detail, but it does not need to; the baseline of 3 applies.

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

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

The description uses the specific verb 'rename' with the resource 'node in Figma,' making the tool's purpose immediately clear. It also naturally distinguishes this tool from siblings like move_node, clone_node, and delete_node.

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

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

The intended use is implied: use this tool when you need to change a node's name. However, there is no explicit guidance about when not to use it or comparison with alternatives, so the usage guidance is minimal but not misleading.

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?

With no annotations, the description carries the full disclosure burden. It does communicate the destructive replace semantics and the empty-array clearing behavior, which is meaningful, but says nothing about return values, error behavior for invalid nodes, or Figma quirks (e.g. only one drop shadow/inner shadow allowed per node).

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

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

Two short sentences, zero filler, with the core action front-loaded and the edge case (clearing) immediately following. Nothing should be removed.

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

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

For a two-parameter setter with no output schema and no annotations, the description covers what is set and the clearing case, but leaves the mutation's side effects and failure modes unaddressed. Adequate minimum, with clear gaps for an agent reasoning about a write 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 coverage is 100%, so the schema already documents nodeId and the effect object fields (baseline 3). The description adds semantics beyond the schema by explaining that an empty effects array clears all effects, a behavior not derivable from the schema alone.

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

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

States a specific verb and resource ('Replace the effects ... of a node') and enumerates exactly which effect kinds are covered (drop/inner shadows, layer/background blur). "Of a node" implicitly separates it from the effect-style siblings (create_effect_style, apply_effect_style), and the second sentence pins down the clear-all case.

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 empty-array instruction is a useful concrete usage rule, but there is no guidance on when to use this direct node setter versus apply_effect_style or create_effect_style, nor any prerequisites (e.g. which node types accept which effect kinds). Usage is implied rather than stated.

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

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

Annotations 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, the description carries the full behavioral burden. It usefully reveals an upsert-like behavior via 'Add (or rename)', implying an existing flow with the same name is renamed rather than duplicated, and it flags the top-level-frame precondition. It does not say what happens on invalid nodes, whether it overwrites or errors on name collisions, or what 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?

A single eleven-word sentence with zero filler, and the operation plus its key constraint are front-loaded. Every clause earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description covers what the tool does and where it applies, but leaves error/return behavior and the interaction with the sibling flow-starting-point tools unspecified. Adequate but with clear gaps an agent would want closed.

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

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

Schema description coverage is 100% and both parameters are documented in the schema (name = flow name, nodeId = top-level frame ID). The description merely restates the same semantics at a high level and adds no syntax, ID format, or constraint detail beyond the schema, 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?

States a precise verb ('Add (or rename)') and resource ('prototype flow starting point') with an explicit scope constraint ('on a top-level frame'). It does not name the closely related siblings get_flow_starting_points or remove_flow_starting_point, so differentiation is implicit rather than explicit.

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 when-to-use/when-not-to-use statement or reference to alternatives. Usage is only implied by the parenthetical 'or rename' and the constraint that the target must be a top-level frame, which tells the agent the precondition but not how this differs from rename_node or the remove/get flow 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?

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.