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

Beyond the annotations (all false), the description discloses that the component will appear in the client dashboard in real-time, a key behavioral detail. It also lists all component types and their variants, providing context on what will be created. It does not cover error conditions or prerequisites, but adds meaningful 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 longer than minimal, but it is well-structured with clear sections for component types, variants, and arguments. The first sentence states the core purpose, and the examples are useful, so every part earns its place.

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

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

The tool has no output schema, and the description does not explain return values, which is a gap. However, it provides extensive guidance on all inputs, available types, variants, and examples. It lacks some context such as whether parent_id must reference an existing component, but overall it is sufficiently complete for an add 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?

Although the schema covers all parameters, the description adds significant value by enumerating each component type and mapping specific variants to major types. The two concrete examples show how to structure props and variant arguments, making parameter usage much clearer.

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 'Add a UI component to the design canvas' with a specific verb and object, plus the real-time dashboard effect. It distinguishes from siblings like design_update_component and design_remove_component by focusing on the addition of new components.

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 clearly implies this is for adding new components, and the comprehensive type list helps the agent understand when to use it. However, it does not explicitly mention alternatives such as design_update_component for modifications or design_remove_component for deletions, so it falls short of a 5.

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

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

The description adds a behavioral trait beyond annotations: 'The new page becomes the current active page.' Annotations only indicate readOnlyHint=false, so this extra detail helps the agent predict state changes. It does not mention other side effects, but with annotations present the added value is meaningful.

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 concise and well-structured: a clear purpose statement, a bulleted args section, and a short example. Every sentence adds value, and the format is easy to scan for an agent.

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

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

For a simple tool with one parameter and no output schema, the description covers the essential behavior, parameter, and active-page effect. It could mention prerequisites like needing an initialized design project, but such context is likely implicit and the description is sufficiently complete for the tool's complexity.

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

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

The schema already provides 100% coverage for the 'name' parameter, and the description repeats the same information ('Name for the new page'). The example shows a concrete invocation, which adds slight value, but no additional constraints or format details are given, so baseline 3 is appropriate.

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

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

Description explicitly says 'Add a new page to the design project' with the specific resource (page) and verb (add). It also distinguishes this from sibling tools like design_add_component by focusing on pages, and notes the active page effect.

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 by the verb and resource, but the description does not explicitly state when to use this tool versus alternatives such as design_switch_page or design_remove_page. No exclusions or prerequisites are mentioned, so guidance is adequate 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?

The description discloses the main behavioral trait: it adds multiple components and enumerates exactly which components each template includes. However, it does not mention whether existing page content is overwritten or if the operation is reversible, which is a gap given that annotations provide no safety hints (all flags false).

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 well-structured and front-loaded: a one-sentence action, a concise list of templates with component details, an args section, and an example. No filler is present; the template list is necessary and clearly formatted.

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 a single parameter and no output schema, the description is nearly complete. It specifies all allowed values and their effects and includes an example. The only notable omission is whether applying a template replaces existing page components or appends to them, which could be important for usage.

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

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

The schema already provides 100% coverage with an enum, but the description adds significant meaning by detailing the component composition for each template value (e.g., 'ecommerce_home' yields 'Navbar + Hero (centered) + Card Grid (3col) + CTA (centered) + Footer'). This goes well beyond the schema's simple 'Template name' description.

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

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

The description clearly states the tool applies a pre-built page template with a specific verb and resource. It distinguishes itself from siblings like design_add_component by focusing on bulk template application rather than individual component operations, and lists exact available template names.

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 clear context by explaining that the tool automatically adds multiple components to the current page, which implies its use for wholesale page construction. It does not explicitly state alternatives or exclusions, but the template list and component breakdown make the appropriate usage evident.

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

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

The description discloses that a pending prompt is 'returned and then cleared', which is a state-changing operation. This contradicts the annotations readOnlyHint=true and idempotentHint=true, as consuming the prompt makes the operation non-repeatable in response and not read-only. This is an annotation contradiction.

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 three concise sentences: purpose, behavior, and usage. It is front-loaded with the key verb and resource, and every sentence adds value without fluff.

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?

