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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical behavioral details: it doesn't specify if this is a read-only analysis or if it modifies the codebase, what permissions or authentication are required, how it handles large codebases (e.g., rate limits or performance), or what the output format looks like (since there's no output schema). For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is highly concise and front-loaded, consisting of two efficient sentences that directly state the tool's function, supported technologies, and extraction targets. Every word earns its place, with no redundant or vague phrasing. This makes it easy for an agent to quickly grasp the core purpose without 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?

Given the complexity of codebase analysis and the lack of annotations and output schema, the description is incomplete. It explains what the tool does but misses key contextual details: how it accesses the codebase (e.g., from a file system or URL), what the analysis output includes (e.g., structured data or raw text), and any limitations (e.g., supported file types or codebase size). Without this, an agent might struggle to use the tool effectively in real scenarios.

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 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't mention any parameters, which is appropriate here—it implies the tool operates without inputs, possibly analyzing a default or contextually provided codebase. Since there are no parameters to explain, the description doesn't need to compensate, and a baseline of 4 is justified for not introducing confusion.

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

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

The description clearly states the tool's purpose: analyzing a codebase to extract component definitions, props, and design tokens, with specific technology support (React, Vue, Svelte, Angular) and extraction targets (Tailwind config, CSS variables). It distinguishes from siblings like 'get_components' or 'get_variables' by focusing on codebase analysis rather than direct retrieval. However, it doesn't explicitly contrast with 'reconstruct_page' or 'generate_ui', which might involve similar analysis, leaving some room for improvement.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a codebase path or access), exclusions (e.g., not for live websites), or compare to siblings like 'get_components' (which might retrieve existing components) or 'reconstruct_page' (which might rebuild UI from code). This lack of context makes it hard for an agent to decide when this tool is appropriate.

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

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

With no annotations, the description carries full burden but provides minimal behavioral context. It mentions that auto-layout 'automatically arranges children horizontally or vertically with consistent spacing,' which hints at mutation behavior and layout direction. However, it lacks details on permissions, side effects (e.g., overwrites existing layouts), rate limits, or error conditions, leaving significant gaps.

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 highly concise and well-structured in two sentences. The first sentence states the core action, and the second explains what auto-layout does. Every word earns its place with no redundancy or fluff, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (mutating layout with directional behavior) and no annotations or output schema, the description is minimally adequate. It explains what auto-layout does but lacks details on outcomes, error handling, or integration with sibling tools. For a mutation tool, more context would improve completeness.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's action. This meets the baseline for zero-parameter tools, though it doesn't add extra semantic value beyond the schema.

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

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

The description clearly states the tool's purpose: 'Apply auto-layout to a frame' specifies the verb (apply) and resource (frame). It distinguishes from siblings like 'create_frame' or 'update_node' by focusing on layout arrangement. However, it doesn't explicitly differentiate from potential layout-related tools that might exist elsewhere.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requires an existing frame), exclusions, or comparisons to sibling tools like 'update_node' which might also affect layout. Usage context is implied but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what the tool does (capture, analyze, detect UI components) and hints at output (capture ID), but lacks details on permissions, rate limits, or error handling. No contradiction with annotations exists.

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

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

The description is front-loaded with core functionality in the first sentence and adds specific details in the second. Every sentence adds value with no wasted words, making it highly efficient and well-structured.

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

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

Given the tool's complexity (capturing and analyzing webpages) and lack of annotations and output schema, the description is adequate but incomplete. It explains the purpose and output format (capture ID), but omits details like supported webpage types, analysis depth, or error scenarios that would enhance completeness.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on tool functionality without redundant parameter details, earning a baseline score of 4 for zero-parameter tools.

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

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

