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

With no annotations, the description must disclose behavior. It only states the action ('link multiple transitions') without addressing critical aspects such as atomicity (does the whole batch succeed or fail as one?), error handling, whether existing links are replaced, or what the response looks like. For a mutating batch operation, 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?

A single sentence with an illustrative parenthetical, front-loaded with the core action. Zero wasted words.

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

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

This is a batch operation with nested object parameters and no output schema or annotations. The description fails to explain batch-specific behaviors (rollback, partial success, response format) or how it relates to single-link tools. An agent would lack critical information for correct invocation and error handling.

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 reported at 100%, and the schema already defines the links array structure, enums, and descriptions for sourceId and destinationId. The description adds only the phrase 'Array of prototype links to establish,' which is minimal and provides no extra meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a clear verb ('Link'), a specific resource ('multiple prototype transitions'), and provides a concrete example ('wiring up an entire user journey'). It naturally distinguishes itself from sibling tool set_prototype_interaction, which handles single transitions.

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 batch usage through the example but does not explicitly contrast with set_prototype_interaction or state when not to use it. No explicit alternatives or exclusions are mentioned, leaving the agent to infer based on the name and example.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a mutation (create/convert) but does not state what happens to the original node when converting—whether it is modified, replaced, or left intact—nor does it mention reversibility or side effects. For a mutation tool with no annotation coverage, this is a significant gap.

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

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

A single, efficient sentence that front-loads the core purpose and immediately offers the alternative conversion mode. There is zero filler; every word contributes to comprehension.

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

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

For a tool with nine parameters, one required, and no output schema or annotations, the description is under-specified. It doesn't explain how parameters interact (e.g., whether fromNodeId supersedes x/y), what the return value is, or any prerequisites for conversion. An agent cannot fully determine correct invocation without more detail about the conversion mode's behavior and parameter relationships.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters. The description adds the conceptual context of 'master' and the conversion mode, which indirectly clarifies fromNodeId and the creation path, but it does not add per-parameter meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting and the description adds only marginal value.

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

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

The description states a specific verb-resource pair ('Create a reusable Figma component master') and adds an alternative mode ('convert an existing frame/node into a component'). It clearly distinguishes from siblings like create_component_instance (instance vs master) and create_frame (generic frame), giving an agent immediate orientation.

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

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

It provides clear context on when to use the tool: to create a master component or convert an existing node. However, it does not explicitly mention when not to use it (e.g., for creating instances) or name alternatives such as create_component_instance. The sibling differentiation is implied by the word 'master' but not spelled out, leaving some room for misrouting.

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 does disclose one useful trait: the instance retains a link to the main component. However, it does not mention side effects, coordinate defaults, parent placement behavior, or what happens if the componentId is invalid.

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

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

A single, front-loaded sentence that conveys the core action and key behavioral nuance with no filler. It is appropriately concise for the tool's simplicity.

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

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

The schema fully documents parameters, and the description is sufficient for a simple creation call. Still, with no annotations, no output schema, and no usage guidance, an agent gets only minimal context about expected behavior, placement defaults, or return value.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds little beyond reinforcing that componentId refers to a master component; this meets the baseline but does not enrich parameter meaning further.

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

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

The description uses a specific verb ('Instantiate') and resource ('reusable component instance'), and clearly distinguishes this from master-component creation by mentioning 'master component ID' and 'retaining link to the main component'. An agent can tell this apart from sibling tools like create_component.

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

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

The usage is implied: you use this when you have a master component ID and want a linked instance. However, it does not explicitly state when not to use it or mention alternatives such as create_component for creating a new master component.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it creates a node on the canvas, which is the core action, but does not mention side effects (e.g., selection changes, undo behavior), prerequisites, permissions, or what happens if required parameters are missing. This is minimal for a mutation tool without annotation support.

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

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

The description is a single, front-loaded sentence that states the purpose immediately and appends a concise list of use cases. Every word contributes, with no fluff 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?

Given the schema fully documents parameters and there is no output schema, the description adequately explains the tool's purpose. However, it lacks any mention of return values, error behavior, or what happens after creation (e.g., node selection), which would make it more complete for an agent to safely invoke.

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

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

The schema provides 100% description coverage for all 8 parameters, so the baseline is 3. The description adds a subtle hint about circular shape (width=height) and typical uses, but does not materially enhance understanding of the parameters beyond the schema, so it stays at baseline.

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

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

The description clearly states the action ('Create'), the resource ('ellipse or circular shape node'), and the location ('on the canvas'), and differentiates it from siblings like create_rectangle by emphasizing the circular/elliptical shape and typical use cases (avatars, status badges, circular buttons, indicator dots).

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

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

The description provides explicit use cases ('ideal for user avatars, status badges, circular buttons, and indicator dots'), which tells the agent when to select this tool over alternatives. However, it does not explicitly name alternatives or state when not to use it, so it falls short of full 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 provided, the description must carry full burden. It explicitly states that the tool creates a new frame, which implies mutation. While it does not detail permission requirements or side effects, the absence of such context is common for create operations. It adds value by clarifying that it can be a container or artboard. However, it lacks details on canvas placement behavior, which might be inferred from parameters.

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

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

The description is a single sentence, concise and front-loaded with the core action and resource. It includes a clarifying parenthetical that adds specificity without waste. Every word earns its place.

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

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

Given the tool has 8 optional parameters but no required ones, the description gives a general sense of what it does but doesn't explain when some parameters are needed (e.g., name, fill, cornerRadius). However, with a 100% schema coverage and no output schema, the description covers the essential context. It could be more complete by explaining common usage patterns, but it is adequate for a create operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters with descriptions. The tool description itself does not add semantic meaning beyond what's in the schema. Since coverage is high, a baseline of 3 is appropriate. The description does not clarify parameter relationships or dependencies, but the schema covers each parameter's purpose.

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

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

The description clearly states the verb 'Create' and the resource 'frame', and elaborates with 'container or artboard' and 'on the Figma canvas'. This distinguishes it from sibling tools like create_rectangle, create_text, or create_section, making the purpose unambiguous.

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

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