Covers the tool's purpose, the critical side effect (clearing), and the polling use case. It does not spell out the response format when no prompt exists, but for a simple zero-parameter poller this is a minor 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?

There are zero parameters and schema coverage is 100%. The description adds 'No arguments required', which is mildly redundant but not harmful. Baseline 4 is appropriate for a no-parameter tool.

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 ('Check') and resource ('user prompts via the client dashboard'), clearly distinguishing this polling tool from the design-focused sibling tools. It states exactly what the tool does in the first sentence.

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

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

Explicitly provides usage guidance: 'Use this to periodically poll for user instructions sent from the browser client.' This gives a clear context for when to invoke the tool. Since no sibling tool serves this function, mentioning alternatives is unnecessary.

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 already declare the tool as read-only, idempotent, and non-destructive, so the safety profile is clear. The description adds behavioral detail about what each export format contains (e.g., CSS variables, component markup, SFC code), going beyond the annotations and schema.

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 well-organized with a clear lead sentence, a bulleted list of formats, an Args section, and a concrete example. Every sentence contributes useful information, and the structure makes 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?

For a single-parameter, read-only export tool, the description is remarkably complete. It covers the action, the supported formats with their outputs, the parameter format, and provides an example. No output schema exists, but the description adequately describes the expected outputs.

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

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

Although the schema already specifies the 'format' parameter with an enum, the description provides meaningful semantic context for each enum value (e.g., 'html: Complete standalone HTML file with CSS variables and all component markup'). This adds significant value beyond the bare schema.

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

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

The description clearly states the tool's function with a specific verb ('Export') and resource ('current design as code'). It enumerates supported formats (html, react, vue, figma_tokens) and explains what each produces, which distinguishes it from all sibling 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 (e.g., export design as HTML or React) but does not explicitly state when to use this tool versus alternatives or when not to use it. No exclusionary or alternative guidance is given, though the format list provides some contextual clarity.

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 already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable context by specifying the return type ('list of conflicts found, or an empty list') and giving concrete examples. This goes beyond annotation coverage, though it does not discuss potential performance 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 two sentences, front-loaded with the purpose, and includes only essential information. Every sentence earns its place: one for functionality, one for invocation and return value.

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

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

Given zero parameters, rich annotations, and no output schema, the description fully covers what the tool does and what it returns. The examples of conflict types provide enough context for an agent to decide when to use it, and the return contract is explicitly stated.

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

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

The input schema has zero parameters, so the baseline is 4. The description reinforces this with 'No arguments required,' which is helpful and eliminates any ambiguity about invocation.

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 and resource: 'Check for token conflicts' with concrete examples ('low contrast color combinations or inconsistent spacing'). This distinguishes it from sibling tools like ui_check_color_contrast by focusing on token-level conflicts rather than a single contrast check.

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 'No arguments required' but does not state when to run this check, what prerequisites exist, or how it differs from related tools like ui_check_color_contrast or design_get_state.

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 already indicate read-only, idempotent, non-destructive behavior. The description adds context about return contents and reflects live client dashboard adjustments, which is useful. It does not contradict annotations and adds some behavioral detail beyond the structured metadata.

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 concise and front-loaded. The first sentence states the core function, the second gives usage direction, and the third lists returns. Every sentence earns its place with no unnecessary words.

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

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

For a simple read-only getter with no parameters and no output schema, the description is complete: it explains what it does, when to use it, and what it returns. The provided information is sufficient for an agent to decide when to invoke this tool versus a sibling.

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 baseline score is 4. The description does not need to explain parameter semantics since there are none. It does clarify the return format (project name, style, tokens, component tree, activity log), which adds 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 clearly states the tool's purpose: 'Get the complete current design state including all tokens, components, and animations.' The verb 'get' and specific resource 'design state' make it distinct from sibling tools that generate or modify design elements.

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: 'Use this to check what's on the canvas before making changes, or to see if the user has made manual adjustments via the client dashboard.' This gives clear context, though it does not explicitly name 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?