The description clearly states the tool's purpose with specific verbs ('capture', 'analyze') and resources ('webpage screenshot', 'DOM structure'), and distinguishes it from siblings by mentioning UI component detection and a specific return value for use with 'reconstruct_page'.

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 context by stating it returns a capture ID for use with 'reconstruct_page', providing a clear alternative tool reference. However, it lacks explicit guidance on when not to use this tool or comparisons to other sibling tools like 'export_image' or 'get_components'.

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 mentions the plugin requirement but lacks details on permissions, error handling, or what happens upon creation (e.g., default properties, positioning). For a creation tool with zero annotation coverage, this leaves significant gaps in understanding its 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 two sentences, front-loaded with the core action and resource. It efficiently adds necessary context without redundancy. However, it could be slightly more structured by separating the prerequisite into its own clause for clarity.

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 (creation operation), lack of annotations, and no output schema, the description is minimally adequate. It covers the purpose and a key prerequisite but misses behavioral details like what the frame defaults to or how it integrates with other tools. It's complete enough for basic use but has clear gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds context about the plugin requirement, which is beyond the schema. Baseline is 4 for zero parameters, as there's nothing to compensate for.

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 a new frame') and resource ('in Figma'), with additional context about frames being 'the primary container for designs.' It distinguishes from siblings like create_rectangle or create_text by specifying the frame type, though it doesn't explicitly contrast with 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 provides a prerequisite ('Requires the Figma plugin to be connected'), which implies when the tool can be used. However, it offers no guidance on when to choose this tool over alternatives like create_rectangle or update_node, nor does it specify exclusions or complementary 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 full burden for behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't address permissions needed, whether this requires an active Figma file/document context, what happens on failure, or any rate limits. The mention of 'fills and rounded corners' hints at capabilities but doesn't fully describe behavioral traits like default values or constraints.

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

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

The description is extremely concise at just two sentences with zero wasted words. The first sentence establishes the core purpose, and the second adds useful capability information. Every element earns its place, and the structure is front-loaded with the most important information first.

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 this is a creation/mutation tool with no annotations and no output schema, the description should do more to address behavioral aspects. While it efficiently states what the tool does and hints at capabilities, it doesn't cover important context like what happens after creation (does it return the created object?), what context is required, or error conditions. For a mutation tool in a design environment, this leaves significant gaps.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't attempt to describe non-existent parameters. It does mention capabilities ('fills and rounded corners') which might relate to how the rectangle is configured, but since there are no actual parameters, this is acceptable. Baseline for 0 parameters with full coverage is 4.

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 a rectangle shape') and target resource ('in Figma'), making the purpose immediately understandable. It distinguishes from some siblings like 'create_frame' or 'create_text' by specifying rectangle creation, though it doesn't explicitly differentiate from all potential shape-creation tools. The description is specific but could be more precise about its unique scope.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_frame' or 'create_text'. It mentions capabilities ('Can have fills and rounded corners') but doesn't indicate when this is the appropriate choice over other creation tools or what prerequisites might exist. There's no explicit when/when-not 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?

No annotations are provided, so the description carries the full burden. It states 'Create a text node', implying a write/mutation operation, but doesn't disclose behavioral traits like permissions needed, whether it's idempotent, rate limits, or what happens on failure. The mention of 'font customization and alignment' hints at capabilities but lacks operational context.

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

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

The description is two short sentences with zero waste. It's front-loaded with the core action ('Create a text node in Figma') and adds useful detail ('Supports font customization and alignment') without redundancy. 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 0 parameters, no output schema, and no annotations, the description is minimally adequate. It states what the tool does and hints at features, but for a mutation tool in a design context, it lacks details on error handling, return values, or integration with sibling tools. It's complete enough for basic understanding but has clear gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description adds value by mentioning 'font customization and alignment', which provides semantic context about what the tool can do beyond the bare 'create' action. This compensates well for the lack of parameters.

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

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

The description clearly states the action ('Create a text node') and the platform ('in Figma'), which is specific and unambiguous. It distinguishes from siblings like 'create_frame' or 'create_rectangle' by specifying text content. However, it doesn't explicitly mention what distinguishes it from other text-related tools (none listed in siblings), so it falls short of a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'font customization and alignment' as features, but doesn't specify prerequisites, constraints, or when to choose this over other creation tools like 'create_frame'. There's no explicit when/when-not or alternative tool references.

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 full burden for behavioral disclosure. While 'Delete' implies a destructive operation, it doesn't specify whether deletion is permanent/reversible, what permissions are required, how it affects parent/child nodes, or what happens on success/failure. This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that states the core functionality without unnecessary words. It's front-loaded with the essential information and contains zero redundant content, making it optimally concise 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?