The description does not explicitly mention when not to use this tool or name alternatives. However, the context is clear: it is for creating frames as containers or artboards, which implies usage for layout structure. Sibling tools like create_component or create_component_instance have different purposes, but no explicit exclusion is provided. This is a clear but not exhaustive guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the creation intent and does not disclose where the node is placed, whether it has default visual properties, coordinate-system expectations, or what response to expect. 'Create' implies mutation but little else is transparent.

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

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

The description is one concise sentence with no filler, and the primary action is front-loaded. The parenthetical use-case context is short but useful, making the description appropriately sized and well-structured.

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

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

The input schema covers all parameters, but with no annotations and no output schema, the description alone does not fully communicate behavioral context such as insertion point or side effects. It is adequate for a straightforward creation tool but leaves some gaps around expected behavior and differentiation from sibling creation tools.

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

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

Schema description coverage is 100%, so the input schema already documents all 8 parameters with meaningful descriptions. The tool description adds no parameter-level information, but the schema is sufficient, warranting the baseline score of 3.

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

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

The description names the verb and resource clearly: 'Create a rectangle or box element'. It also gives concrete use cases ('cards, buttons, visual dividers'), which helps distinguish it from shape siblings like create_ellipse and create_svg_icon. However, it does not explicitly contrast with create_frame, which could overlap semantically with 'box element'.

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 intended usage through examples ('useful for cards, buttons, visual dividers'), but it does not state when to choose this tool over alternatives or when not to use it. No exclusion criteria or sibling routing is provided, so the agent must infer selection from the tool name and sibling context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create a Figma Section' and gives a purpose; it does not mention side effects, whether it mutates the canvas, how childNodeIds affect existing nodes, coordinate defaults, or any prerequisites. For a creation tool with no annotation coverage, this is a meaningful gap.

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

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

The description is a single, efficient sentence with no filler. It front-loads the verb and resource ('Create a Figma Section') and immediately follows with the purpose, making it easy to scan.

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 7 parameters, no annotations, and no output schema, the description is too thin to be fully self-sufficient. It does not explain how a Section differs behaviorally from a Frame, how childNodeIds populate the section, or what happens when x/y are omitted. The schema covers parameter definitions but not the operational context needed 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 100%, with each of the 7 parameters individually described (e.g., 'Optional array of frame/node IDs to place inside this section'). The description itself adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description states a specific verb and resource ('Create a Figma Section') and gives a concrete purpose: 'to organize related artboards, user journeys, or screen flows on the canvas.' This clearly distinguishes it from sibling creation tools like create_frame, create_rectangle, or create_component by naming the object type and its organizational role.

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

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

The description offers a clear context for use: when you want to organize related artboards, user journeys, or screen flows. It does not explicitly name alternatives or state when not to use this tool, but the stated purpose is sufficient for an agent to select it over generic frame/rectangle creation in most cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description says 'Render and insert' implying a mutating operation, but it does not disclose whether it replaces existing content, whether it requires a selected parent, or what happens on the canvas (e.g., does it create a new frame or overlay?). It omits potential side effects like resizing or default positioning. This is a gap for a mutation tool without annotation support.

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

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

The description is a single sentence that is efficient and front-loaded with the primary action. It clearly states the resource and destination without redundancy. It could be slightly more structured to mention key parameters, but it is concise and not verbose.

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

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

Given the tool has 8 parameters with full schema coverage and no output schema, the description is somewhat minimal. It does not explain the default behavior for x/y when not provided, whether the SVG auto-fits to given dimensions, or how the fill option interacts with multi-path SVGs. While the schema documents each parameter, an agent might need more operational context to use the tool correctly in a complex design environment. The description is 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?

The schema description coverage is 100%, so all parameters are documented in the schema itself. The description adds context on the purpose (scalable vector graphics) but does not elaborate on parameter semantics beyond what schema already provides. For instance, the 'svg' parameter is clear as raw XML, but the description does not clarify the relationship between width/height and the SVG's intrinsic size. Since coverage is high, baseline 3 is appropriate.

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

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

The description clearly states a specific verb ('Render and insert'), a resource ('scalable SVG vector graphics'), and the destination ('onto the canvas'). It distinguishes from siblings like create_frame, create_rectangle, and create_ellipse by focusing on SVG content rather than basic shapes. However, it could be more explicit about the output being an icon/frame, but the tool name helps.

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

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

The description implies usage (rendering SVGs into the canvas) but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. Sibling tools like create_frame or create_component_instance exist, but no exclusionary language is given. The purpose is clear enough that an agent can infer appropriate usage, but it lacks explicit routing.

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?

Although no annotations are present, the description discloses a consequential side effect: leading and letter-spacing are automatically computed and applied based on typographic hierarchy, so callers know they cannot control those values independently. It also states the emoji restriction as a hard behavioral constraint. It does not mention return values or selection effects, but the disclosed behavior goes well beyond what the schema alone would communicate.

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, all dense with information: purpose/placement, hard constraint and alternative, and automatic typography behavior. No filler, no repetition of schema properties, and the most important scoping constraint 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 a 9-parameter create operation with no annotations and no output schema, the description is nearly complete: it covers placement, the emoji edge case, and the automatic styling behavior. The main residual gaps are return/created-node semantics and error behavior for violations, but the fully-described schema covers the remaining parameter details.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters; the baseline is therefore 3. The description adds useful semantic context for text (no emojis) and implies that fontSize and fontFamily participate in automatic leading/tracking, but it does not add per-parameter meaning beyond the schema.

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

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

The description uses a specific verb-resource pair — 'Create a styled text element' — and specifies placement ('on the Figma canvas or inside a container'). It also differentiates itself from the sibling create_svg_icon by explicitly reserving vector icons/emojis for that 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 gives explicit when-not guidance: emojis are strictly disallowed, and create_svg_icon is named as the alternative for vector icons. The placement context (canvas or container) also clarifies the intended invocation scope, so there is no ambiguity about when this tool should be chosen over its icon-oriented 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 must carry the safety burden. It does state the destructive action, but it does not disclose whether deletion is permanent, whether child/descendant nodes are also removed, or whether any permissions are required.

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

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

A single sentence with no filler that front-loads the action, object, and input. Every phrase 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 one-parameter tool with a fully documented schema, the basics are covered. But because this is a destructive operation with no annotations and no output schema, the description should also note irreversibility or cascading deletion to be fully context-complete.

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

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