Annotations indicate destructiveHint=true and readOnly=false. The description adds context by specifying that previous state is cleared and a complete token set is generated, plus the real-time dashboard update. This is useful behavioral information beyond the annotations.

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 well-structured with a main statement, a side-effect note, an Args list, and examples. It is reasonably concise for a tool with 3 parameters, though it does repeat schema details. The primary purpose 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?

The description covers core purpose, side effects, parameters, and examples. It does not describe the return value, but given the absence of an output schema and the presence of design_get_state among siblings, this is acceptable and fairly 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 covers all parameters with descriptions. The description repeats parameter names/types and includes examples with concrete values, but adds little new semantic meaning since the style enum and base_color hex format are already in the schema.

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

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

The description clearly states the tool initializes a new design project, sets style, generates a token set, and clears previous state. This distinct purpose separates it from sibling tools that update or add specific components.

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 use for new projects ('Initialize a new design project') but provides no explicit alternatives or exclusions. It hints at starting fresh ('clears any previous state'), yet does not compare to design_set_theme or design_generate_design_tokens.

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 all annotations false, the description carries the burden of disclosing behavior. It states that it re-applies a change (a mutation) and returns success status and a state summary, but it does not elaborate on failure conditions or side effects beyond the basic redo 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 exceptionally concise: three short sentences, front-loaded with the primary purpose, and every sentence adds essential information (what it does, no args, return value). 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 simplicity (no params, no output schema), the description covers the core aspects: purpose, argument requirement, and return value. It could mention that a redo is only possible after an undo, but this is strongly implied by the tool name and title, making the description sufficiently complete.

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

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

The tool has zero parameters, and the description reinforces this with 'No arguments required.' The schema already fully documents the parameter set, so the description adds little beyond redundancy, but the baseline for 0 params 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 verb 'Redo' and the resource 'last undone operation,' and adds the clarifying phrase 'Re-applies the most recently undone change.' This distinguishes it from the sibling tool design_undo by being its inverse, 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 context of use is implied: it must follow an undo operation to be meaningful. However, it does not explicitly state when to use versus when not to use, nor does it reference the prerequisite design_undo tool. No alternatives or exclusions 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?

The annotations already provide key behavioral signals: destructiveHint=true and readOnlyHint=false. The description adds scope ('from the canvas') but does not disclose additional behavioral details such as irreversibility or behavior when the ID does not exist, though idempotentHint=true partially covers the latter. This is 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?

The description is compact and front-loaded: one clear sentence, then a simple parameter list and a concrete example. There is no fluff, and every element contributes to understanding how to invoke the 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 simple tool with one parameter, no output schema, and strong annotations, the description covers the essential action, target, and example. It could mention what happens if the component doesn't exist, but the idempotentHint annotation mitigates that need. Overall, sufficient for its complexity.

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

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

Schema coverage is 100% and the single parameter 'id' is described identically in the schema and the description. The description adds no semantic meaning beyond the schema, though it does provide a concrete example invocation, which is mildly helpful. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Remove') and resource ('component from the canvas by its ID'), which clearly distinguishes it from siblings like design_add_component, design_update_component, or design_remove_page. The action and target are immediately clear.

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

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

The description clearly indicates when to use this tool: to remove a component by its ID from the canvas. It does not explicitly mention alternatives or exclusions (e.g., use design_remove_page for pages), but the context is unambiguous enough for an agent to select it appropriately.

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

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

The description adds no behavioral context beyond the annotations. While annotations already indicate destructiveHint and idempotentHint, the description does not disclose side effects (e.g., permanent deletion, impact on associated content) or any prerequisites. It merely restates the operation without adding transparency value.

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

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

The description is very concise and well-structured: a clear one-sentence purpose, a simple Args listing, and a practical example. Every element is useful and there is no redundancy or fluff.

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

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

For a simple one-parameter destructive tool, the description is minimally adequate: it states the action, parameter, and example. However, it lacks usage guidance and behavioral detail (e.g., what happens to dependent components), leaving some gaps. The absence of an output schema and the simplicity of the tool make this acceptable 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 coverage is 100% for the single parameter page_id, and the schema description ('Page ID to remove') already explains its meaning. The description's Args section repeats this exactly, adding no new semantics. This matches the baseline of 3 for high schema coverage.

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

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