For a destructive operation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address critical context like what 'delete' means in Figma's document model, whether there are confirmation steps, what the response contains, or error conditions. The agent lacks necessary operational understanding.

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 0 parameters with 100% description coverage, so the schema fully documents the parameter situation. The description appropriately doesn't discuss parameters since none exist, earning a baseline 4 for not creating confusion about non-existent parameters.

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

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

The description clearly states the action ('Delete') and target resource ('a node from the Figma document'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential sibling operations like 'update_node' or 'get_node' beyond the basic verb difference.

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites for deletion, or what constitutes a deletable node. With multiple sibling tools like 'get_node', 'update_node', and 'get_selection', there's no indication of workflow relationships or decision criteria.

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

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

No annotations are provided, so the description carries the full burden. It discloses the action (export) and return type (URL), but lacks details on behavioral traits such as permissions required, rate limits, whether the URL is temporary or permanent, or error conditions. The description adds basic context but misses key operational aspects for a tool with no annotation coverage.

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 that front-loads the core action ('Export a Figma node as an image') and follows with essential details (formats, return type). Every word earns its place, with no wasted text or unnecessary elaboration, making it highly concise and well-structured.

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

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

Given the tool's complexity (export operation with no parameters) and lack of annotations/output schema, the description is minimally adequate. It covers the basic purpose and return value but omits context like authentication needs, error handling, or format-specific behaviors. For a tool with no structured data support, it should provide more operational guidance to be fully complete.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, focusing instead on the tool's function and output. This meets the baseline for tools with no parameters, as it adds value by explaining what the tool does without redundancy.

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 specific action ('Export a Figma node as an image') and the resource involved ('Figma node'), distinguishing it from siblings like 'get_node' (which retrieves) or 'update_node' (which modifies). It specifies the output formats (PNG, JPG, SVG, PDF) and the return type (URL), making the purpose explicit and distinct.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a valid node ID), exclusions (e.g., not for text nodes), or comparisons to siblings like 'capture_webpage' (for web content) or 'get_file' (for raw file data). Usage context is implied but not 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 provided, the description carries full burden for behavioral disclosure. It mentions the tool 'creates corresponding Figma elements' which implies a write operation, but doesn't specify permissions needed, whether changes are reversible, or what happens to existing designs. No rate limits, error conditions, or output format are described. The behavioral context is minimal for a creation tool.

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

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

The description is perfectly concise at two sentences. The first sentence establishes the core purpose, the second adds important behavioral detail about pattern parsing and Figma element creation. Every word earns its place with zero redundancy or fluff. The structure is front-loaded with the primary function.

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 (generative UI design), lack of annotations, and no output schema, the description is minimally adequate. It explains what the tool does and the parsing behavior, but doesn't cover important aspects like what UI patterns are supported, quality of generated designs, error handling, or what the output looks like. For a creative generation tool, more context would be helpful.

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 0 parameters with 100% schema description coverage, so the baseline is 4. The description adds meaningful context about what the tool expects: 'from a text description' and 'parses the prompt for common UI patterns' clarifies that input is provided through the prompt/description text rather than structured parameters. This compensates for the lack of formal parameters.

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

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

The description clearly states the tool's purpose: 'Generate a UI design from a text description' specifies the verb (generate) and resource (UI design). It distinguishes from siblings like create_frame or create_rectangle by focusing on high-level design generation rather than low-level element creation. However, it doesn't explicitly differentiate from reconstruct_page or other design-related tools.

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

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

The description implies usage context: 'Parses the prompt for common UI patterns' suggests this tool is for converting textual descriptions into structured UI elements. However, it doesn't provide explicit guidance on when to use this versus alternatives like create_frame for manual creation or reconstruct_page for existing designs. No when-not-to-use scenarios or prerequisites are mentioned.

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

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

With no annotations provided, the description carries full burden but only states it 'Returns component keys, names, and descriptions.' It lacks details on permissions, rate limits, pagination, error handling, or whether it's read-only/destructive. For a tool with zero annotation coverage, this is insufficient behavioral disclosure.

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

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

Two concise sentences with zero waste: the first states the action and resource, the second specifies the return data. It's front-loaded with the core purpose and efficiently structured without redundant 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?