Schema description coverage is 100% and the schema already documents nodeIds as 'Array of node IDs to remove'. The description only reinforces this with 'by their IDs', adding no extra format, constraints, or usage nuance.

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

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

Description uses a specific verb ('Delete'), a clear resource ('nodes from the Figma canvas'), and a precise selection method ('by their IDs'). This unambiguously distinguishes it from sibling node tools like create_node, update_node, and duplicate_node without needing to open the schema.

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

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

The behavior implies it is the right tool whenever nodes need to be removed, and no sibling tool offers deletion. However, it does not explicitly state when to use it over alternatives or mention exclusions, such as whether protected or frame nodes behave differently.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and a use case; it does not mention whether the duplicate includes child elements, how the offset parameters affect placement, permissions required, or any return value. For a mutation tool without annotation support, this is a significant gap.

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

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

The description is a single sentence, front-loaded with the primary action and resource, followed by a brief example. There is no redundant information or wasted words. It is concise and well-structured for quick scanning.

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 four parameters and no output schema. While the schema documents parameters, the description does not explain what the tool returns (e.g., the new node's ID) or any side effects beyond duplication. For a mutation operation, this missing return information reduces completeness, though the core operation is straightforward.

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

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

The input schema provides descriptions for all four parameters (100% coverage), so the schema already documents parameter meanings. The description does not add extra detail beyond the schema—it mentions 'node or screen' but does not elaborate on name, offsetX, or offsetY. Baseline of 3 is appropriate since the schema captures the semantics.

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

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

The description states a clear verb ('duplicate') and resource ('node or screen'), and provides an example use case ('creating variant states for prototyping'). This clearly distinguishes the operation from sibling creation tools like create_frame or create_rectangle, since the focus is on copying an existing element rather than creating new ones.

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

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

The description gives a specific context for use ('for creating variant states for prototyping'), which tells the agent when this tool is appropriate. It does not explicitly compare with alternatives or state exclusions, but the example provides enough guidance to select this tool over others. The absence of explicit 'instead of' phrasing keeps it from 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 provided, the description must disclose behavioral aspects. It only mentions the return format and defaults for scale, but doesn't state safety (read-only vs destructive), permission requirements, or error behavior on invalid node IDs.

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

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

One sentence, front-loaded with action and output, no filler. Every word earns its place.

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

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

For a simple export tool, it mentions return format and scale default, but lacks details on error handling or prerequisites like whether the node must be selected.

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

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

The schema already covers both parameters with descriptions, and the description adds that nodeId likely refers to a frame or component, adding useful context.

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

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

The description clearly states the action (render a PNG snapshot), the target (frame or component), and the output format (base64 data URI). It distinguishes itself from siblings by its focus on rendering, though it doesn't explicitly name a sibling alternative.

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

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

The phrase 'for visual feedback' implies when to use it, but it doesn't provide explicit guidance on when not to use it or mention alternative tools like rest_get_images for image fetching.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Search' implies a non-destructive read operation and the description adds the useful 'current page' scope. It does not disclose return shape, pagination, or ordering, but those are not critical for a simple search tool.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the tool's essence, scope, and filtering criteria in under 20 words, which is ideal for a simple search tool.

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

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

For a low-complexity tool with no required parameters and fully documented inputs, the description is adequate. It clearly identifies the search scope and criteria, though it could mention the limit default explicitly even though the schema already does.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description reinforces that query maps to the name keyword and type maps to the node type filter, but does not add meaningful semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific action ('Search for nodes on the current page') and specifies the two filtering dimensions: name keyword and node type. It is clear and technically distinct from siblings like get_selection or inspect_node, though it does not explicitly name or contrast any sibling.

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 context is implied by the purpose: an agent would use this when it needs to locate nodes by name or type on the current page. However, there is no explicit guidance about when to choose this over related tools like inspect_node, get_design_context, or generate_ui_tree.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose one important side effect beyond pan/zoom: 'with optional selection'. However, it doesn't mention whether the viewport change is instant or animated, whether nodeIds must be currently rendered, or whether this operation mutates any persistent state. For a viewport-focused tool, the behavior is reasonably clear but not deeply transparent.

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

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

The description is a single, tightly worded sentence that starts with the core action and ends with the optional modifier. Every word contributes meaning, and there is no redundancy or filler.

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

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

For a simple two-parameter tool, the description provides enough to invoke it: what it does and what parameters are involved. However, it does not specify what the tool returns (no output schema), nor does it clarify behavior with multiple nodeIds or whether the viewport change is persistent. Given the large sibling set and lack of usage guidance, the context is adequate but not fully complete.

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

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

Schema description coverage is 100%: nodeIds is described as 'Array of node IDs to focus and zoom into' and select as 'Whether to also select the nodes (default: true)'. The description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate. It doesn't clarify edge cases like multiple nodeIds or invalid IDs.

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

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

The description clearly states a specific action ('Pan and zoom the Figma canvas viewport') with a clear purpose ('to focus on specific nodes'). This distinguishes it from many siblings like get_selection or find_nodes, which involve querying rather than viewport manipulation. It doesn't explicitly name a sibling or contrast itself, but the verb-resource pairing 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 phrase 'to focus on specific nodes' implies the primary use case: when an agent needs to bring certain nodes into view. However, it gives no explicit guidance about when not to use this tool, nor does it reference alternative siblings or side effects like how it relates to selection tools. The usage is implied but not directly 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 discloses that the tool enforces standards (no emojis, 8pt grid, 44px touch targets, typography calibration) and operates atomically, which is useful. However, it doesn't state whether it creates nodes in the current document, what it returns, or error behavior.

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

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

The description is a single dense sentence that front-loads the purpose and then lists enforcement rules. It's efficient, and while the enumeration of standards adds length, each element contributes meaningful constraint 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?

There is no output schema, yet the description doesn't mention what the tool returns (e.g., node IDs, hierarchy map, success status) or whether it commits to the Figma document. Given the complexity and one nested parameter, this is a notable omission; input constraints are well-covered but downstream effects are not.

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

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

The schema already describes the spec object in detail at 100% coverage. The description adds behavioral constraints on how the spec will be interpreted (spacing snapping, target sizes, typography) and reiterates the no-emoji rule, providing value beyond the schema's structural 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 and resource: 'Generate a complete UI screen or component hierarchy in a single atomic pass from a structured JSON specification.' This clearly distinguishes it from siblings like create_frame and create_component by emphasizing whole-hierarchy generation from a spec.

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 mentions 'use create_svg_icon for icons' but does not explicitly state when to use this tool versus other creation tools like create_frame or create_component. The 'single atomic pass' phrasing implies batch use, but there is no when-not guidance or alternative routing beyond the icon case.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It states the output is a token-efficient semantic outline and explicitly says it avoids heavy vector noise, which are useful behavioral traits. It does not mention side effects, prerequisites, auth needs, or response shape, but 'retrieve' implies a read operation and this is a low-risk getter.

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

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

The description is one front-loaded sentence with no fluff, and the parenthetical list of outline contents is useful. 'Token-efficient' and 'without heavy vector noise' are slightly redundant, but the overall length is appropriate.

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

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

For a single-optional-parameter read tool, the description conveys the main use and parameter semantics. However, with no output schema and no annotations, it omits the exact return shape and fails to provide sibling differentiation, leaving some ambiguity for an agent deciding between similar inspection tools.

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

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

Schema coverage is 100% for the single optional screenId parameter, and the description aligns with the schema by describing screen-level inspection versus the whole page. The description does not add much beyond the schema, but with full coverage the baseline 3 is appropriate.

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

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

The description names a specific operation ('retrieve a token-efficient semantic outline') and a concrete resource scope (active document page or a specific screen), and it enumerates outline contents such as screens, buttons, cards, inputs, and flow starting points. It does not explicitly contrast with sibling tools like get_selection, inspect_node, or generate_ui_tree, so it misses the top differentiation bar.

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

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

The description implies the tool is for lightweight semantic exploration ('without heavy vector noise') but gives no explicit when-to-use guidance, exclusions, or named alternatives. With many sibling navigation/inspection tools present, an agent cannot tell when to choose this over generate_ui_tree or inspect_node.

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

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

Annotations are absent, so the description carries the disclosure burden. 'Retrieve' signals a read-only operation and the description identifies state-dependent data (current page, selected nodes), but it does not mention prerequisites, error behavior, or the absence of 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?

A single 14-word sentence with no fluff, front-loaded with the verb and resource, followed by a compact list of the returned items. Every word earns its place.

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

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

For a zero-parameter getter with no output schema, the description lists the expected return payload names (name, pages, current page, selected nodes). It does not specify the shape of pages or selection nodes, but the omission is minor for an agent deciding whether to call the tool.

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

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

The tool has zero parameters, which sets the baseline at 4. The description correctly has nothing to add about invocation inputs.

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

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

Description states a specific verb (Retrieve) and resource (active Figma document), enumerating the returned data: name, all pages, current page, and selected nodes. It doesn't explicitly name sibling tools, but the combination of data elements distinguishes it from narrower siblings like get_selection.

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

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

There is no guidance on when to use this tool versus alternatives such as get_selection or get_design_context. The description only lists outputs, so an agent must infer the use case from the resource scope; no when/when-not 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It says 'Extract', which implies a read-only operation, but it does not explicitly state that it does not modify the document, nor does it describe the return structure or any limitations (e.g., only local tokens, not remote). The disclosure is minimal and leaves important behavioral traits unstated.

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

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

The description is a single concise sentence with the primary action front-loaded ('Extract active design tokens') and the enumeration in parentheses. Every word earns its place; there is no redundancy or filler.

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

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

While it specifies the token types (paint, text, effect), it does not describe the return format (e.g., is it an array of objects? What fields per token?) or whether tokens beyond the listed types are excluded. Given no output schema, a bit more detail about the output structure would improve completeness, but the essential purpose is clear for a simple extraction tool.

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

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

The tool has zero parameters, so there is no parameter schema to enrich. According to the rubric, a parameter-free tool gets a baseline of 4. The description clarifies the scope of the output (token types), which indirectly helps an agent know what to expect, fully meeting the expectation for tools without parameters.

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

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

The description uses the specific verb 'Extract' with resource 'active design tokens from the document' and enumerates the token types (paint, text, effect), which clearly distinguishes it from sibling tools like 'get_document_info' or 'get_selection'. A generic alternative would be 'Retrieve tokens', but this is precise and informative.

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

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

No guidance on when to use this tool versus alternatives, and no mention of scenarios where it is preferred. It simply states the function without contextual usage cues (e.g., 'Use when you need design tokens before editing styles'), so an agent has to infer the appropriate call context from the purpose alone.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool checks connection status and retrieves metadata, which implies a read-only operation. However, it doesn't describe what 'active document metadata' includes, whether it can fail (e.g., if plugin not connected), or any side effects. It's adequate but not rich.

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

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

One sentence, front-loaded with the primary purpose ('Check whether... connected') and secondary purpose ('get active document metadata'). No wasted words.

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

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

For a zero-parameter status-check tool, the description is mostly complete. However, it doesn't specify what the output looks like (no output schema) or what 'active document metadata' contains. Given the tool's simplicity, this is a minor gap, but the lack of output details and failure behavior keeps it from being a 4.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds meaning by explaining what the tool does with no inputs. Baseline 4 for 0 params is appropriate.

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

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

The description states a specific verb ('Check') and resource ('Figma Desktop companion plugin connection status') plus 'active document metadata'. It clearly distinguishes from siblings like ping_figma (which likely just pings) and get_document_info (which likely gets document info), though it doesn't explicitly 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?

The description implies usage: check this tool when you need to know if the Figma Desktop companion plugin is connected and to get active document metadata. It doesn't explicitly state when to use this over ping_figma or get_document_info, but the context is reasonably clear given the sibling names.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation but does not explicitly state side effects, authentication requirements, rate limits, or the structure of the returned data. It also fails to mention whether the tool returns a list, a map, or any other format.

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

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

The description is a single, focused sentence with no filler. The core purpose is front-loaded and every word contributes to meaning, making it efficient and easy to parse.

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

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

The description is adequate for a simple read-only tool with no parameters, but it omits the return value entirely. Since there is no output schema, the description should indicate what the agent can expect as a result. This leaves a notable gap for an agent deciding whether the tool meets its needs.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. Per the rubric, a baseline of 4 is appropriate when there are no parameters, and the description does not need to explain any parameter semantics.

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

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

The description clearly states a specific verb ('Inspect') and a concrete resource ('all flow starting points and interactive prototype wiring') scoped to 'the current page'. This distinguishes it from sibling setters like set_flow_starting_point and set_prototype_interaction, which modify rather than inspect.

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 explicit guidance on when to use this tool versus alternatives. It does not mention that this is for reading while other tools are for writing, nor does it suggest any conditions or exclusions. An agent must infer usage purely from the verb 'Inspect'.

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

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

There are no annotations, so the description must carry behavioral disclosure. 'Inspect' and 'currently selected' imply a non-mutating, state-dependent read, which is useful, but it does not explain behavior when no selection exists or whether an active Figma canvas is required.

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 focused sentence with no filler or redundancy. It front-loads the verb and resource 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?

For a simple 0-parameter read tool, the description is mostly adequate, but without an output schema it does not state the return shape or the empty-selection case. An agent would likely call it correctly but may not know exactly what to expect back.

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

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

The input schema has zero parameters and 100% schema coverage, so no parameter documentation is needed. The rubric's baseline for 0-parameter tools is 4, and the description adds no confusing parameter claims.

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 operation ('Inspect') on a specific resource ('currently selected elements on the Figma canvas'). It is unambiguous about what the tool does, though it does not explicitly distinguish itself from siblings like inspect_node or get_design_context.

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

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

The description gives no guidance on when to prefer this tool over alternatives or when not to use it. It only states what it does, leaving selection vs. inspect_node/get_design_context to inference.

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

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

With no annotations provided, the description must carry the behavioral burden. The verb 'Inspect' strongly implies a read-only operation, and the listed content (layout, dimensions, children) hints at the return scope. However, it does not disclose behavior such as the meaning of maxDepth, handling of invalid node IDs, or whether a subtree is fully traversed—important details for an agent invoking the 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, tightly packed sentence with no filler. The action is front-loaded, and every phrase earns its place by naming the inspected content. This is appropriately sized for the tool's simplicity.

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

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

The description covers the core purpose and the main output categories, and the schema fills in parameter details like maxDepth's default. Still, it could be more complete by mentioning that maxDepth controls how deep children are inspected, which is a meaningful behavioral detail for a tool without annotations or an output schema.

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

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

Schema description coverage is 100% for both parameters, so the schema already documents nodeId and maxDepth. The description adds no new parameter-specific meaning beyond what the schema states; it only reaffirms that inspection is by ID.

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

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

The description uses a specific verb ('Inspect') and names the exact resource ('any node') plus the attributes covered (properties, layout settings, dimensions, children). This clearly conveys the tool's scope, though it does not explicitly distinguish itself from siblings like get_selection or find_nodes.

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

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

The description implies usage when a node ID is available and detailed node information is needed, but it gives no explicit guidance on when to choose this over sibling tools such as get_selection, find_nodes, or get_design_context. There are no exclusions or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal what the audit checks (touch targets, grid spacing, typography, emojis) and that it produces a score, but it does not state whether the operation is read-only, what the score represents, or how results are returned. The core behavior is clear, but key details about output and side-effect-freedom 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?

A single, front-loaded sentence that states the action and then packs the acceptance criteria into a compact parenthetical list. There is no filler, and every clause contributes useful information. This is an efficient use of the description budget.

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

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

For a tool with one optional parameter and no output schema, the description adequately covers input scope and evaluation criteria, but it does not explain the result format, scoring scale, or how an agent should interpret the output. Since there is no output schema to compensate, this is a meaningful gap for an agent intending to act on the result.

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

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

Schema description coverage is 100%, so the schema already fully documents nodeId, including the optional/fallback behavior (audit the active canvas page if omitted). The description rephrases the same scope ('any screen or the active canvas page') without adding new parameter-level semantics, so it meets the baseline but adds little beyond the schema.

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

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

The description names a specific verb ('Audit and score') and a clear resource ('any screen or the active canvas page'), and it enumerates the exact compliance standards checked. No sibling tool is a lint/audit tool, so there is no ambiguity about what this tool is for.

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

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

The description implies when to use the tool (to audit a screen or page against compliance standards) but provides no explicit guidance contrasting it with related analysis tools like inspect_node, get_design_context, or generate_ui_tree. The agent must infer that this is the audit/score choice from the verb, not from any stated alternatives or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It identifies both operations as mutations but discloses nothing beyond that: it doesn't state whether creating a page also switches to it, whether duplicate names are allowed, what changes occur to the current view/selection, or what the tool returns. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

One sentence, perfectly front-loaded with the two operations, zero filler. The second phrase ('or switch the active page') adds a distinct purpose without redundancy. Structurally efficient and easy to scan.

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

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

For a tool with two actions, conditional parameters, no annotations, and no output schema, the description is adequate but lean. It covers the two operations but doesn't address return behavior, side effects on the active page when creating, or the parameter-action pairing rules. The schema fills part of the gap (required action, enum values), but the description leaves behavioral outcomes unstated.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal value by scoping creation to 'the document' and mapping switch behavior to 'active page,' which loosely reinterprets the action enum. However, it doesn't clarify the conditional relationship between action, name, and pageId beyond what the schema already conveys.

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-resource pair ('create a new page' / 'switch the active page') and clearly differentiates this tool from all siblings. No other sibling manages pages — the nearest are object creators (create_frame, create_rectangle, create_text) which operate on different resources. An agent can select this tool unambiguously.

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

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

The description implies the two use cases (creating vs. switching) through the action verbs, but provides no explicit when-to-use guidance, prerequisites, or exclusions. It also doesn't name alternatives or clarify which action requires which parameters (name vs. pageId). The usage context is inferable but not spelled out.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Ping' implies a harmless check, and 'verify live canvas communication' suggests a response, but the description does not explicitly state that the operation is read-only, non-destructive, or what happens if the plugin is disconnected. It is not misleading, but it leaves some behavior unstated.

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

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

The description is a single concise sentence that front-loads the action and purpose. There is no redundancy or unnecessary detail.

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

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

For a simple ping tool with one optional parameter and no output schema, the description provides enough information for an agent to understand its function and invoke it correctly. Nothing essential is missing.

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

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

Schema description coverage is 100% for the single optional parameter, which is already documented as 'Optional message to echo back'. The tool description adds no further parameter context, but since the schema fully covers it, the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Ping'), a clear resource ('connected Figma companion plugin'), and a specific purpose ('verify live canvas communication'). It is easily distinguishable from all sibling tools, none of which are ping-like operations.

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

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

The description implies a use case (verifying connectivity) but does not explicitly state when to use it versus alternatives, nor any conditions under which it should not be used. Since no sibling tool serves this exact purpose, the lack of explicit guidance is minor but still present.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. The verb 'Read' indicates this is non-mutating, but the description does not disclose return format, pagination behavior, or whether the file must have comments. This is acceptable but not highly informative.

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

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

The description is one compact sentence that leads with the action and resource. It is slightly wordy ('collaboration feedback, review threads, and pins' could be simpler), but every major element is useful and there is no redundant 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 definition is complete enough for a simple single-parameter read operation: it identifies the resource and what will be retrieved. It does not describe the response shape or pagination, but given the simplicity of the tool and the clear 'Read' framing, no critical invocation detail is missing.

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

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

Schema description coverage is 100%, with the single fileKey parameter already documented as 'Figma file key'. The tool description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Read') and names a concrete resource ('collaboration feedback, review threads, and pins'), making it clear this retrieves comments from a Figma file. It is naturally differentiated from siblings like rest_post_comment by being explicitly a read operation.

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

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

The description implies the use case: call this when you need to read collaboration feedback or comments on a file. However, it does not explicitly state when not to use it or name alternatives such as rest_post_comment for writing comments, leaving the routing to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'List' without noting that it is read-only, any authentication needs, rate limits, or error behavior. The description adds no behavioral context beyond the literal action, leaving significant ambiguity for a tool that could potentially be a heavy operation.

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

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

The description is a single, concise sentence that is front-loaded with the primary action and object. There is no redundant or extraneous information, making it highly efficient for its purpose.

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

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

Given the simplicity (1 param, no output schema), the description provides a reasonable hint about the return content by listing what it returns (component definitions, sets, documentation links). However, it does not clarify the output format, potential pagination, or error conditions. Since no annotations or output schema exist, the description could be more informative but is minimally adequate.

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

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

Schema description coverage is 100% for the single parameter fileKey, which already documents its meaning. The description does not add any additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'List' and the specific resources: component library definitions, component sets, and documentation links. It is specific and distinct from generic file operations, though it does not explicitly differentiate from sibling tools like rest_get_file or rest_get_file_nodes.

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

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

The description implies usage (when you need component library information), but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. No context is given about fileKey requirements or relationship to other listing tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that this is a 'Headless read' (implying non-mutating) and that it requires FIGMA_ACCESS_TOKEN, which are useful. However, it does not address potential behavioral details like response size, pagination, rate limits, or error handling on invalid tokens.

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, information-dense sentence that leads with the core action ('Headless read') and resource, then enumerates the included data categories. There is 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 read-only metadata tool with only two well-documented parameters and no output schema, the description covers the key essentials: what is retrieved, that it is a headless/REST operation, and the authentication requirement. It does not explain how to obtain the fileKey, but the schema already provides an example, so this is not a critical gap.

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

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

Schema description coverage is 100%, so the schema already documents both fileKey and depth, including the default depth value. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('read') and resource ('full Figma file metadata, version history, components, styles, and document tree'), making the tool's purpose obvious. It is implicitly distinguished from siblings like rest_get_file_nodes and rest_get_components by emphasizing 'full file', but it does not explicitly name a sibling alternative.

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

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

No guidance is provided about when to choose this tool over siblings such as rest_get_file_nodes, get_document_info, or rest_get_components. The description mentions the access token requirement but offers no use-case context or exclusions, leaving the selection decision entirely to 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?

Annotations are absent, so the description must carry the behavioral disclosure burden. It mentions the REST API method and the efficiency benefit, but omits any side effects, error handling, authentication requirements, or response format. For a fetch operation, the agent needs to know what happens on missing IDs or depth limits, but none of that is disclosed.

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

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

The description is a single sentence that front-loads the action and its benefit. It contains zero filler and directly conveys the core functionality, making it easy for an agent to parse quickly.

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

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

For a 3-parameter tool with no output schema, the description covers the essential function but leaves out details such as the effect of the 'depth' parameter and the structure of the response. It is minimally viable but not enriched with the nuance needed for an agent to anticipate behavior under 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?

The input schema already provides complete descriptions for all three parameters (fileKey, nodeIds, depth), so schema coverage is 100%. The description adds no further parameter semantics beyond referring to 'by ID', which is already covered by the nodeIds description. Baseline 3 is appropriate.

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

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

The description opens with the specific verb 'Fetch', names the resource 'specific nodes by ID', and adds the key differentiator 'without loading the entire document'. This clearly distinguishes it from sibling tools like rest_get_file (whole file) and find_nodes (search). The purpose is unmistakable.

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

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

The description implies usage when you know node IDs and want to avoid a full document load, but it does not explicitly state when not to use it or name an alternative. Sibling tools like rest_get_file exist, yet no comparison is made. Guidance is only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'high-resolution' and 'cloud rendering engine', which hints at the rendering behavior, but it does not disclose rate limits, cost implications, whether the operation is asynchronous, or what happens if node IDs are invalid. For a rendering tool that likely consumes significant resources, this is a notable gap.

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

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

The description is a single, focused sentence that front-loads the core action and resource. It is concise and free of filler, though it could be slightly more structured by separating the rendering action from the engine 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?

Given the tool's complexity (4 parameters, no output schema, no annotations), the description is incomplete. It does not explain the return format (e.g., URLs to rendered images), error behavior, or any constraints like maximum node count or file size. An agent would need to inspect the schema and possibly make assumptions about the response.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds the context that rendering is 'high-resolution' and uses the 'cloud rendering engine', which gives some meaning to the 'scale' and 'format' parameters, but it does not add significant detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Render') and resource ('high-resolution cloud images/exports of frames or components') and names the rendering engine ('Figma Cloud rendering engine'). It is clear about what the tool does, though it does not explicitly differentiate it from the sibling 'export_node_image', which likely has overlapping functionality.

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

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