The description clearly states the action ('Remove a page'), the resource ('from the design project'), and the method ('by its ID'). It is specific and distinguishes from the sibling tool design_remove_component by explicitly targeting pages.

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 on when to use this tool vs alternatives. It does not mention when not to use it, nor does it reference related tools like design_add_page or design_remove_component. The usage is only implied by the tool's name and basic description.

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

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

Annotations already indicate a non-destructive, idempotent mutation (readOnly=false, destructive=false). The description adds the relative before/after positioning context but does not disclose edge cases (e.g., components in different containers) or additional side effects.

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

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

The description is tightly structured with a one-sentence purpose, an Args list, and a concise example. Every sentence earns its place, and the front-loaded purpose makes the operation immediately clear.

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 mutation tool with fully described parameters, the description is nearly complete. It includes the core operation, all required parameters, and an example. It does not describe return values or failure modes, but those are not critical for this straightforward reorder action.

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% coverage with clear descriptions for all three parameters. The description largely repeats this information, adding only an example that clarifies parameter usage without introducing new semantic detail.

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 reorders a component relative to another component on the canvas, using a specific verb and resource. It distinguishes itself from siblings like design_add_component or design_update_component by focusing on relative ordering.

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 'reorder', and an example demonstrates a typical call, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or when-not-to-use scenarios.

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

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

The description adds behavioral context beyond the annotations, noting that 'The client dashboard will play the animation in real-time' and listing allowed values for entry, hover, and curve. It also provides defaults and ranges, which the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false) do not cover. No contradiction with annotations.

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 well-structured with a clear purpose opening, a behavioral note, lists of allowed values, a parameter breakdown, and an example. It is a bit lengthy due to the enumeration of values, but every sentence adds information (defaults, ranges, example) and there is no fluff.

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 six parameters and no output schema, the description is complete enough for an agent to invoke it correctly. It explains the effect (real-time playback), includes all parameters with types/optionality/defaults, and provides a concrete example. It lacks explicit discussion of side effects like overwriting existing animations, but that is a minor gap given the idempotent hint.

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

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

The input schema covers all six parameters with descriptions (100% coverage), so baseline is 3. The description adds valuable semantics by specifying defaults (duration=0.3, delay=0, curve='easeOut'), explicit ranges (0.1-3.0), and allowed values for entry/hover/curve, which go beyond the schema's property descriptions.

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

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

The description clearly states 'Set animation for a component' with a specific verb and resource, and distinguishes itself from sibling tools like design_update_component by focusing solely on animation. The explicit list of animation entries (fadeUp, fadeIn, etc.) further reinforces the specific 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 implies usage (set animation for a component) but does not explicitly mention when to use this tool versus alternatives, nor does it provide exclusions or conditions. The real-time playback note gives context, but no explicit 'when-not-to-use' guidance is 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?

Annotations already convey mutability and idempotency. The description adds the behavioral consequence that the client dashboard updates accordingly, providing useful context about the effect of the mutation.

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

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

The description is concise and includes a helpful example. The Args section partially duplicates schema information, but the overall structure is clear and 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 single-parameter tool with no output schema and clear annotations, the description is complete. It states the action, effect, and provides an example, sufficient for an agent to invoke it correctly.

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

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

The input schema already documents the 'mode' parameter with enum values and description. The description repeats these values and adds an example, but does not provide additional semantics 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 action (set), the resource (theme mode for the design project), and the allowed values (light/dark). It distinguishes from sibling tools by focusing specifically on the project-wide theme mode.

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

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

The description implies usage by stating the tool's purpose, but it does not explicitly mention when to prefer this over related tools like design_set_token or design_set_animation. No exclusions or alternatives 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?