Given no annotations, no output schema, and 0 parameters, the description covers the basic purpose and return values adequately. However, for a read operation in a design tool context, it lacks details on authentication needs, response format, or error cases, leaving gaps in completeness.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't add parameter details, maintaining focus on the tool's purpose. Baseline for 0 parameters is 4, as no compensation is needed.

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

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

The description clearly states the specific action ('List all components') and resource ('in a Figma file'), distinguishing it from sibling tools like get_file, get_node, or get_styles. It precisely defines the scope as retrieving all components rather than filtering or analyzing them.

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

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

No guidance is provided on when to use this tool versus alternatives like get_node (which might retrieve specific nodes) or get_file (which might return broader file metadata). The description implies usage for listing components but doesn't specify prerequisites, exclusions, or comparative contexts with siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get') and specifies the return content, but lacks details on permissions, rate limits, error handling, or whether it requires authentication. It adds some context but is incomplete for a tool with zero annotation coverage.

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 that front-loads the purpose ('Get a Figma file structure and metadata') and adds necessary detail about returns. Every word earns its place, with no redundancy or wasted phrasing.

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

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

Given the tool's complexity (retrieving file structure), lack of annotations, and no output schema, the description is minimally adequate. It explains what the tool does and what it returns, but does not cover behavioral aspects like authentication needs or error cases, leaving gaps for the agent to navigate.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, focusing instead on the tool's purpose and output, which aligns with the baseline for zero parameters.

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

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

The description clearly states the specific action ('Get'), resource ('Figma file structure and metadata'), and what is returned ('document tree, components, and styles'). It distinguishes from siblings like get_components, get_styles, and get_node by specifying it retrieves the full file structure rather than subsets.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_components, get_styles, or get_node. It does not mention prerequisites, such as needing a file ID, or exclusions, leaving the agent to infer usage from context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions efficiency compared to 'get_file', which is useful context, but lacks details on permissions, error handling, rate limits, or what happens if nodes are not found. It adequately describes the core behavior but misses operational traits.

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

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

The description is two sentences with zero waste: the first states the purpose, and the second provides usage guidance. It is front-loaded with the core function and efficiently contrasts with alternatives, making it highly concise and well-structured.

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

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

Given no annotations, no output schema, and 0 parameters, the description is complete enough for a simple retrieval tool. It explains what the tool does and when to use it, but lacks details on return values (e.g., node structure) or error cases. For a tool with no structured data, it meets minimum viability but has gaps in output explanation.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining the tool's purpose and usage context, which compensates for the lack of parameters. Baseline is 4 for 0 parameters, as the description provides meaningful semantics beyond the empty schema.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('specific nodes from a Figma file by their IDs'), distinguishing it from siblings like 'get_file' (full file) and 'get_selection' (selected nodes). It explicitly contrasts with 'get_file' for efficiency when node IDs are known.

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 guidance on when to use this tool ('when you know what nodes you need') and when not to use it (vs. 'getting the full file'), naming the alternative 'get_file' implicitly. It clearly defines the optimal context for usage.

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

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

With no annotations, the description carries full burden. It states a read operation ('Get') which implies non-destructive behavior, but doesn't disclose permissions needed, rate limits, or what happens with no selection. It adds minimal behavioral context beyond the basic 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?

Single sentence with zero waste—directly states the tool's purpose without fluff. Every word earns its place, and the structure is front-loaded with the core action.

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

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

Given no annotations, no output schema, and a simple zero-parameter tool, the description is minimally adequate. It explains what the tool does but lacks details on return format, error conditions, or integration context that would help an agent use it effectively.

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 0 parameters with 100% schema description coverage. The description appropriately doesn't discuss parameters since none exist, and the schema already fully documents this. Baseline is 4 for zero-parameter tools when schema coverage is complete.

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 specific action ('Get') and resource ('currently selected nodes in Figma'), distinguishing it from siblings like get_node, get_components, or get_file. It precisely defines the scope as current selection without ambiguity.

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

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

The description implies usage when needing the current selection in Figma, but provides no explicit guidance on when to use this versus alternatives like get_node (for specific nodes) or get_components (for components). No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries full burden but only states what it does, not how it behaves. It lacks details on permissions needed, rate limits, whether it's read-only (implied by 'Get' but not explicit), error handling, or output format. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It uses parentheses to clarify scope without verbosity, and every word contributes meaning without waste.

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

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