The description implies usage for rendering frames/components at high resolution via cloud rendering, but it does not explicitly state when to use this tool versus alternatives like 'export_node_image'. No exclusions or alternative routing are provided, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly signals a read operation, but omits enterprise-plan requirements, authentication needs, output shape, and potential failure modes, which are important for a scoped API like this.

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 compact sentence with no filler. The verb and resource are front-loaded, making it easy for an agent to quickly understand the tool's purpose.

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

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

For a one-parameter tool the description is close to adequate, but it does not mention when to use it rather than get_document_tokens, nor does it disclose the enterprise-only limitation or expected return data. An agent could select the wrong sibling or invoke this on an ineligible file.

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

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

Schema description coverage is 100% for the single fileKey parameter, so the schema already documents the only input. The description adds no additional meaning to the parameter beyond what the schema provides.

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

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

The description uses a specific verb ('Read') and identifies the resource ('Figma Enterprise / Organization Variables and token collections') with helpful examples like color palettes, spacing, and modes. It is clear, though it does not explicitly distinguish itself from siblings such as get_document_tokens or rest_get_file.

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

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

The description gives no guidance on when to use this tool versus the sibling get_document_tokens or other REST getters. The 'Enterprise / Organization' phrasing hints at a scope restriction but does not state conditions, prerequisites, or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a write operation but does not mention authentication requirements, side effects on the Figma file, reversibility, permissions, or response behavior. An agent cannot anticipate what will happen beyond the high-level 'post' action.

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

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