Annotations already convey readOnly=false, destructive=false, and idempotent=true. The description adds that the client dashboard updates in real-time, which is useful behavioral context beyond the structured fields. There is no contradiction with the annotations.

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 compact and well-structured: a purpose sentence, categories, arguments, and an example. The Args section somewhat repeats schema metadata, but it earns its place with value examples and a concrete invocation pattern, so there is no meaningful 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?

For a simple 3-parameter setter with strong annotations and no output schema, this description is sufficient. It covers purpose, allowed categories, parameter formats, and the real-time effect. No significant behavioral or usage context 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds concrete value examples (e.g., '#FF5733', '1.5rem') and clarifies token key patterns, which enriches 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 clearly states the verb ('Set or update') and the resource ('a single design token'). The word 'single' effectively distinguishes it from bulk-generation siblings like ui_generate_design_tokens, and the example and categories further specify its precise 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?

Usage is implied: this is for updating one token, not generating a token system. However, it never explicitly states when to prefer this over alternatives such as ui_generate_design_tokens or design_update_component, and there are no exclusion criteria or when-not-to-use instructions.

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

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

The annotations already declare idempotentHint=true and destructiveHint=false, but the description adds no further behavioral details. It fails to mention the effect on the current design state or undo history, which could be important for a mutating 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 concise with a simple statement and an example, but the 'Args' list and the parameter explanation duplicate the schema. It earns a 4 for efficiency despite some 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 tool with one parameter and no output schema, the description covers the basic operation but omits any context about side effects or error handling. The annotations fill some gaps, but the description itself lacks sufficient contextual completeness.

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

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

The schema already documents page_id with 100% coverage, and the description's 'Args' section merely restates that definition. No additional semantics, formatting details, or edge cases are provided, so the description adds no 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 uses the specific verb 'switch' with a clear resource: 'a different page in the design project.' This effectively differentiates it from sibling tools like design_add_page and design_remove_page, which handle page creation and deletion.

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 context on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. It only states the action and parameter, leaving the agent without guidance on usage.

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

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

The description goes beyond annotations by stating that no arguments are required and that it returns success status and a state summary. It also reveals the mutation ('Reverts') despite the destructiveHint being false. It does not mention potential clearing of redo history, but given the simplicity, the transparency is adequate.

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 long, entirely front-loaded with the core purpose, and contains no filler. Every sentence adds value.

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

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

For a tool with no parameters and no output schema, the description sufficiently covers input (none), behavior (revert last operation), and output (success + state summary). It could mention edge cases like multiple undos or interaction with design_redo, but it is not necessary for basic use.

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

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

The tool has zero parameters, which earns a baseline of 4. The description adds 'No arguments required', but that is already obvious from the empty schema. Still, it confirms the expected usage.

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 'Undo the last design operation' – a specific verb ('undo') with resource ('design operation') and scope ('last'). It clearly differentiates from the sibling design_redo, which performs the opposite 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 when to use it (after a mistake or unwanted change) and notes 'Reverts the most recent change'. It does not explicitly mention alternatives or exclusion criteria, but the context is clear enough for a simple undo 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?

The description reveals merge semantics and real-time updates, which go beyond the annotations. It does not contradict annotations and adds meaningful context about the update 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 concise and well-structured, with a clear first sentence, argument list, and an example. It wastes no 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 simple update tool with two parameters, the description covers usage, merge behavior, and real-time effects. Without an output schema, it might be further improved by stating return values, but the essentials are present.

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

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

Schema descriptions already cover both parameters, but the description adds value by specifying the source of the ID and clarifying that props merge with existing properties. The example illustrates concrete property names.

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

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

The description clearly states the tool updates properties of an existing component on the canvas, with a specific verb and resource. It distinguishes from siblings like design_add_component by focusing on existing components.

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 on existing components by requiring an ID from design_add_component response. It provides context for when to use it but does not explicitly call out 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?

Annotations already declare readOnly, idempotent, and non-destructive. The description adds valuable behavioral context: which WCAG levels are checked, the exact ratio thresholds, and what the return includes (ratio, pass/fail, grade, recommendations). No contradiction with annotations.

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?

