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

No annotations are supplied, so the description carries the full behavioral burden for a mutation tool, yet it says nothing about permissions, whether the property is immediately effective, what happens when a name collides with an existing property, or the consequences of defaultValue/preferredValues. It discloses only the accepted value types, which is surface-level information.

Agents need to know what a tool does to the 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 verb and the enumerated property types come first. It is appropriately sized for a sentence, though the brevity here reflects under-specification rather than disciplined concision.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description is far too thin. An agent cannot determine how to select the target (nodeId vs componentId vs componentSetId), what preferredValues or preferComponentSet do, or what a successful call returns.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and largely does not. It names the four `type` values but leaves name, nodeId, componentId, componentSetId, defaultValue, preferredValues, and preferComponentSet completely unexplained, including the critical question of which identifier targets a component versus a component set.

Input schemas describe structure but not intent. Descriptions should explain 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 (Add) and resource (a component property) and enumerates the four supported property types, which an agent can map directly to the `type` enum. It is clearly distinguishable from sibling mutators like edit_component_property and delete_component_property by the 'Add' action, though it never names those 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?

The phrase 'to a component or component set' hints at the target, but there is no guidance on when to use this versus edit_component_property, bind_component_property, or set_variant_properties, and no prerequisites or ordering constraints are given. An agent gets no help choosing among the several property-related 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 full behavioral burden. It usefully discloses layout behavior (children join the slot's flow, AUTO+FILL under auto layout, 0,0 when freeform) and warns against a follow-up move_node, but omits whether the operation is reversible, what happens on conflicts, or permission requirements.

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

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

Three front-loaded sentences with no filler; the core action and the caution against move_node are stated first. Phrasing such as "at 0,0 when it is freeform" is slightly terse but acceptable.

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

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

For a mutation tool with no annotations, no output schema, and low param coverage, the description covers the key layout outcome but leaves gaps around reversibility, conflict handling, and the undocumented parameters. It is minimally adequate rather than 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 only 33% across 6 parameters. The description names index and layoutSizing as optional but adds no meaning beyond that, and never addresses ignoreAutoLayout, nodeIds, or slotNodeId. It does not compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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 (Reparent) and resource (existing nodes into a SLOT), making the operation clear and distinguishable from generic node operations. It does not explicitly differentiate itself from close siblings like reparent_node, insert_child, or move_node, 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 an implicit usage constraint ("Do not move_node afterwards"), which hints at workflow sequencing, but never states when to use this over reparent_node, insert_child, or move_node. Usage is implied rather than explicitly scoped.

Agents often have multiple tools that could apply. Explicit usage 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 largely succeeds: it discloses that duration/timelineOffset are top-level rather than nested in props, that it returns an instance id, and the non-obvious fact that applying a style does not materialize tracks into animations. It omits auth/permission and error/rate behavior, but the semantic gotchas are well covered.

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

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

The core action is front-loaded and each sentence adds information about identification, units, return value, or verification. It is dense but avoids filler, though it reads as a run-on sequence rather than cleanly separated concerns.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 9-param mutation tool with no annotations and no output schema, the description supplies the critical path: how to identify the style, unit semantics, the return value, its downstream consumer, and how to verify the result. The gap is the undocumented secondary params (extendTimeline, allowTopLevelFrame, props).

Complex tools with many parameters or behaviors need more documentation. 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 0% across 9 params, so the description must compensate. It clarifies styleId, styleName (substring match), duration, and timelineOffset (seconds, top-level not props), but leaves name, props, nodeId, extendTimeline, and allowTopLevelFrame undocumented, so compensation is only partial.

Input schemas describe structure but not intent. Descriptions should explain 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 first sentence states a specific verb and resource ('Apply a reusable animation style to a node'), and the mention of remove_animation_style plus the returned instance id distinguishes it from adjacent animation tools. An agent can identify the action 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?

It names list_animation_styles as the source for styleId and remove_animation_style as the consumer of the returned instance id, giving clear routing context. It stops short of an explicit when-to-use/when-not statement, but the identification instructions make usage unambiguous.

Agents often have multiple tools that could apply. Explicit usage 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 and delivers almost none of it. It doesn't disclose whether existing effects are replaced or merged, whether the node must be a compatible type, or whether the styleId must resolve to a local effect style.

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

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

A single short, front-loaded sentence with no wasted clauses. But it is terse to the point of under-specification, and the 'effect style to a node's effects' construction is redundant rather than economical.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, no output schema, and 0% schema description coverage, the description is the only source of context and it leaves the mutation semantics, prerequisite (does the style need to exist?), and parameter meaning unexplained. For a two-required-parameter mutation tool this is a clear 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 0% for both required parameters. The description's words 'node' and 'effect style' give only the roughest hint that nodeId and styleId take a node identifier and a style identifier; no format, ID type, or lookup source is specified.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Apply an effect style'), so the agent knows it performs a style application. However, 'to a node's effects' is circular phrasing and the description does nothing to distinguish it from the many sibling appliers (apply_fill_style, apply_stroke_style, apply_text_style, apply_grid_style), though the 'effect' noun does implicitly scope it.

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

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

No when-to-use guidance at all. It does not say whether the style must already exist locally (vs. one created by create_effect_style or import_style_by_key), nor whether to prefer set_effects for raw effect data instead of a style reference.

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

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

With no annotations, the description carries the full behavioral burden and does very little: it does not say whether existing fills are replaced or appended, whether the style must be local/imported, what permissions are needed, or whether the change is undoable. 'Apply' implies mutation but nothing is disclosed about its effects.

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

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

A single, front-loaded sentence with zero filler. It is efficient, though its brevity is partly under-specification rather than disciplined conciseness.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is far too thin. An agent lacks the information needed to invoke it correctly or to anticipate side effects.

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

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

Schema coverage is 0% and both parameters (nodeId, styleId) are undocumented in the schema. The description loosely maps them to 'node' and 'paint style', but adds no format, ID scheme, or constraint details, so it does not compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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 (apply), resource (paint style), and target (a node's fills), which is enough to distinguish it from apply_stroke_style, apply_text_style, and apply_effect_style. It does not, however, explicitly name any sibling or note the difference from the generic set_fill_color.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 apply a style versus setting a fill directly (set_fill_color / figma_set_solid_fill), nor any prerequisite such as the style needing to exist locally or be imported first. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden. It implies a mutation but does not disclose whether applying a style replaces existing grids, whether it is reversible, what permissions or preconditions are required, or what happens on failure. Only the barest mutation signal is 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?

A single short, front-loaded sentence with no wasted words. It is appropriately compact for the action, though its brevity reflects under-specification rather than disciplined economy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is far too thin. An agent cannot confidently call it without knowing what the IDs must reference or how existing grids are affected.

Complex tools with many parameters or behaviors need more documentation. 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 0% for both required parameters (nodeId, styleId). The description implies a frame (nodeId) and a style (styleId) but adds no format, ID-source, or constraint detail, so it barely compensates for the undocumented schema.

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

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

The description states a specific verb (apply) and resource (grid style) plus the target ('a frame's layout grids'), which is clearer than the bare name. It does not, however, distinguish itself from sibling operations like set_layout_grids or create_grid_style, so an agent must still infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 versus alternatives such as set_layout_grids (which also touches layout grids) or the parallel apply_fill_style/apply_stroke_style family. No prerequisites, e.g. that the style must already exist, are stated.

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

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

With no annotations, the description carries the full burden and does disclose the key behaviors: an import side effect ('Import (if needed)'), the destructive default (replace:true replaces all effects), and the append override. It does not cover failure behavior or permissions, but the destructive default and side effect are the critical disclosures 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?

Four sentences, front-loaded with purpose and followed by routing, alternative, and the append case. Mostly earns its place, though the 'properties may be keyed by...' sentence overlaps with the schema's own description of that 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 an 8-parameter, nested-object, no-output-schema mutation tool, the description covers the non-obvious essentials: import side effect, target routing, replace default, and append behavior. The remaining per-parameter details (visible, paintIndex) are already documented in the schema, so nothing critical 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 already 88%, so the baseline is 3; the description adds real meaning beyond the schema by explaining target routing (effect vs fill shaders) and the replace:false append semantics. The properties-keying sentence largely restates the schema description, so it is not fully 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?

States a specific verb and resource ('Import (if needed) and apply a shader to a node') and immediately differentiates from the sibling by name ('Prefer this over set_effects when applying a SHADER'). An agent can tell it apart from set_effects and the fill/style tools 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?

Gives explicit routing rules ('Effect shaders go on effects; fill shaders go on fills or strokes'), names the alternative and the condition that selects it ('Prefer this over set_effects when applying a SHADER'), and states the append case ('Pass replace:false to append'). Little is left to inference.

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

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

No annotations are provided, so the description carries full behavioral burden. It implies mutation but does not disclose whether existing stroke properties are overwritten, what permissions or preconditions are required, or how the operation affects the node beyond applying a style.

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

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

Two short sentences with zero waste. The primary purpose is front-loaded and the routing instruction follows 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?

Adequate for a simple two-parameter tool with no output schema, but missing key behavioral context such as overwrite semantics and prerequisites. With no annotations available, the description should do more to make invocation safe and predictable.

Complex tools with many parameters or behaviors need more documentation. 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 0% for both parameters. The description links styleId to 'paint style' and nodeId to 'a node's strokes' only indirectly, but does not clarify formats, constraints, or whether the style must already exist.

Input schemas describe structure but not intent. Descriptions should explain 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 (Apply), resource (a paint style to a node's strokes), and explicitly distinguishes itself from the sibling set_stroke_color by naming the alternative and the condition that selects it.

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

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

Explicitly says to use set_stroke_color instead when applying raw color/weight/align/dash without a style, and notes design-system preference. The when-to-use and alternative path are fully 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, yet it discloses almost nothing beyond the mutation implication. It does not say whether applying a style overwrites existing text properties, requires the style to already exist locally, or requires specific permissions, leaving meaningful behavioral gaps 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?

A single short sentence that is front-loaded and waste-free. It is appropriate in size, though its brevity comes at the cost of detail rather than being overcooked.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is far too thin. An agent lacks the prerequisites, side-effect information, and parameter constraints needed to invoke it confidently.

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

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

Schema description coverage is 0%, and the description does not explain what nodeId or styleId must reference, whether styleId accepts remote/imported style keys, or what happens with a mismatched style type. With two required undocumented parameters, the description fails to compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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 'apply' and resource 'text style' on a TEXT node, which is clearer than a bare name restatement. However, the sibling list contains near-identical tools like set_text_style and apply_fill_style/apply_stroke_style, and the description offers no differentiation between apply_text_style and set_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?

No indication of when to use this tool versus set_text_style, apply_fill_style, or apply_stroke_style. The only constraint ('to a TEXT node') is an eligibility condition rather than usage guidance, so an agent must infer routing from names alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that bounds default to the parent, but says nothing about permissions, reversibility, how non-auto-layout children are handled, or failure modes for a mutation-style layout 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?

Three compact sentences with the core action front-loaded and no filler. The dependency on distribute_nodes' option set is stated efficiently rather than re-enumerated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 5-parameter mutation tool with no annotations, no output schema, and zero schema coverage, the description covers the basics but omits allowed values, error/edge behavior, and how it differs operationally from distribute_nodes. 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 description coverage is 0%, so the description must compensate. It names and explains the roles of axis ('horizontal or vertical'), mode, gap, and crossAlign, and implies parentNodeId via 'the parent', but gives no allowed values or formats for mode/crossAlign, leaving key semantics to guesswork.

Input schemas describe structure but not intent. Descriptions should explain 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 ('distribute') and resource ('direct children of a frame/node') and names the axis of operation, so the core action is unmistakable. It references the sibling distribute_nodes but does not clearly delimit the boundary between them, leaving the agent to infer which to pick.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 or when-not-to-use guidance. The reference to distribute_nodes implies a shared option surface but never says which tool applies to a selection versus a parent's children, and the only usage hint is 'Bounds default to the parent.'

Agents often have multiple tools that could apply. Explicit usage 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, and it discloses almost nothing: not whether the fill is replaced or added, not what happens when a node has multiple paints, not error/permission behavior, not reversibility. One short sentence cannot cover a mutation tool with zero 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?

A single front-loaded sentence with no filler or repetition; the verb and target come first. It is efficient, though its brevity borders on under-specification rather than tight concision.

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

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

For a mutation tool with no annotations, no output schema, three undocumented parameters, and near-identical siblings (bind_color_variable_to_stroke, bind_variable_to_property), the definition omits paintIndex semantics, sibling differentiation, and failure behavior. It is not complete enough to guarantee a correct invocation.

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

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

Schema description coverage is 0% for all three parameters, so the description must compensate. It hints at nodeId and variableId implicitly ('node's fill paint', 'COLOR variable') but says nothing about paintIndex, which is the most ambiguous parameter (which paint in the stack gets bound when omitted?).

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

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

The description names a specific verb (bind), a specific resource type (COLOR variable), and a precise target (a node's fill paint), so the action is unambiguous. It implicitly separates itself from the fill/stroke-style siblings by saying 'fill paint', though it never names bind_color_variable_to_stroke or bind_variable_to_property 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?

There is no guidance on when to use this instead of bind_color_variable_to_stroke, bind_variable_to_property, or figma_set_solid_fill. No prerequisites (e.g. variable must be a COLOR variable, node must exist, which paints are eligible) are stated, leaving the agent to infer selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing: no indication of whether the node must already have a stroke paint, whether binding replaces an existing binding, what happens to paintIndex if omitted, or what errors occur. Only the mutation intent is implied by 'bind'.

Agents need to know what a tool does to the 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 or repetition. It is efficient, though its brevity is more under-specification than true conciseness.

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

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

For a mutation tool with no annotations, no output schema, and zero schema documentation, the description does far too little. An agent cannot tell how to target the correct paint or what state the node must be in before binding.

Complex tools with many parameters or behaviors need more documentation. 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 0% across three parameters. The description hints at nodeId and variableId via 'a node's stroke paint' and 'COLOR variable', but paintIndex — the index that selects which stroke paint to bind — is entirely unexplained in both schema and 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?

States a specific verb (bind) and precise resource (a COLOR variable to a node's stroke paint), which implicitly separates it from the sibling bind_color_variable_to_fill. The COLOR-variable restriction is a useful scoping detail. It never names the alternatives or clarifies when stroke binding applies, so differentiation is left 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?

No when-to-use guidance, no prerequisites, and no mention of the obvious neighbors (bind_color_variable_to_fill, bind_variable_to_property). An agent must infer the correct choice purely 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 implies a mutation of node/component state but says nothing about required permissions, whether the binding is reversible, what the 'unbind' path does, or what happens to existing references. Only the operation type 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?

A single front-loaded sentence with zero filler. Nothing in it is wasted, and the core action leads.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 5-parameter mutation tool with no annotations, no output schema, and no per-parameter documentation, the description is too thin. It should at least explain the required vs optional params and the bind/unbind semantics.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. It gestures at the property types and the node-field concept, but leaves nodeId, propertyOwnerId, propertyName, and unbind unexplained beyond their names.

Input schemas describe structure but not intent. Descriptions should explain 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) plus the resource (component property) and target (node field), and names the property kinds BOOLEAN/TEXT/INSTANCE_SWAP. This differentiates it from sibling bind_variable_to_property, but the trailing 'using componentPropertyReferences' is implementation jargon rather than agent-facing meaning.

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

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

There is no when-to-use guidance, no preconditions (e.g. the component property must already exist via add_component_property), and no named alternatives such as bind_variable_to_property or set_instance_properties. The agent must infer the context entirely.

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

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

With no annotations, the description carries the full burden. It discloses the accepted variable types and the underlying setBoundVariable call, plus a hint about preserving a fill via a FLOAT-variable token bind. It does not mention permission requirements, failure/type-mismatch behavior, or what state changes on the node, so disclosure is partial 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?

Two sentences, front-loaded with the core action and the API signature; every clause adds usable content. The parenthetical about opacity/color is slightly dense but still earns its place as an example.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter coverage, the description is adequate but incomplete — it omits error/precondition behavior and nodeId/variableId semantics. It covers enough to attempt a call but not enough to call it safely in edge cases.

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

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

Schema description coverage is 0% with 3 parameters, so the description should compensate. It maps well to the 'property' parameter via examples (opacity, padding, radius, spacing, fontSize) and references a 'variable', but says nothing about nodeId format or variableId expectations, leaving two of three parameters undocumented.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Bind a ... variable to a node property') and names the underlying API call setBoundVariable(property, variable), so the action is unambiguous. It enumerates the accepted variable types (FLOAT/STRING/BOOLEAN/EASING/TIMING), which helps distinguish it from the color-binding siblings. It stops short of explicitly differentiating itself from bind_color_variable_to_fill/stroke 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?

Gives concrete usage context ('Use property "opacity" to token-bind layer opacity' and 'Also used for padding, radius, spacing, and fontSize'), which implies when to reach for it. However, it never states when NOT to use it or points to bind_color_variable_to_fill/stroke as alternatives, leaving the agent to infer the routing between sibling bind tools.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose that boolean operations are destructive to the source nodes, what happens to the originals, whether permission or selection is required, or whether the operation is reversible. For a document-mutating boolean op this is a real 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 core action and its operation vocabulary are presented first with nothing wasted.

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

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

For a 4-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description is thin. It omits the role of name and parentNodeId, the destructive nature of the operation, and any return behavior, so an agent cannot call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It usefully explains the nodeIds requirement (2+ nodes) and names the valid op values (UNION, SUBTRACT, INTERSECT, EXCLUDE), which the schema does not enumerate. However name and parentNodeId receive no explanation at all, leaving half the parameters undocumented.

Input schemas describe structure but not intent. Descriptions should explain 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 (combine) and resource (vector nodes into a boolean group) and enumerates the boolean operations, which is far more than a tautology. It does not explicitly contrast itself with the sibling group_nodes, which is the most likely confusion point, 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?

There is no statement of when to use this versus group_nodes, ungroup_node, or create_vector, nor any prerequisite or exclusion guidance. Usage must be inferred entirely from the name and the operation list.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the z-order model ('children[last] is front-most'), but says nothing about required permissions, what happens if the node is already front-most, 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?

Two tight sentences with no waste, and the purpose is front-loaded ahead of the clarifying detail.

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

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

For a simple single-parameter mutation tool with no output schema, the description covers purpose and the key z-order semantic adequately. The main gap is the absence of any safety or edge-case behavior, which annotations would normally supply.

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

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

The single nodeId parameter is fully documented in the schema (100% coverage), so the baseline is 3. The description adds no meaning about nodeId beyond what the schema already provides.

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

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

States a specific verb and resource ('Bring a layer to the front of its parent') and clarifies the z-order semantics with 'children[last] is front-most.' It is clearly distinguishable from the inverse sibling send_to_back by intent, though it does not name that sibling 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 self-explanatory operation, but there is no explicit guidance on when to use this versus send_to_back or arrange_children, and no prerequisites (e.g., node must have a parent) are stated.

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

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

No annotations, so the description carries the full burden. It usefully discloses the regex capability, a dryRun preview mode, the default scope (current page), and the before/after diff return. However, it never states that matching is destructive/irreversible once dryRun is off, nor what permissions or undo path exist.

Agents need to know what a tool does to the 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, zero filler, with the core action front-loaded ahead of modifiers and the return-value note last. Every clause carries 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 5-parameter mutation tool with no annotations and no output schema, the description covers the essential mechanics (what changes, scope, preview, return). It still omits irreversibility, required auth, and how rootNodeId is specified, leaving real gaps for a bulk 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 0%, so the description must compensate. It explains useRegex and dryRun by name, implies find/replace, and implies rootNodeId via 'subtree (defaults to current page)' – covering four of five params conceptually, though without naming rootNodeId or giving format/syntax 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?

States a specific verb+resource ('Find-and-replace text in node names') and narrows scope ('across a subtree, defaults to current page'). This implicitly separates it from sibling find_and_replace_text (text content) and rename_node (single node), but never names those alternatives 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?

Gives no when-to-use or when-not-to-use guidance and does not point to the obvious alternative (rename_node for a single node, find_and_replace_text for text content). The subtree-default note hints at selection context but is not framed as a usage condition.

Agents often have multiple tools that could apply. Explicit usage 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 for what is a bulk mutation. It discloses nothing about reversibility, undo support, permissions, partial-failure behavior when some nodeIds are invalid, or whether the result reports affected nodes, leaving an agent unable to predict side effects.

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

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

Two tight sentences: purpose first, then the supported-property list, then the targeting modes. Every clause earns its place and nothing is padded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 5-parameter bulk mutation with no annotations and no output schema, the description covers targeting and valid properties but omits value semantics, return behavior, and failure/undo characteristics. It is adequate but leaves meaningful gaps for a mutation of this 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?

Schema coverage is 0%, so the description must compensate, and it does explain the valid property values plus the nodeIds/nodeTypes/rootNodeId targeting combination. The critical 'value' parameter, whose expected type varies with the chosen property, is left entirely unexplained in both the schema and the 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 states a specific verb and scope ('Apply one property across many nodes') and enumerates the supported properties, so an agent knows exactly what operation this performs. It does not explicitly distinguish itself from close siblings such as bulk_rename or the single-property setters (set_corner_radius, set_fill_color), 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?

It describes three targeting modes (nodeIds, nodeTypes under rootNodeId, or the whole current page), which is useful selection guidance. However, it never states when to prefer this tool over the per-node/per-property siblings, nor any prerequisites or exclusions, so usage 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 discloses what is destroyed ('all prototype reactions') but says nothing about irreversibility, undo/checkpoint behavior, permissions, or whether the removal cascades across child nodes.

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

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

A single front-loaded sentence with no filler. The action and scope are stated immediately, though it is minimal rather than optimally informative.

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

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

For a one-parameter destructive operation with no annotations and no output schema, the definition is minimally viable: purpose is clear, but reversibility and the parameter's expected input 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 coverage is 0% and the single nodeId parameter has no type/format documentation. The description never references nodeId or explains whether it expects a node ID, key, or selection, so it fails to compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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) plus resource (prototype reactions) plus scope (from a node), and the quantifier 'all' cleanly separates it from the sibling set_reactions/upsert_reaction. It does not explicitly name those siblings, so it stops 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?

No when/when-not guidance and no alternative named. The agent must infer from the name alone that this is the bulk-clear counterpart to get_reactions/set_reactions rather than a filtering or additive operation.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only states the verb and object. It does not say whether this removes all targets or just the active one, whether the operation is reversible, or what side effects occur on subsequent frame operations.

Agents need to know what a tool does to the 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, which is appropriately sized for a simple clear operation, though its extreme terseness borders on under-specification.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 0-param, no-output-schema tool this is minimally viable, but with no annotations it leaves unanswered what state results after clearing (e.g., does it fall back to a default frame or to none) and when this should be called relative to set_target_frame.

Complex tools with many parameters or behaviors need more documentation. 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 and describes the cleared state, which is the complete input surface. Baseline for a 0-parameter tool is 4, and nothing here undermines that.

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

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

The description pairs a clear verb ('Clears') with a specific resource ('target frameIds'), so the agent knows it manipulates the target-frame selection. It does not, however, distinguish itself from the related siblings set_target_frame and get_target_frames beyond the verb.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 and no mention of the obvious alternatives (set_target_frame to add, get_target_frames to inspect). The agent must infer the workflow from the sibling names alone.

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

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

No annotations are provided, so the description carries full behavioral burden. It says a copy is created but does not disclose permissions needed, whether the copy is independent or linked, how children/components are handled, or any side effects of cloning.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core action and the optional parameters efficiently.

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

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

Given no annotations, no output schema, and only 25% schema description coverage, the description is too thin. It omits return behavior, required permissions, and sufficient parameter detail for an agent to invoke the tool confidently.

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

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

Schema coverage is only 25%, so the description must compensate. It mentions an optional position offset and name, which loosely covers dx/dy and name, but it does not explain dx/dy units or coordinate space, and the required nodeId parameter is completely undocumented in both schema and 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 gives a specific verb and resource: 'Create a copy of an existing node.' It does not distinguish this tool from the sibling clone_node_into_parent or explain boundary cases, but the core operation 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 guidance on when to use this tool versus alternatives such as clone_node_into_parent or create_instance_from_instance. The mention of optional offset and name implies basic cloning, but no conditions or exclusions are provided.

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

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

With no annotations, the description carries the full burden, and it does disclose a genuinely non-obvious behavioral trait: in auto-layout parents the copy joins the flow unless dx/dy are non-zero, in which case it becomes absolutely positioned. That is real beyond-schema context. It still omits whether the source node is left untouched and what the call returns, so it stops short of full disclosure.

Agents need to know what a tool does to the 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 filler, with the primary purpose front-loaded and the conditional auto-layout nuance following immediately. 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 6-param mutation tool with no annotations and no output schema, the description covers purpose, accepted container types, and the tricky auto-layout positioning case well. The main gap is the return value (e.g. the new node's id) that an agent would need to chain follow-up calls, plus interaction between index and dx/dy.

Complex tools with many parameters or behaviors need more documentation. 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 low (33%), so the description needs to compensate, and it does for dx/dy by explaining their flow-vs-absolute effect, which the bare 'number' schema does not convey. The two required params (nodeId, parentNodeId) and name/index are left to the schema, which is acceptable since name and index are already 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 specific verb (clone), resource (node) and destination (parent container), then enumerates the container types it accepts (frame, section, group, auto-layout, slot, page). This clearly separates it from clone_node (no parenting) and reparent_node/move_node (no duplication) without the agent needing to open another 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 when to reach for it (duplicating a node directly into a container) and hints at dx/dy behavior, but never explicitly says when to prefer clone_node + reparent_node or insert_child instead. Usage is inferable but not stated, which is the textbook 'implied usage' level.

Agents often have multiple tools that could apply. Explicit usage 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 discloses one useful trait ('lay them out to avoid overlap'), but for a structural mutation it omits whether source nodes are modified/destroyed, permission requirements, and failure behavior.

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

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

A single well-formed sentence with the action front-loaded and zero filler. It is appropriately sized, though it could carry more information given the tool's complexity.

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

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

For an 8-parameter mutation tool with no annotations and no output schema, the description is too thin. It neither explains the layout/placement parameters nor the return value, leaving an agent unable to invoke it confidently.

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

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

With 8 parameters at 0% schema coverage, the description must compensate but largely does not. Only 'existing component nodes' loosely maps to the required componentIds; gap, gapX, gapY, name, index, columns, and parentNodeId are entirely undocumented in both schema and 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 gives a specific verb ('Combine') and resource ('existing component nodes into a component set'), which is clearly distinguishable from the inverse sibling extract_component_set. It does not explicitly name or contrast with siblings, but the action 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 guidance on when to use this tool versus alternatives (e.g. create_component, extract_component_set) and no prerequisites stated, such as whether the input nodes must already be component variants or be selected. The agent is left to infer usage entirely.

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

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

With no annotations, the description carries the full behavioral burden and discloses useful constraints: the limited set of properties captured, inability to restore deleted nodes or structural changes, and loss of state on plugin UI reload. It omits side effects (whether creating a checkpoint mutates document state) and any return value information.

Agents need to know what a tool does to the 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 front-loaded with the snapshot action and property list, then immediately follows with limitations. The property list is long but earns its place by defining scope, and there is no filler.

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

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

The description gives strong behavioral context for a checkpoint tool but leaves important gaps: the optional label parameter is unexplained, and with no output schema the return value or checkpoint identifier is not described. It is adequate for basic invocation but incomplete for fully informed use.

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

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

Schema description coverage is 0%. The description only indirectly clarifies nodeIds ('on the given nodes') and completely omits the optional 'label' parameter, so it does not compensate for the undocumented schema.

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

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

The description states a specific verb and resource: 'Snapshot a handful of common mutable properties' on 'the given nodes.' It also names the exact property categories and distinguishes itself from restore_checkpoint and true undo, so an agent can identify its purpose without opening another tool.

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

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

It clearly links usage to later restoration with restore_checkpoint and explicitly states when not to rely on it: 'NOT true undo: it cannot restore a deleted node or undo structural changes.' However, it does not explicitly describe the workflow condition (e.g., create before applying batch edits) or name undo/redo as the alternative for structural changes.

Agents often have multiple tools that could apply. Explicit usage 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 usefully discloses auto-layout interaction behavior (coordinate and sizing delegation) that would not be obvious otherwise, but omits other behavioral facts: default placement when x/y are omitted, whether the component lands on the current page, and whether parameters like ignoreAutoLayout override the stated rules.

Agents need to know what a tool does to the 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 tightly packed sentences, front-loaded with the core action and then the conditional rules. Every clause carries actionable information 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 10-parameter mutation tool with no annotations and no output schema, the description covers the trickiest geometric/auto-layout semantics well but is not complete: it omits behavior for ignoreAutoLayout and the two layoutSizing enums, and says nothing about what is returned or where the component is placed by default.

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

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

Schema description coverage is only 20% and there are 10 parameters, so the description should compensate. It does a good job on the interaction-heavy params (parentNodeId, x/y, index, width/height) but leaves name, ignoreAutoLayout, layoutSizingVertical and layoutSizingHorizontal entirely undocumented, and never clarifies how ignoreAutoLayout relates to the 'omit x/y inside auto layout' rule.

Input schemas describe structure but not intent. Descriptions should explain 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+resource ('Create a new empty component'), and the qualifier 'empty' usefully distinguishes it from the sibling create_component_from_node, which builds a component from an existing node. It stops short of naming that sibling explicitly, so differentiation relies on 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?

Gives solid conditional guidance on how to use the tool (pass parentNodeId to insert into a frame/stack/slot; omit x/y inside auto layout; omit width/height unless fixed). However it never says when to choose this over alternatives like create_component_from_node or create_component_slot, so the when-to-use dimension 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 burden. It does not disclose whether the source node is consumed/converted in place, whether the operation is reversible (undo/checkpoint), or what permissions or preconditions apply.

Agents need to know what a tool does to the 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 or redundancy. It is efficient, though the brevity shades into under-specification rather than tight editing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, no output schema, and 0% parameter coverage, the description is the only source of behavioral and parameter information and it provides almost none. It is insufficient for a mutation-style tool with an undocumented optional parameter.

Complex tools with many parameters or behaviors need more documentation. 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 0%, so the description must compensate and largely does not. 'Existing node' loosely maps to nodeId, but the optional 'name' parameter is never explained (is it the new component's name, and what happens if omitted?).

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

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

States a specific verb ('Convert') and resource ('existing node into a main component'), so the agent knows exactly what transformation occurs. It does not, however, distinguish itself from the sibling create_component, which sounds like it produces a similar artifact.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, when-not-to-use, or alternative is stated. The sibling create_component and combine_as_variants are obvious candidates for confusion, and nothing here routes the agent between them.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral burden and does disclose the non-obvious auto-layout interaction (omit x/y, use index). However, it says nothing about what happens on invalid componentId, whether overrides carry over, or the mutation's side effects, which matters for a create 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 tight sentences, front-loaded with the core action and then the placement rules. No filler, though the sentence could be marginally denser.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8-parameter mutation tool with no annotations and no output schema, the description covers the trickiest placement semantics but leaves several parameters and all failure/return behavior unexplained. 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 only 25%, so the description must compensate. It explains parentNodeId, x/y, and index usage well, but ignoreAutoLayout and the two layoutSizing parameters go undocumented anywhere, so the compensation is partial.

Input schemas describe structure but not intent. Descriptions should explain 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+resource with a scope qualifier ('local component'), which implicitly separates it from key-based siblings like create_instance_from_component_key and create_instance_from_set_key. It stops short of naming those alternatives 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?

Gives clear conditional guidance: pass parentNodeId to insert into a frame, auto-layout stack, or slot, and inside auto layout omit x/y and use index. This is real when/how routing, though it addresses parameter combinations more than choosing this tool over a sibling.

Agents often have multiple tools that could apply. Explicit usage 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 disclose one important side effect – creation of the corresponding SLOT property – which is genuinely useful. But it says nothing about required permissions, whether the parent must already be a component variant, or what fails if componentId/componentSetId/variantComponentId are 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?

Two short, front-loaded sentences with zero filler. Efficient, though the brevity is partly the problem – it's concise at the cost of under-specification.

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

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

A 9-parameter mutation tool with zero required-parameter markers, 0% schema coverage, no annotations, and no output schema. The description explains the core action and one side effect but leaves the agent unable to know which IDs to supply or how params map to slot geometry. Inadequate for the complexity.

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

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

Nine parameters at 0% schema description coverage and no description-level explanation of any of them. The description doesn't say what x/y/width/height mean (slot placement size vs position?), how name relates to the SLOT property, or which of nodeId/componentId/componentSetId/variantComponentId is authoritative. This is the largest gap in the definition.

Input schemas describe structure but not intent. Descriptions should explain 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+resource: 'Create a slot inside a component variant.' Clear what the tool does, and siblings like edit_component_slot/delete_component_slot clarify the create-vs-edit distinction. Minor gap: 'slot' is Figma-domain jargon and the relationship to component vs componentSet is not spelled out.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, no prerequisites, no mention of how this differs from edit_component_slot or how it interacts with create_component/combine_as_variants. The side-effect note is informational, not usage guidance.

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

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

No annotations are provided, so the description carries full behavioral burden. It states mutation and local scope, but omits permissions, reversibility, overwrite behavior on update, and what happens to the effects array.

Agents need to know what a tool does to the 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 or repetition. It is concise, though its brevity comes from under-specification rather than tight information design.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 two required parameters, including an array, with no annotations and no output schema. The description supplies only a scope statement and leaves parameter and behavioral details for the agent to guess.

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

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

Schema description coverage is 0% for both required parameters. The description does not explain 'name' or the expected structure of the 'effects' array, adding no meaning beyond the raw property names.

Input schemas describe structure but not intent. Descriptions should explain 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 or update a local effect style'), clearly distinguishing it from paint, text, and grid style siblings. However, it does not differentiate create vs. update behavior or separate itself from apply_effect_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?

Provides no when-to-use guidance, prerequisites, or alternatives. An agent cannot infer when to choose this over apply_effect_style, set_effects, or updating an existing 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 and does disclose a genuinely non-obvious behavior: Figma's native white fill is cleared so containers default to transparent, plus the auto-layout sizing caveat. It omits return values, coordinate space for root frames, and permissions.

Agents need to know what a tool does to the 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-loads the create action and default-fill behavior before the conditional guidance; every sentence carries usable information. Slightly dense but no obvious 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 17-parameter creation tool with no annotations and no output schema, the description covers fills and auto-layout nesting well but leaves several parameters (r/g/b, opacity, name, keepDefaultFill semantics) and any return behavior 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 coverage is only 53%, and the description compensates by explaining fillHex, x/y, width/height, parentNodeId, index, and layoutSizing usage. However the unexplained r/g/b parameters are never addressed anywhere, leaving a real gap.

Input schemas describe structure but not intent. Descriptions should explain 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+resource ('Create a new frame') and immediately characterizes its default behavior. It doesn't explicitly differentiate from close siblings like create_rectangle, create_section, or group_nodes, so it's clear but not sibling-routing.

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

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

Gives concrete conditional guidance: pass fillHex only for visible surfaces, and omit x/y and width/height when nesting into auto layout. It doesn't name alternative tools or state exclusions, but the when-to-omit rules are actionable.

Agents often have multiple tools that could apply. Explicit usage 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. 'Create or update' signals a mutation, but it omits permissions, reversibility, whether an update overwrites existing style data, and any response behavior.

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

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

A single front-loaded sentence with no filler. Its brevity is structurally clean, though it stems partly from under-specification rather than deliberate efficiency.

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

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

For a mutation tool with two required parameters, no annotations, no output schema, and zero parameter documentation, the description is inadequate. It does not give an agent enough information to invoke the tool 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 0% and both required parameters (name, layoutGrids) are undocumented. The description does not explain expected values, format, or structure for either parameter, adding no meaning beyond the bare schema.

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

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

States a specific verb (create/update) and resource (local grid style), making the action clear. It does not explicitly differentiate itself from sibling tools like create_paint_style, apply_grid_style, or set_layout_grids, 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 no guidance on when to use this tool versus alternatives such as apply_grid_style or set_layout_grids, nor when to create versus update. Usage context must be inferred entirely by the agent.

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

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

With no annotations, the description carries the behavioral burden. It discloses a meaningful conditional behavior (auto-layout positioning requires parentNodeId+index, freeform requires x/y), which is real context. But it says nothing about what the created instance returns, permission/auth needs, or how ignoreAutoLayout and layout sizing interact.

Agents need to know what a tool does to the 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 tightly written sentences with zero filler, and the core purpose is front-loaded before the placement caveat. Efficient for the amount of information conveyed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8-parameter mutation tool with no annotations and no output schema, the description covers placement adequately but leaves auto-layout option parameters (ignoreAutoLayout, layoutSizing*) unexplained. An agent can likely call it, but with avoidable guesswork on the layout-related fields.

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

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

Coverage is only 25%, so the description must compensate, and it partially does by clarifying the intended use of parentNodeId, index, x, and y relative to parent type. The remaining four parameters (componentKey semantics, ignoreAutoLayout, layoutSizingVertical/Horizontal) are left undocumented beyond the two enum hints in the schema.

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

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

States a specific verb+resource ('create an instance from a library component key') and the placement target (inside the target frame/parent). The 'from component key' phrasing implicitly distinguishes it from siblings like create_instance_from_set_key and create_instance_from_instance, though it 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?

Gives genuinely actionable invocation guidance: use parentNodeId + index for auto-layout stacks, omit x/y unless the parent is freeform. However, it offers no guidance about when to choose this tool versus sibling instance-creation tools, so 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 supplied, so the description carries the full behavioral burden. It does disclose useful behavior (auto-layout handling, the parentId alias, index-based insertion), but is silent on permissions, whether the new node adopts overrides/slot content, and the auto-layout interaction with ignoreAutoLayout and the sizing params.

Agents need to know what a tool does to the 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, and each sentence adds distinct information. There is no redundant filler; it could be marginally tighter but nothing is wasted.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description covers the tricky placement semantics but omits the layout-sizing and ignoreAutoLayout parameters and any safety/return context. Adequate minimum, with visible 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 only 33%, so the description has to compensate, and it usefully explains parentNodeId/parentId aliasing plus the x/y-vs-index rule. It says nothing about ignoreAutoLayout or layoutSizingVertical/Horizontal (FIXED|HUG|FILL), leaving a third of the parameters undocumented in both places.

Input schemas describe structure but not intent. Descriptions should explain 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 new instance") and pins the source precisely ("whatever main component an existing instance points at"), which cleanly separates it from the sibling factories create_instance_from_component_key and create_instance_from_set_key without needing to name them.

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

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

Gives clear conditional context: pass parentNodeId/parentId to place it into a frame, stack, or slot, and omit x/y and use index inside auto layout. This is real 'how/when' guidance, but it never names an alternative tool or states exclusions, so it falls 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?

With no annotations, the description carries the full burden. It usefully discloses that the default variant is created and how placement behaves in auto-layout vs freeform parents, but it says nothing about permissions, error behavior for invalid/missing keys, mutability/reversibility, or what ignoreAutoLayout does. Moderate but incomplete 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?

Two tightly packed sentences: purpose and target first, then the placement rules. Zero filler and the most decision-relevant information is front-loaded.

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

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

For an 8-parameter mutation tool with no annotations and no output schema, the description covers the central placement decision adequately but omits prerequisites, failure modes, and any sense of the returned instance, leaving meaningful gaps for correct invocation.

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

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

Schema coverage is only 25%, so the description must compensate, and it does explain the key parameter interactions: parentNodeId + index for auto-layout and x/y only for freeform. That adds genuine meaning for four parameters the schema leaves bare, though componentSetKey format, ignoreAutoLayout, and the layoutSizing enums remain unexplained.

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

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

The description gives a specific verb and resource ('Create an instance from a library component set key') plus the target context ('inside the target frame/parent'), and the '(default variant)' qualifier implicitly separates it from create_instance_from_component_key and create_instance_from_instance. It doesn't explicitly name those siblings, so an agent must infer the distinction, but the purpose is unambiguous.

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

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

The second sentence provides real conditional guidance: use parentNodeId + index for auto-layout stacks, omit x/y unless the parent is freeform. However, it offers no help choosing between this tool and the many sibling instance-creation tools, and states no prerequisites (e.g., the set must already be imported).

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It says creation happens and that activate switches to the new page, but it omits permissions, side effects, default naming behavior, and what happens if name is omitted. It largely repeats the schema description for activate rather than adding behavioral context.

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

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

The description is two short, front-loaded sentences with no wasted words. The main action comes first, followed by the only optional behavior mentioned.

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

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

For a mutation tool with no annotations, no output schema, and 50% parameter description coverage, the description is too thin. It does not explain the purpose of name, whether the new page is named by default, or what the tool returns.

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

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

Schema description coverage is only 50%: activate is documented in the schema, while name is undocumented in both schema and description. The description repeats the activate behavior already present in the schema and adds no meaning for the name parameter, so it does not compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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 new page in the document.' It is clear enough to distinguish from delete_page, rename_page, and reorder_page, but it does not explicitly differentiate from duplicate_page or mention page scope. No sibling alternative is named.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 create_page versus siblings such as duplicate_page, set_current_page, or create_section. It only explains a parameter option for activation, which is not usage guidance for the tool selection itself.

Agents often have multiple tools that could apply. Explicit usage 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 usefully discloses upsert semantics ('create or update'), but says nothing about required permissions, what happens to an existing style of the same name, side effects, or return behavior for what is effectively a 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?

A single efficient, front-loaded sentence with no filler. It is only marginally penalized because the terseness edges into under-specification rather than pure conciseness.

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

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

For an upsert mutation with no annotations, no output schema, and 0% parameter coverage, the definition is too thin. An agent lacks the parameter formats, upsert collision behavior, and usage routing needed to invoke it correctly.

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

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

Schema description coverage is 0% with three params (hex, name, paints). The description mentions 'paint style' but adds no detail on name, hex format, or the structure of the paints array, leaving the undocumented params unexplained in both places.

Input schemas describe structure but not intent. Descriptions should explain 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+resource (create/update a local paint style), which lets an agent distinguish it from apply_fill_style (applies to a node) and set_fill_color (sets a color). However it offers no explicit contrast with the near siblings create_text_style/create_effect_style/create_grid_style or import_style_by_key.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, when-not-to-use, or alternative routing guidance. An agent cannot tell from the description whether to use this versus set_fill_color, figma_set_solid_fill, or apply_fill_style when it wants paint on a node versus a reusable 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 and does disclose a non-obvious behavioral trait: x/y are ignored inside auto layout unless ignoreAutoLayout is set, and index+layoutSizing must be used instead. It stops short of covering what happens when parentNodeId is omitted, default sizing, or the return value.

Agents need to know what a tool does to the 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 tightly written sentences, front-loaded with the action followed by the conditional layout guidance. No filler and 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 10-parameter creation tool with no annotations and no output schema, the description covers the layout nuance but omits what happens without a parent (default placement), default dimensions, and return behavior. 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 only 50%, but the description adds genuine meaning by explaining the relationship between parentNodeId, x/y, index, layoutSizing, and ignoreAutoLayout in the auto-layout system. It leaves name/width/height implicit (self-explanatory) and adds no enum detail for the layoutSizing params.

Input schemas describe structure but not intent. Descriptions should explain 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+resource ('Create a rectangle'), which is clearly distinguishable from siblings like create_frame, create_vector, or create_text. It does not explicitly name or contrast with any sibling, so it stops 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?

It explains two usage modes (freeform frames vs auto-layout/overlay) and how to insert via parentNodeId, which is real context. However, it never states when to choose this tool over alternatives such as create_vector or create_frame, so usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It says nothing about permissions, defaults for the optional fields, what coordinates/size semantics apply, whether the new section is returned or selected, or whether it is undoable.

Agents need to know what a tool does to the 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 with the core action front-loaded and no filler. It is efficiently written, though the terse style is what leaves the parameter gaps rather than compensating for them.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8-parameter mutation tool with no annotations, no output schema, and a nested object parameter, the description is far too thin. It should at minimum explain the coordinate/size semantics, the meaning of parentNodeId (including the default), and what sectionProperties accepts.

Complex tools with many parameters or behaviors need more documentation. 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 0% across 8 parameters, and the description only touches fillColor, sectionProperties, and parentNodeId. The five geometry/name parameters (x, y, name, width, height) are undocumented in both the schema and the description, leaving required-for-correct-use meaning unstated.

Input schemas describe structure but not intent. Descriptions should explain 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 SECTION node") and names the constructor-style optional fields, so an agent can immediately tell it is a creation tool. It does not differentiate itself from nearby creators such as create_frame or create_rectangle, nor from the sibling set_section_properties, 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?

There is no guidance on when to use this tool versus create_frame, create_rectangle, or set_section_properties. No prerequisites, no placement context, no mention of what happens if parentNodeId is omitted. Only implied usage from the verb.

Agents often have multiple tools that could apply. Explicit usage 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, and it does disclose non-obvious traits: default auto-width hug behavior (WIDTH_AND_HEIGHT + HUG) and the rule that fontStyle may be omitted for variable fonts. It stops short of side effects, error behavior, or what the call returns.

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

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

Purpose is front-loaded in the first sentence and each following clause adds usable detail (defaults, parent insertion, enum values, variable fonts). It is dense rather than bloated, though the parameter enumeration runs long in a single paragraph.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 20-parameter creation tool with no annotations and no output schema, the description covers the tricky parameters well but omits about half the inputs (x/y, name, fontSize, fillsHex, r/g/b) and says nothing about the returned node identity. Adequate but with clear gaps against the tool's complexity.

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

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

Schema coverage is only 40% and the schema declares zero enums, so the description meaningfully compensates by spelling out allowed values for textAlignHorizontal, textAlignVertical, textAutoResize, and layoutSizingVertical/Horizontal, plus the variationSettings format. It leaves obvious params (x/y, name, characters, fontSize, fillsHex, r/g/b) undocumented, which is why it is not 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?

The description opens with a precise verb+resource: 'Create a text node.' The resource is distinct from siblings like create_rectangle, create_frame, and set_text_content, so an agent can immediately tell which operation this is 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?

It gives clear conditional usage context — pass parentNodeId to insert into a frame/stack/slot, omit x/y inside auto layout and use index instead — but never names an alternative tool or states when NOT to use it. Solid context without explicit alternatives/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 usefully discloses upsert semantics and the variable-font interaction between variationSettings and fontStyle, but omits whether an existing style is overwritten or merged, permission/bridge requirements, and any side effects of updating a shared style.

Agents need to know what a tool does to the 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: the core action is front-loaded, followed by a targeted caveat. No filler, though the variable-font sentence is somewhat dense and could have been split.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 12-parameter mutation tool with no annotations, no output schema, and 8% schema coverage, the description is too thin. It covers purpose and one parameter nuance but leaves most inputs and all return/side-effect behavior undocumented.

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

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

Schema description coverage is only 8%, so the description must compensate for roughly 10 undocumented parameters (fills, fillsHex, fontSize, textCase, lineHeight, letterSpacing, textDecoration, paragraphSpacing, name, fontFamily). It explains variationSettings and its relationship to fontStyle, but leaves the majority of parameters with no added 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?

States a specific verb+resource ("Create or update a local text style") with a scoping qualifier ("local"). It is clear what the tool does, though it does not explicitly distinguish itself from close siblings like set_text_style, apply_text_style, or create_typography_scale.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 "create or update" phrasing implies upsert behavior, so the agent can infer it is used to author a style rather than apply one. However, there is no explicit when-to-use guidance, no mention of alternatives such as apply_text_style, 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?

With no annotations, the description carries the full burden. It does disclose meaningful behavior: the deterministic sizing formula, the default step set, and the side effect that createSampleFrame produces sample text nodes in a frame. However, it says nothing about permissions, where the scale is stored (styles vs. nodes), or what parentNodeId affects, which are significant gaps for a creation tool.

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

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

Three dense sentences, front-loaded with the core purpose and formula, followed by the optional behaviors. Parentheticals are used efficiently; only minor tightening would help.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 12-parameter, nested-object creation tool with no annotations and no output schema, the description explains the core algorithm and a few key options but leaves half the parameters and the tool's side effects incompletely covered. Adequate but not complete.

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

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

Schema description coverage is only 8% (just variationSettings), so the description must compensate. It explains baseSize and ratio via the formula, and touches steps, createSampleFrame, variationSettings, and fontStyle, but leaves prefix, fontFamily, lineHeight, lineHeightRatio, letterSpacing, and parentNodeId entirely unexplained.

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

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

States a clear verb+resource ('Create a text-style scale') and goes further by defining the underlying formula (fontSize = base * ratio^offset) and the default step names. It distinguishes itself implicitly from siblings like create_text_style/set_text_style by describing a whole generated scale rather than a single style, though it never names those 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?

Offers conditional guidance for one case ('For variable fonts, pass variationSettings and optionally omit fontStyle') and mentions the createSampleFrame option, so usage is implied for those scenarios. It gives no when-not-to-use guidance and no explicit routing against the many sibling style/text tools.

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

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

With no annotations, the description carries the full burden. It helpfully discloses that resolvedType is an enum-like set and clarifies that EASING/TIMING hold motion curves and durations, but it says nothing about mutation effects, duplicate-name behavior, required modes, scope semantics, or 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?

Two sentences, front-loaded with the action, with no filler. The trailing explanation of EASING/TIMING is slightly tangential but earns its place by documenting a value the schema never documents.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 7 parameters, nested valuesByMode/valuesByModeEntries objects, no annotations, and no output schema, the description covers only the type field. It omits how values-by-mode should be supplied, what scopes do, and what the creation side effects are, leaving an agent under-informed for 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?

Schema description coverage is 0% across 7 parameters, so the description's enumeration of resolvedType values is genuinely additive and the only documentation of that critical field. However, collectionId, name, scopes, description, valuesByMode, and valuesByModeEntries remain unexplained, so it only partially compensates for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain 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 in a collection') plus the value-setting scope ('set values by mode'), which is enough to distinguish it from create_variable_collection, set_variable_values, and rename_variable. It stops short of naming siblings explicitly, so it is clear but not maximally differentiated.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives such as set_variable_values (for populating an existing variable) or create_variable_collection (for the container itself). The phrase 'in a collection' only weakly implies a precondition that a collection must already exist.

Agents often have multiple tools that could apply. Explicit usage 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, yet it only reveals that the collection is 'local' and that modes may be named. It says nothing about persistence scope, whether duplicates are allowed, permissions required, 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 front-loaded sentence with no waste. It is efficient, though the brevity is partly a symptom of under-specification rather than disciplined editing.

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

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

For a mutation tool with no annotations, no output schema, and zero parameter documentation, the description is too thin. An agent lacks enough to call it correctly in edge cases such as naming collisions or empty modes.

Complex tools with many parameters or behaviors need more documentation. 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 0%, so the description must compensate. It only implies that 'modes' is optional and that 'name' labels the collection; it gives no format, uniqueness, or ordering semantics for either 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?

States a specific verb+resource (create a variable collection) and adds the scoping detail 'local'. It implicitly contrasts with the sibling set (list/rename/delete_variable_collection), though it does not name them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 given. The agent must infer that this is the creation step preceding create_variable_mode and create_variable from sibling names alone.

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

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

No annotations are provided, so the description carries the full burden. It is a mutating create operation but says nothing about permission requirements, whether the mode name must be unique, what happens if collectionId is invalid, or what is returned. This is a significant gap for an unannotated 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?

A single efficient sentence with the action front-loaded and zero filler. It is well-sized, though the brevity reflects under-specification rather than tight editing of rich content.

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

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

For a two-parameter mutation with no annotations, no output schema, and 0% schema description coverage, the description should cover prerequisites, uniqueness, and error behavior. As written it is too thin to fully guide a correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only loosely implies the two params ('mode' -> name, 'variable collection' -> collectionId) and gives no format, id type, or naming constraints. It adds marginal meaning over the bare 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 gives a specific verb+resource ('Add a new mode') and its container ('to a variable collection'), so the agent knows exactly what is created. It does not distinguish this from siblings like set_variable_mode, rename_variable_mode, or delete_variable_mode, so it falls short of 5.

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

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

There is no statement of when to use this versus the sibling mode tools (set/rename/delete_variable_mode) or versus create_variable_collection. No prerequisites are given, such as requiring an existing collection. The agent must infer usage entirely.

Agents often have multiple tools that could apply. Explicit usage 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 the tool creates a node but does not disclose what is returned (e.g. the new node id), where the node lands when parentNodeId is omitted, whether the operation is undoable, or any permission requirements. For a creation/mutation tool 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?

Three short, front-loaded sentences with no filler; the core action leads and the parameter hints follow. Efficient, though the parameter list reads as a compressed inventory rather than explanatory prose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, no output schema, and zero schema-level parameter descriptions for an 8-parameter mutation tool, the description is too thin. It omits return behavior, default placement behavior, and parameter semantics that an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It names most parameters (vectorPaths, fills, strokes, strokeWeight, parentNodeId, x, y) and shows the vectorPaths item shape, but adds no meaning beyond names and structure — no units, formats, defaults, or relationships between fills/strokes and strokeWeight.

Input schemas describe structure but not intent. Descriptions should explain 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 VECTOR node from SVG path data — which is concrete enough to distinguish it from neighbors like set_vector_paths or create_rectangle. It does not explicitly name a sibling or clarify how it differs from set_vector_paths, 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?

There is no when-to-use guidance, no prerequisites, and no mention of the alternative set_vector_paths for editing existing vectors. The agent must infer usage entirely from the verb.

Agents often have multiple tools that could apply. Explicit usage 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 correctly discloses the destructive nature and the authentication requirement (FIGMA_TOKEN, REST API), which is real added value, but says nothing about irreversibility, whether threaded replies are also removed, or required permissions beyond the token.

Agents need to know what a tool does to the 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 filler; the destructive action and the auth prerequisite are both delivered compactly.

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

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

For a simple two-parameter delete with no output schema, the description covers the action and auth need, which is close to sufficient. It falls short on parameter meaning and on consequences of deletion, both of which an agent would want before calling a destructive 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 0% for both required parameters, so the description must compensate and does not – it never explains what fileKey or commentId are or their expected format. Only the implied file/comment context of the verb gives any hint.

Input schemas describe structure but not intent. Descriptions should explain 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 (a comment in a Figma file), which cleanly separates it from sibling post_comment and list_comments. It adds transport context (REST API) but never explicitly names or contrasts with 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?

Usage is implied by the verb – an agent can infer you call this when you want a comment removed – but there is no explicit when-to-use statement, no exclusions, and no mention of alternatives such as editing a comment instead. The FIGMA_TOKEN note is a prerequisite, not routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states a mutation ('Delete') but does not disclose whether deletion is reversible, what permissions are required, or what happens if the property is bound or in use.

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

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

Single front-loaded sentence with no filler. Every word contributes to stating 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?

For a destructive 5-parameter tool with no annotations and no output schema, the description is too sparse. It omits parameter semantics, safety/behavioral context, and usage guidance, leaving the agent under-informed for correct invocation.

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

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

Schema description coverage is 0% for 5 parameters. The description only vaguely references the property ('component property') and the target ('component or component set'), leaving nodeId, preferComponentSet, and the distinction between componentId and componentSetId unexplained.

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

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

States a specific verb (Delete) and resource (component property), and clarifies the target (component or component set). This distinguishes it from siblings like add_component_property, edit_component_property, and bind_component_property by action.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, alternatives, or prerequisites are provided. The usage is only implied by the verb 'Delete'; it does not mention edit_component_property or bind_component_property as alternatives, nor when a property should be deleted versus unbound.

Agents often have multiple tools that could apply. Explicit usage 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 disclose a genuine destructive side effect: content placed in instances of the slot is discarded. That is exactly the kind of impact an agent needs on a delete tool. It stops short of stating irreversibility, permissions, or related cleanup, so it is 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?

Two tight sentences, front-loaded with the primary action and followed by the consequential side effect. No filler, no repetition of the tool name.

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

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

For a one-parameter destructive tool with no annotations and no output schema, the description covers the action and its most important consequence (discarded slot content). Minor gaps remain around reversibility and permission requirements, preventing a 5.

Complex tools with many parameters or behaviors need more documentation. 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 a single parameter with 0% schema description coverage. The description implies slotNodeId identifies the SLOT node being removed, which adds modest meaning, but it never defines the parameter explicitly or its expected format.

Input schemas describe structure but not intent. Descriptions should explain 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+resource pair ('Remove a SLOT node from a component') and adds the secondary effect ('delete its corresponding SLOT property'), leaving no ambiguity about what is being deleted. It does not explicitly name a sibling to differentiate from (e.g., delete_node, edit_component_slot), which keeps it at a 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?

Usage is only implied by the operation itself; there is no statement of when to use this versus delete_node, edit_component_slot, or other slot tools, and no prerequisites are given. The scope ('from a component') offers mild context but no explicit routing guidance.

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

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

With no annotations, the description carries the full behavioral burden. It discloses two useful traits: the target-frame scoping restriction and the guard requiring confirmFrameOrPageDeletion for pages/top-level frames. It omits irreversibility, child-node handling, and undo/checkpoint behavior, which matter for a destructive bulk 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?

Two tight sentences, front-loaded with the primary action and followed by the exception condition. 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 two-parameter destructive tool with no annotations and no output schema, the description covers scope and the confirmation guard but leaves out reversibility, partial-failure behavior, and the outcome/return. 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 50%: confirmFrameOrPageDeletion is documented in the schema, but nodeIds is undocumented. The description partially compensates by describing nodeIds as the deletion targets and noting the target-frame restriction, but adds no format detail (e.g., must all be in the same frame) beyond that.

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

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

The description states a specific verb and resource ('Delete multiple nodes by nodeIds'), and the plural 'multiple' implicitly distinguishes it from the sibling delete_node. It does not explicitly name delete_node or delete_page as alternatives, so an agent must infer the routing, but the core purpose is unambiguous.

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

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

It gives one usage constraint ('only within the allowed target frame') and a conditional prerequisite for pages/top-level frames, which is genuine context. However, it never says when to prefer this over delete_node or delete_page, nor what to do if a nodeId falls outside the target 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 exist, so the description carries the full behavioral burden. It usefully discloses the target-frame scope constraint and the confirm requirement for pages/frames, but says nothing about reversibility (undo/checkpoints exist), child-node handling, or permission requirements expected of a destructive 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?

Two tight sentences, zero waste, with the primary action stated first and the guard condition second. Appropriately sized for the tool's complexity.

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

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

For a destructive tool with no annotations and no output schema, the description covers the confirm requirement and scope, which is the minimum viable. It omits consequences (child deletion), reversibility, and failure modes that an agent would need to invoke this safely.

Complex tools with many parameters or behaviors need more documentation. 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 50%: confirmFrameOrPageDeletion is already documented in the schema, while nodeId has no description anywhere. The description repeats the confirm semantics and adds the target-frame scope, but never clarifies nodeId format or provenance, so it only partially compensates for the gap.

Input schemas describe structure but not intent. Descriptions should explain 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 (delete a node) plus the identifying key (nodeId), so the agent knows exactly what the tool does. It does not distinguish itself from close siblings like delete_multiple_nodes or delete_page, which the definition could have named.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'only within the allowed target frame' implies a scope precondition, and the confirm flag hints at a guarded path, but there is no explicit when-to-use vs alternatives guidance toward delete_multiple_nodes or delete_page. Usage 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 does disclose the confirmDelete safety gate, which is genuine behavioral information beyond the schema's boolean type, but it never states whether deletion is irreversible, what happens to child nodes, or whether undo can revert it.

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

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

Two short sentences with the constraint front-loaded after the action. No filler, and the mandatory flag is surfaced before the agent reads the 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 destructive tool with no annotations and no output schema, the definition covers the action and the confirmation flag but omits reversibility, side effects on child content, and failure modes. Adequate to invoke, thin on consequence.

Complex tools with many parameters or behaviors need more documentation. 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 0%, so the description must compensate for two bare parameters. It explains confirmDelete's required value, adding real meaning, but pageId is left as an unexplained string with no mention of format, source, or how to obtain it.

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

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

States a specific verb and resource ('Delete a page'), and names the identifier parameter, so the action is unambiguous. It does not differentiate itself from adjacent destructive siblings such as delete_node, delete_multiple_nodes, or delete_variable, which is the only real gap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 implicitly conveys a prerequisite ('Requires confirmDelete=true'), which tells the agent it cannot be called casually. However, it offers no when-to-use context relative to alternatives like delete_node or undo, and no guidance on whether deletion is recoverable.

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