The description is a single, front-loaded sentence with no fluff beyond the mildly redundant 'via REST API,' which is already implied by the tool name. It is concise and communicates the core action 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?

Despite the simple schema and full parameter descriptions, the tool has no annotations, no output schema, and no behavioral guidance about auth, response format, errors, or what happens when nodeId is omitted. The phrase 'screen or pin' is ambiguous relative to the schema's optional nodeId, leaving an agent without enough context 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?

The input schema already documents all three parameters at 100% coverage, so the baseline is 3. The description adds marginal context by framing the message as 'review feedback or design critique,' but it does not meaningfully enrich the schema's parameter descriptions.

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

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

The description uses a specific verb-resource pair ('Post a review comment or design critique') and the target is clearly a Figma comment, distinguishing it from read-oriented siblings like rest_get_comments. However, it does not explicitly name or contrast itself with any sibling, so it stops short of full differentiation.

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

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

The intended use is implied by the verb 'Post' and the comment-related fields, but the description gives no explicit guidance on when to use this tool versus alternatives such as rest_get_comments for reading comments or other mutation tools. There are no exclusions, prerequisites, or situational cues beyond the action 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?

With no annotations provided, the description must disclose behavioral consequences, but it only says 'Configure' and 'existing frame'. It does not state that existing AutoLayout settings will be overwritten, that 'NONE' removes AutoLayout, or what happens if the target node is not a valid Frame.

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

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