Well-structured with clear sections for purpose, args, returns, and examples. The Args section duplicates schema descriptions somewhat, but the examples earn their place. Overall it's compact and front-loaded, not wasting 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 read-only check tool with no output schema, the description fully covers purpose, WCAG standards, parameters, return values, and examples. There are no obvious gaps in what an agent needs to use it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value with concrete examples (e.g., foreground='#1A1A2E') and clarifies the default response_format. This helps an agent choose valid inputs and understand expected output format.

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

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

Description clearly states 'Check the WCAG 2.1 color contrast ratio' – a specific verb and resource. It distinguishes itself from sibling generation tools (ui_generate_*) by being a validation/checking tool. The WCAG level details further clarify 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 clear context: it evaluates against AA/AAA standards and includes examples of use cases (e.g., checking dark text on white). It doesn't explicitly name alternatives or exclusions, but the purpose is distinct enough from siblings that an agent won't confuse it with palette generation or typography 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?

Annotations already mark the operation as read-only and idempotent. The description adds valuable behavioral details beyond annotations: it specifies that output includes 6 levels, px/rem values, usage guidance, and CSS custom properties. This gives the agent a clear picture of what to expect without contradicting the annotations.

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 well-structured with short paragraphs for arguments, return value, and examples. Every sentence contributes: the purpose, style definitions, parameter details, output summary, and two usage examples. It is comprehensive yet succinct with no filler.

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

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

Despite having no output schema, the description clearly explains the return contents (scale levels, units, guidance, CSS variables). With only two optional parameters and clear parameter documentation, plus annotations covering safety, the description is sufficient for an agent to invoke and interpret results correctly.

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

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

The input schema provides minimal descriptions for both parameters ('Radius visual style' and 'Output format'), but the description enriches them by explaining the meaning of each style enum ('sharp (minimal radius)', 'subtle (small radius)', etc.) and covering defaults. This goes beyond the schema, adding genuine semantic value despite high schema coverage.

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

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

The description clearly states the tool's function: 'Generate a border-radius scale with named levels'. It identifies the specific resource (border radius) and action (generate), and the mention of styles like sharp, subtle, rounded, pill distinguishes it from sibling UI generation tools such as color palettes or typography.

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 for when to use this tool (when needing a border-radius scale), and it gives examples for style choices. However, it does not explicitly state when not to use it or name alternative tools for other design needs, so it falls short of a perfect score.

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 already report readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral detail: it derives a color from the style preset when base_color is omitted, returns hex/rgb/hsl values with semantic role assignments and CSS custom properties, and defaults include_neutrals to true. No contradiction with annotations.

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 well-structured with a headline purpose, feature summary, Args, Returns, and Examples. It is somewhat redundant with the input schema, but each section serves a purpose and the examples are intentionally helpful, so it is not bloated.

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

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

For a tool with no output schema, the Returns section fully specifies what the agent will receive: hex/rgb/hsl values, semantic role assignments, usage guidance, and CSS custom properties. All five parameters are explained with defaults, and examples cover key usage patterns, making the description complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description supplements the schema by explaining the fallback behavior for base_color, the 11-step neutral scale, and giving three concrete usage examples, which adds real semantic value beyond the schema metadata.

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 'Generate a cohesive, harmonious color palette from a base color using color theory principles,' which clearly states the tool's verb and resource. It further specifies the supported harmony schemes and semantic color roles, distinguishing it from sibling tools like ui_generate_gradient and ui_check_color_contrast.

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 context by listing supported schemes and showing examples of when to omit base_color and rely on the style preset. However, it does not explicitly name alternatives or exclusion cases, so usage guidance is clear but not fully contrasted with sibling tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds meaningful behavioral context: tokens are 'harmonized based on the chosen style preset,' dark_mode defaults to true, and output is 'CSS custom properties, ready to paste into a project.' It does not disclose any side effects or caveats beyond that, but with strong annotations, this is sufficient.

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 well-structured with a clear summary, Args list, Returns section, and examples. Every line earns its place: it wastes no words, and the examples greatly help an agent understand real invocation patterns. It is appropriately sized for the tool's complexity.

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

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