Given no annotations, no output schema, and 0 parameters, the description is minimally adequate for a simple read operation. However, it doesn't address behavioral aspects like what 'Get all styles' entails (e.g., pagination, format), leaving gaps in context for an agent to use it effectively.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, but that's acceptable here. Baseline is 4 for zero parameters, as it doesn't need to compensate for gaps.

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

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

The description clearly states the action ('Get') and resource ('all styles from a Figma file'), specifying what types of styles are included (colors, text styles, effects, grids). It distinguishes from siblings like get_components or get_variables by focusing on styles, but doesn't explicitly contrast them.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a file ID), exclusions, or compare it to siblings like get_file or get_node that might overlap in accessing Figma data.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what data is retrieved but doesn't describe how the tool behaves: e.g., whether it returns all tokens or a subset, if there are rate limits, authentication needs, or error conditions. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 two sentences, front-loaded with the core purpose and followed by specifics on included data. Every sentence adds value: the first defines the action and resource, the second clarifies the scope. There's no waste or redundancy, making it highly efficient.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It covers what the tool does but lacks behavioral details like return format or constraints. For a read operation with no structured fields to rely on, it should do more to be fully complete, but it meets the basic threshold.

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 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add param info, and it correctly avoids mentioning any. Baseline for 0 params is 4, as it's complete in this regard without unnecessary details.

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

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

The description clearly states the tool's purpose: 'Get design tokens/variables from a Figma file.' It specifies the verb ('Get') and resource ('design tokens/variables'), and distinguishes the type of data (colors, spacing, tokenized values) from siblings like get_components or get_styles. However, it doesn't explicitly differentiate from get_file or get_node, which could also retrieve file data, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose get_variables over get_styles (which might overlap) or get_file (which might include broader file data), nor does it specify prerequisites or exclusions. Usage is implied by the purpose but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: the tool checks connectivity and implies that write operations depend on it. However, it lacks details on what 'connected' means (e.g., network status, authentication), potential errors, or response format. With no annotations, this is a moderate disclosure but could be more comprehensive.

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

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

The description is highly concise and front-loaded: two sentences that directly state the tool's purpose and usage context without any wasted words. Every sentence earns its place by providing essential information efficiently.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is somewhat complete but could be improved. It explains the purpose and a key dependency for write operations, but lacks details on what the check entails (e.g., returns a boolean, error handling) or how it integrates with sibling tools. For a simple status check, this is adequate but has clear gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description does not add parameter information, which is acceptable here. Baseline is 4 for 0 parameters, as there is nothing to compensate for, and the schema fully covers the absence of 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?

The description clearly states the tool's purpose: 'Check if the Figma plugin is connected.' This is a specific verb ('Check') and resource ('Figma plugin'), making the action clear. However, it does not explicitly differentiate from sibling tools, which include various Figma operations like 'get_file', 'create_frame', etc., though the plugin status check is fairly distinct in purpose.

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

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

The description provides clear context on when to use this tool: it implies it should be used to verify connectivity before performing write operations, as stated in 'Write operations require the plugin.' This gives a practical guideline, but it does not explicitly name alternatives or specify when not to use it (e.g., if only read operations are needed).

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool creates frames, shapes, and text, which is useful behavioral context. However, it doesn't mention potential side effects (e.g., whether it overwrites existing content), permissions needed, or error handling, leaving gaps for a mutation tool.

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

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

The description is two sentences with zero waste. The first sentence states the purpose, and the second provides critical usage guidance. It is front-loaded and efficiently conveys necessary information without redundancy.

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

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

Given the tool's complexity (reconstructing a webpage in Figma), no annotations, and no output schema, the description is somewhat incomplete. It covers purpose and prerequisites but lacks details on output format, error conditions, or behavioral nuances, which could hinder an agent's ability to use it effectively.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on prerequisites and behavior rather than parameters, meeting the baseline for tools with no parameters.

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

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