The description is one compact sentence with a useful parenthetical listing the core rule categories. It is front-loaded with the tool's purpose, is easy to scan, and contains 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 parameter schema is rich and covers all inputs, and the description states the core purpose and the existing-frame prerequisite. However, with no annotations and no output schema, the agent is left uninformed about the mutation's side effects and return value, so the definition is adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already explains each of the 12 parameters. The description's parenthetical (direction, padding, gap, alignment) maps loosely to those parameters but adds no new meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Configure') and a specific resource ('existing frame'), and it names the domain (Flexbox/AutoLayout) plus the main rule categories. It is clear, but it does not explicitly differentiate this from generic mutation tools like update_node or other frame setters, so it falls short of a 5.

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

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

The phrase 'on an existing frame' implies the tool is for modifying frames that already exist rather than creating new ones, which provides weak usage context. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as update_node or create_frame.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'apply' and lists effect types; it does not disclose whether existing effects are replaced, whether an empty array clears effects, or any other side-effect semantics.

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

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

A single sentence that front-loads the action and resource while compactly listing the supported effect types in parentheses. Every word earns its place; there is no redundancy.

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

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

For a mutating tool with no annotations and no output schema, the description should clarify behavioral semantics like replace-versus-merge behavior and how to remove effects. The schema fully documents the parameters, but the operational context is incomplete.

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

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