With no output schema, the description properly explains the return value (complete token set with categories as CSS custom properties). It also covers all 4 parameters, including defaults and enums. However, there is a slight ambiguity: the Returns section says 'as CSS custom properties' without acknowledging that response_format='json' would change the output structure. Otherwise, the description is complete for the tool's moderate complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description goes beyond the schema by explaining the meaning of each parameter in the Args section (e.g., 'Override the preset's base color with a hex code') and includes practical examples for combination usage. This adds value without being redundant.

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 and resource: 'Generate a complete, cohesive design token system in a single call.' It explicitly lists the token categories it combines (colors, typography, spacing, shadows, etc.), distinguishing it from sibling tools that handle each category individually (e.g., ui_generate_color_palette, ui_suggest_typography).

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 that this tool generates the full token set at once, implying it is the comprehensive option versus the individual generators. However, it does not explicitly name alternatives or provide when-not-to-use guidance, such as 'for just a color palette, use ui_generate_color_palette.' This is clear context but lacks explicit 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?

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds context that color stops are generated automatically using color theory, and it describes the return values, which is useful given the lack of an output schema.

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 well-structured with clear sections for arguments, returns, and examples. It is somewhat lengthy but appropriate for the six parameters it documents, avoiding redundancy beyond the helpful 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?

For a tool with six parameters and no output schema, the description covers all necessary information: parameter semantics, return value composition, and usage examples. It is sufficient for an agent to invoke the tool correctly.

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

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

The input schema covers 100% of parameters, and the description enriches them with examples, default values, and explanations of direction values (analogous, complementary, triadic). This goes beyond the schema's brief 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 clearly identifies the tool as generating CSS gradients from a base color, with specific mention of linear/radial types and automatic color stop generation. It distinguishes itself from sibling tools like ui_generate_color_palette by focusing on gradients.

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 state when to use this tool over alternatives, but provides examples of different gradient configurations, implying its use case. No exclusions or alternative recommendations are given.

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 already declare readOnlyHint=true and idempotentHint=true, and the description adds valuable output details: 5 elevation levels, CSS box-shadow values, usage guidance, and CSS custom properties. It also lists supported visual styles and defaults, giving the agent a clear picture of what the tool produces without contradicting annotations.

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 organized with an opening statement, Args/Returns/Examples sections, and examples. While it is longer than necessary and duplicates some schema information, it remains readable and front-loaded with the core purpose in the first sentence.

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

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

With no output schema, the description fills the gap by specifying the return contents (elevation levels, CSS values, usage guidance, custom properties). It also provides examples of style usage. Given the tool's simple, read-only nature, this is sufficient context for an agent.

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

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

Schema coverage is 100% with descriptions for both parameters, including enums and defaults. The description repeats these details and adds examples, but does not introduce new parameter semantics beyond what the schema already conveys, 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 uses the specific verb 'Generate' with the resource 'cohesive elevation shadow system with multiple depth levels,' clearly distinguishing it from sibling tools like ui_generate_color_palette or ui_suggest_typography. The focus on shadow elevation and depth makes the tool's 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 provides clear context for use—when a design needs a shadow system with selectable styles—and includes examples for 'subtle' and 'sharp' styles. However, it does not explicitly mention alternative tools or when not to use it, so it stops short of full exclusionary 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds useful behavioral context beyond annotations, such as the return structure ('named steps (0 to 3xl), px/rem values, usage guidance, and CSS custom properties') and the meaning of the generation strategies. No contradictions with annotations.

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 compact and well-organized: a single-purpose sentence, a strategies sentence, an Args list, a Returns clause, and examples. Every sentence adds value, and the most important information is front-loaded.

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

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

For a stateless generation tool with no output schema, this description covers all necessary aspects: purpose, parameters with defaults, return value description, and usage examples. It is complete for an agent to invoke the tool correctly.

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

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