The description clearly states the specific action ('Reconstruct a captured webpage in Figma') and the resources involved ('creates frames, shapes, and text based on the captured DOM structure'). It distinguishes from siblings like 'create_frame', 'create_rectangle', and 'create_text' by specifying this is a reconstruction of a captured webpage rather than individual element creation.

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 explicitly states when to use this tool ('Requires capture_webpage to be called first'), providing a clear prerequisite. It also implies an alternative by referencing the sibling tool 'capture_webpage' as a necessary precursor, though it doesn't explicitly list other 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?

With no annotations provided, the description carries the full burden. It effectively discloses the key behavioral trait: 'Replaces all existing fills' (destructive overwrite behavior). However, it doesn't cover other aspects like permissions needed, error conditions, or what happens if the node doesn't exist.

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

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

Two sentences with zero waste. The first states the core purpose, the second adds crucial behavioral context. Every word earns its place, and the information is front-loaded appropriately.

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

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

For a mutation tool with no annotations and no output schema, the description covers the destructive nature well but lacks information about what values to provide for fills, expected return format, or error handling. It's minimally adequate given the zero parameters but could be more complete for a write operation.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose and behavior. A baseline of 4 is appropriate for zero-parameter tools.

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 specific action ('Set fill colors/gradients'), target resource ('on a node'), and distinguishes it from siblings by specifying it replaces all existing fills rather than modifying or adding to them. This is a precise verb+resource+scope definition.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_node' or 'get_styles'. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs comparison and syncing, which implies read and write operations, but doesn't clarify permissions, side effects (e.g., whether syncing overwrites data), error handling, or output format. For a tool with potential mutative behavior and zero annotation coverage, this is a significant gap in transparency.

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

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

The description is highly concise and well-structured: a single sentence that efficiently conveys the core purpose and capabilities without redundancy. It is front-loaded with the main action ('Compare and sync') and adds necessary detail about extraction sources. Every word earns its place, 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?

Given the tool's complexity (involving cross-platform syncing) and lack of annotations or output schema, the description is minimally adequate. It covers what the tool does and its input sources, but doesn't address behavioral aspects like mutability, error cases, or result format. For a tool with no structured safety or output hints, more completeness would be beneficial, but it meets a basic threshold.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining the tool's functionality and sources (Figma variables/styles or codebase analysis), which provides context beyond the empty schema. Since there are no parameters to document, a baseline of 4 is appropriate, as the description compensates adequately for the lack of structured input details.

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

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

The description clearly states the tool's purpose: 'Compare and sync design tokens between Figma and code.' It specifies the verb ('compare and sync'), resource ('design tokens'), and scope ('between Figma and code'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_styles' or 'get_variables', which might overlap in token extraction, so it falls short of a perfect score.

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 minimal usage guidance: it mentions the tool can extract tokens 'from Figma variables/styles or from codebase analysis,' implying two possible sources. However, it offers no explicit advice on when to use this tool versus alternatives (e.g., 'get_styles' for styles only), no prerequisites, and no exclusions. This leaves the agent with little direction on optimal tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't disclose critical traits: whether it requires specific permissions, if changes are reversible, potential side effects on other nodes, or rate limits. The mention of 'position, size, text, visibility, and more' hints at scope but lacks depth on 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 appropriately sized and front-loaded: the first sentence clearly states the core purpose, and the second adds useful detail without redundancy. Every sentence earns its place by providing essential information efficiently, with no wasted words.

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

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

Given the tool's complexity (a mutation operation with no annotations and no output schema), the description is minimally adequate. It covers the basic purpose and some updatable properties but lacks details on behavior, error handling, or return values. For a mutation tool in a design context, more guidance on permissions or side effects would improve completeness.

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

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

The input schema has 0 parameters with 100% coverage, meaning no parameters are defined. The description compensates by listing example properties that can be updated ('position, size, text, visibility, and more'), which adds semantic context beyond the empty schema. However, it doesn't specify the exact parameter names or formats, so it's not fully comprehensive.

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

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

The description clearly states the tool's purpose: 'Update properties of an existing Figma node' with a specific verb ('Update') and resource ('Figma node'). It distinguishes from siblings like 'create_frame' or 'delete_node' by focusing on modification of existing nodes. However, it doesn't explicitly differentiate from 'set_fills' which might also modify node properties, keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing node ID), exclusions, or comparisons to siblings like 'set_fills' for specific property updates. The phrase 'and more' is vague and doesn't help the agent choose between this and other modification tools.

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