Schema description coverage is 100%, with nodeId, effects, and all nested fields (type, color, offset, radius, spread, visible) already documented. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb ('Apply') and names the exact resources: elevation shadows, inner shadows, and blurs. It also enumerates the four supported effect types, making it clearly distinct from siblings like set_stroke or update_node.

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

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

No guidance is given for when to use this tool versus alternatives such as set_stroke or update_node. There is also no mention of whether effects replace existing ones or how to clear effects, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Mark' is vague: it does not say whether this mutates the frame, persists a named flow, overrides an existing starting point, or requires a specific frame type. These side effects are left entirely unstated.

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

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

The description is a single sentence with no filler. It front-loads the core operation ('Mark a screen frame'), then specifies the resulting state ('named prototype flow starting point') and relevant examples.

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

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

This is a simple two-parameter tool with a complete input schema, so the description is minimally viable. However, without annotations or an output schema, it leaves behavioral and routing context unexplained, especially the relationship between a flow starting point and the broader prototype interaction workflow.

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

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

Schema description coverage is 100%, and both parameters already have clear descriptions in the schema. The tool description adds illustrative examples of flow names but no additional syntax, constraints, or edge-case meaning beyond what the schema provides.

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

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

The description uses a specific verb and resource: 'Mark a screen frame as a named prototype flow starting point'. It clearly says what the tool does and gives concrete examples ('Onboarding Flow', 'Purchase Flow'), but it does not explicitly contrast itself with sibling tools like set_prototype_interaction.

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 'prototype flow starting point' and the examples imply when this tool applies, but the description never states when to use it instead of related tools such as set_prototype_interaction or batch_link_prototype, nor does it mention any exclusions or prerequisites.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only categorizes the action and gives examples; it does not reveal that this creates or overwrites a prototype connection, whether existing overlay interactions are replaced, or what side effects occur after invocation.

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

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