Schema coverage is 100% but property descriptions are minimal (e.g., 'Scale generation strategy'). The tool description expands on this by explaining each strategy ('linear (equal steps), geometric (exponential growth), and fibonacci (golden ratio progression)') and providing example parameter combinations, adding 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 opens with a specific verb+resource: 'Generate a consistent spacing scale for layout and component spacing.' This clearly distinguishes it from sibling generators like type scale or color palette, and the mention of multiple strategies further solidifies its 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 clear context on when to use the tool (for layout and component spacing) and gives examples for different strategies ('8px geometric scale (most common)', '4px fibonacci scale for fine control'). However, it does not explicitly mention alternatives or when not to use this tool, so it stops short of full when/why-not 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?

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds valuable behavioral details: it lists all ratio multiplier values, default parameters, and the exact output contents (px/rem, line-heights, CSS variables). This exceeds the transparency provided by annotations.

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 well-structured with Args, Returns, and Examples sections. It is front-loaded with the core purpose and each sentence delivers useful information, including the ratio enums which are essential for parameter usage. 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?

All 3 optional parameters are explained with defaults and allowed values, output format is described, and examples are provided. The annotations cover safety, and no output schema exists, so the description carries full responsibility for return values. It is fully complete.

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

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

Schema coverage is 100%, but the description enriches parameters with concrete ratio multipliers (1.067, 1.125, etc.), defaults for all params, and examples of extreme values. This adds meaning beyond the schema's simple property descriptions.

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

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

The description clearly states it 'Generate a modular typography scale using a chosen ratio' and specifies the output (sizes from 'xs' to '4xl' with px, rem, line-height, weight, usage). This specific verb+resource distinguishes it from sibling tools like color palette or spacing generation.

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: generating a typography scale for design systems. It provides examples and parameter guidance, but does not explicitly compare with alternatives like ui_suggest_typography. Clear context without 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?

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds behavioral context such as parameter defaults, supported strategies (mobile-first vs desktop-first), and the return format, which goes beyond the structured annotations.

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 well-structured with Args, Returns, and Examples sections, making it easy to scan. It does repeat default values already present in the schema, but the examples and explanatory detail justify the length. It is efficient without being overly 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?

With three optional parameters, no required fields, and no output schema, the description adequately covers what the tool returns (breakpoint definitions, container max-widths, usage guidance, CSS media queries) and provides usage examples. It is complete for a read-only generation tool, though it could mention error or edge cases.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds semantic value by explaining what 'mobile_first' means (min-width) and 'desktop_first' (max-width), plus providing concrete example combinations, which enhances the schema's brief 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 clearly states the tool's function: 'Generate a responsive breakpoint system with named breakpoints, container max-widths, and CSS media queries.' This is a specific verb+resource pairing that distinguishes it from sibling tools like color palette or typography generation.

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 by listing supported frameworks, strategies, and examples, but it does not explicitly name alternative tools or state when not to use it. Given the sibling tool list, it is obvious this is for breakpoints, so it meets the 'clear context, no exclusions' level.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral detail: it returns Google Fonts import links, CSS font-family declarations, recommended weights, and usage notes, and offers markdown/json response formats. No contradiction.

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 well-structured with a summary, Args, Returns, and Examples sections, and the key purpose is front-loaded. However, the Args section largely duplicates the schema's parameter descriptions, adding minor redundancy. Still, it remains compact and scannable.

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

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

No output schema exists, but the Returns section explicitly describes the output fields (display font, body font, Google Fonts link, CSS snippet, usage notes). All parameters, defaults, and format options are documented, and examples reinforce usage. For a simple recommendation tool, this is 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 100% coverage with enums and defaults for all 3 parameters, so the baseline is 3. The description's Args section repeats schema values, but the examples ('Get a tech-focused serif+sans mix: style="tech", category="mixed"') clarify how style and category combine, adding 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 opens with 'Suggest a curated font pairing (display + body font) based on a design style' — a specific verb and resource. This clearly distinguishes it from the sibling ui_generate_type_scale, which handles type scale rather than pairing.

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 frames the tool as a suggestion service for font pairings and lists input options (style, category, response_format) with defaults. It does not explicitly name alternatives or when-not-to-use, but the sibling set (color palette, type scale, spacing) makes the use case evident. Thus context is clear but exclusions are absent.

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