Single sentence with no filler, and the key term 'overlay prototype interactions' appears before the parenthetical examples. Every part contributes to identifying the tool's domain.

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

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

Despite a rich input schema, the tool has 11 parameters, no annotations, and no output schema, and the description provides only a one-line category. Missing context includes when this tool is preferred over set_prototype_interaction, whether it creates or modifies connections, and what happens after invocation.

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

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

Schema description coverage is 100%, and each parameter already has a clear description, so the baseline is 3. The description adds no extra parameter meaning, but it does not need to compensate for schema gaps.

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

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

Description states a specific verb ('Configure') and a distinct resource ('interactive overlay prototype interactions'), with concrete examples (modals, dialogs, bottom sheets, slide-over panels, dropdowns). This clearly differentiates it from the sibling set_prototype_interaction, which appears to target prototype interactions more generally.

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 examples imply when to use the tool: whenever an overlay-style interaction (modal, dialog, sheet, etc.) is being configured. However, it never explicitly names alternatives such as set_prototype_interaction or states when NOT to use this tool, leaving the routing decision to inference.

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

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

With no annotations, the description must disclose behavioral traits. It mentions defaults for some parameters (e.g., navigation defaults to NAVIGATE, triggerType defaults to ON_CLICK) but does not describe side effects like whether existing interactions are overwritten or if the source must be a specific node type. It provides some clarity but misses important behavioral details.

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

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

The description is a single, concise sentence that front-loads the core purpose. It is not verbose and avoids redundancy with the schema. However, it could add a bit more usage context without becoming wordy.

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

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

Given the tool's complexity (10 parameters, 5 enums), the description is too sparse. It does not explain required parameters like destinationNodeId (though not required by schema, it is essential for navigation) or how the various navigation types behave. The schema provides parameter details but the description should guide successful invocation, which it does not fully do.

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

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

Schema coverage is 100%, so the schema already explains each parameter. The description does not add extra meaning beyond the schema, but it does frame the tool's purpose. Since the schema is comprehensive, a baseline of 3 is appropriate.

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

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

The description clearly specifies the action (wire a transition), the resource (interactive prototype), and the source/destination (clickable element to target screen/modal). It distinguishes itself from sibling tools like set_overlay_interaction and batch_link_prototype by focusing on a single transition from a source element.

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

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

The description implies usage for creating interactions, but does not explicitly state when to use this tool versus alternatives like set_overlay_interaction or batch_link_prototype. It lacks exclusion criteria or preconditions (e.g., source must be a frame or component).

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

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

With no annotations present, the description must carry the full behavioral burden, but it only indicates that a stroke is added or updated. It does not disclose whether existing stroke properties are overwritten, what happens with unsupported node types, or any side effects or permissions needed.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the operation and its applicable target types.

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

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

Given there is no output schema and no annotations, a 12-word description is insufficient for a mutating tool with four parameters. Missing context includes update semantics, alignment defaults, and what the agent should expect after execution.

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

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

The input schema already documents all four parameters with 100% coverage, so the description does not need to repeat them. The description provides no extra meaning about how color, weight, or strokeAlign interact, but the schema is sufficient for basic parameter understanding.

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

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

The phrase 'Add or update border stroke' names a specific verb and resource, and enumerates target node types (frame, card, button, rectangle), making the tool's function unmistakable. It stands apart from siblings like set_effects and set_autolayout, which address different visual properties.

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

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

The description offers no guidance on when to prefer this tool over alternatives, nor does it state conditions where another sibling (e.g., update_node or set_effects) would be more appropriate. Although the target types imply some use cases, no exclusions or comparisons are provided.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose two important behaviors: emojis are strictly sanitized and leading/tracking are recalibrated. However, it leaves ambiguity about what 'sanitized' means (stripped vs rejected) and says nothing about permissions, failure modes, or whether other text properties are preserved.

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

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

Two sentences with no filler. The first sentence front-loads the core purpose, and the second adds meaningful behavioral caveats about sanitization and automatic recalibration.

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 mutation tool with fully documented schema and no output schema, the description is largely sufficient. It explains the core operation and two notable side effects. It could mention return behavior or error handling, but these are less critical for a straightforward setter.

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

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

The input schema already covers both parameters with 100% description coverage, including the explicit 'must NOT contain emojis' constraint on text. The description adds no parameter-level detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a clear action ('Update') and a specific resource ('existing text layer'), which immediately distinguishes it from create_text and generic update_node. The phrase 'existing' also signals this is not for creating new text.

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

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

Provides no explicit guidance on when to use this tool versus alternatives. It only implies through 'existing text layer' that the tool is for modifying already-created text nodes, but it never names create_text, update_node, or any condition that would route an agent to this tool.

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

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

With no annotations provided, the description must disclose behavioral traits itself. It only says 'Update', implying mutation, but does not clarify side effects (e.g., whether updates are atomic, whether partial updates are allowed, what happens if nodeId is invalid, or whether the node must exist). No error behavior or return information is given.

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

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

The description is a single, clear sentence that lists the key updateable properties. It is front-loaded with the action and target, though it could be slightly more compact by grouping properties more efficiently. No redundancy or filler.

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

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

Given 11 parameters, no annotations, and no output schema, the description is insufficiently complete. It does not address error handling, whether multiple properties can be updated in one call, constraints on input formats, or what the response contains. An agent would need to inspect the schema for details but still lacks behavioral context for a mutation operation.

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

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

The schema covers all 11 parameters with descriptions (100% coverage), so the baseline is 3. The description loosely maps to some parameters (dimensions, coordinates, etc.) but adds no new meaning beyond listing a few categories; it does not mention 'name' or 'image', and does not elaborate on constraints like opacity range or coordinate units.

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

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

The description clearly states the tool updates an existing node's visual/geometric properties (dimensions, coordinates, fills, corner radius, opacity, visibility). It distinguishes from create and delete tools, though it omits the 'name' and 'image' properties that also appear in the schema, making the scope slightly incomplete.

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 siblings like set_stroke, set_text_content, or set_autolayout. It does not mention any conditions, exclusions, or alternatives, leaving the agent to infer that this is a general-purpose update tool without knowing when a more specific setter would be preferable.

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