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

With no annotations, the description fully bears the transparency burden. It discloses specific checks (contrast, labeling, legibility), mentions the text_contrast_failures special behavior, and states that results are always a normal report. No contradictions.

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 no redundancy. It front-loads the main action and adds a necessary clarification about text contrast failures and return type, efficiently using every word.

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 (multiple checks, 3 parameters, output schema exists), the description explains the return type and a special case but fails to describe the size and theme parameters. It is partially 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 only 33% (only description has a description). The tool description does not clarify the size and theme parameters, which are left undocumented. The description's contribution is limited to the overall tool purpose.

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

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

The description uses a specific verb 'check' and resource 'accessibility of a UI', and details the aspects checked (contrast, labeling, APCA+WCAG legibility), clearly differentiating from sibling tools like check_layout.

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 vs alternatives, nor does it mention when not to use it. The phrase 'Returns a structured report...' implies it's for assessing accessibility but lacks explicit guidance.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns a structured report and that results are normal whether problems are found. However, it does not state that the tool is read-only, describe side effects (likely none), or detail the report structure beyond a vague 'structured report'.

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, front-loads the purpose, and contains no redundant or irrelevant information. 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?

Given the presence of an output schema and three parameters, the description is incomplete. It does not explain the output schema, provide parameter context, or offer usage guidance. The tool's purpose is clear but the description lacks necessary context for correct invocation.

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

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

Schema coverage is low (33%) with size and theme lacking descriptions. The tool description does not explain any parameters, failing to compensate for the schema gap. Users are left guessing the meaning and required format of size and theme.

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 checks layout geometry for two specific issues: interactive targets below 24px hit size and signal-bearing nodes outside the window. This verb+resource combination distinguishes it from sibling tools like check_a11y, which focuses on accessibility.

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 such as check_a11y, describe_schema, or match_screenshot. It does not mention prerequisites or when not to use it.

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?

Without annotations, the description fully discloses the tool's behavior: it is structural only (shape, fields, unions) and does no semantic validation. It explicitly directs users to validate for semantic checks, leaving no hidden 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 two sentences with zero wasted words. The first sentence defines purpose and relationship; the second sentence clarifies limitations and alternative. Perfectly 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?

Given no output schema and simple inputs, the description fully explains what the tool returns (formal JSON Schema) and what it does not do (semantic checks). Comparisons with describe_vocabulary and validate complete the context.

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, so the baseline is 4. The description does not need to add parameter details, and the context signals confirm 100% 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 returns the formal JSON Schema for a fenestra/1 description, distinguishing it from the related describe_vocabulary tool by calling itself a 'structured complement' to its 'prose grammar'. The verb 'return' and specific resource are explicit.

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

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

The description tells when to use the tool (before rendering for structural validation/autocomplete) and when not to use it (for semantic checks, defer to validate). It implicitly contrasts with describe_vocabulary but does not explicitly list all 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?

No annotations exist, so the description carries the full burden. It discloses the return content (grammar, examples, color roles) but does not mention safety (read-only), limitations, or format. Adequate but not thorough.

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

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

Two sentences with no waste. First sentence defines output, second gives usage advice. Perfectly concise 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?

Given no parameters and existence of output schema, the description is largely sufficient. It could mention that the tool is safe to call or hint at output structure, but the directive to call first provides enough context.

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?

No parameters; schema coverage is 100%. The description adds no param info, but none is needed. Baseline of 4 is appropriate as the schema already covers everything.

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 returns the description grammar with node types, examples, and color roles. The phrase 'Call this first' distinguishes it as an introductory tool, differentiating it from siblings like describe_schema.

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

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

Explicit instruction to 'Call this first to learn how to author a fenestra/1 description' provides clear when-to-use guidance. No exclusions or alternatives are mentioned, but the context is sufficient for a learning tool.

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

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

With no annotations, the description fully discloses behavioral traits: it drives interaction steps first, captures frames with real motion, clamps parameters with documented ceilings to prevent hanging, and returns specific values (frame count, interval, scale, pixel dimensions, preview, resource link). This provides comprehensive 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 a single dense paragraph that front-loads the main purpose. It is informative but somewhat run-on. It could be broken into shorter sentences for better readability, but it earns its sentences without unnecessary 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?

Given the tool's complexity (7 params, no output schema), the description covers the main workflow, safety mechanisms, and return values. However, it could be more explicit about the output structure, especially since there is no output schema to fall back on. It provides a good overview.

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 71%, so the baseline is 3. The description adds context about how steps are applied and clamping, but does not add new details for the undocumented parameters (size, theme) or significantly enhance understanding of those documented. It provides process context rather than per-parameter semantics.

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

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

The description clearly states the tool's purpose: 'Render a filmstrip' with a specific verb and resource. It distinguishes itself from sibling tools by explicitly noting that 'every other tool stays reduced-motion for deterministic pixels; this is the one place the point is watching motion play', making it unique among rendering tools.

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

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

The description provides guidance on when to use this tool: for capturing motion with real motion enabled, as opposed to other reduced-motion tools. It also explains the optional interaction steps and clamping behavior, but could more explicitly list alternative tools and when not to use it.

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 discloses key behaviors: returns data, honors focus traps, excludes disabled controls, and does not drive the UI. However, it does not mention permissions, rate limits, or performance characteristics. Still, provides sufficient transparency for a read-only query tool.

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

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

Two concise sentences with no filler. Every sentence adds meaningful information about the tool's function and behavior.

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

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

Adequate but incomplete: return format is implied but not explicit ('refs... in order'). Output schema exists but is not shown; description suffices for that. However, parameter coverage is lacking for size and theme, making it less complete for a tool with 3 parameters.

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

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

Schema coverage is low (33%) with only 'description' documented in schema. The tool description adds no further detail for 'size' or 'theme', leaving them unexplained. The description does reiterate the 'description' parameter's purpose but does not compensate for missing parameter info.

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?

Clearly states the tool returns keyboard focus order (Tab cycle refs) honoring modal focus traps and excluding disabled controls. Distinguishes from sibling tools like check_a11y by specifying it's about focus order and not driving the UI.

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

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

Implies use case for verifying tab order and reachability, but does not provide explicit guidance on when to use versus alternatives (e.g., check_a11y might also focus on accessibility). No when-not-to-use or alternative tool names 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns 'the emitted intent messages and the access tree afterwards' and that a screenshot can be requested. It also clarifies the interaction method (semantic selectors, not coordinates). However, it does not mention side effects, permissions, or whether interactions are synchronous, which would improve 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 two sentences with no redundant information. It front-loads the core action ('Drive a UI through scripted interactions'), then specifies supported actions, constraints, and return values. Every sentence is necessary and contributes to understanding.

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 (5 parameters, no output schema, no annotations), the description provides essential information about purpose and returns but misses contextual details like error handling, sequencing (e.g., need to render UI first), or any limitations. It is adequate for a simple use case but lacks completeness for robust agent decision-making.

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 60%. The description adds value for the 'steps' parameter by providing an example format, and for 'screenshot' by explaining its effect. However, parameters like 'size', 'theme', and 'description' are not elaborated beyond the schema, leaving the agent to rely on their names. The description partially compensates for gaps but does not fully cover all 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: 'Drive a UI through scripted interactions' and lists supported actions (click, type, key, tab, hover, wheel, drag) with the constraint 'by semantic selector, never coordinates'. This distinguishes it from sibling tools like render_ui (which renders) and query_ui (which queries). The verb 'Drive' with 'scripted interactions' is specific and unambiguous.

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

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

The description implicitly guides usage by specifying 'by semantic selector, never coordinates', but it does not explicitly state when to use this tool versus alternatives like run_scenario or describe_schema. No exclusion criteria or prerequisites (e.g., needing a rendered UI) are mentioned, leaving the agent to infer 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 must fully disclose behavioral traits. It only states it matches and returns a diff, but does not mention side effects, error behavior, or required permissions. The phrase 'a normal result' is vague.

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

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

The description is a single sentence that packs the key elements (purpose, modes, result). It is concise without extraneous text, though a slightly more structured format could improve readability.

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 output schema exists, return values are sufficiently explained. However, with 5 parameters and a non-trivial matching behavior, the description lacks details on how mode affects matching and what constitutes pass/fail. Leaves gaps for an agent to infer.

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 60%. The tool description adds meaning for 'mode' (lists values) and 'expected' (aria snapshot), but 'size' and 'theme' are not elaborated. The description provides some context but does not fully compensate for the missing schema 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?

Clearly states verb 'match', resource 'accessibility snapshot' against UI, and specifies the grammar format (Playwright `- role "name" [attr]`). Distinguishes itself from siblings like check_a11y and match_screenshot by focusing on ARIA snapshots.

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?

Mentions three modes (partial, strict, regex) and returns a pass/fail diff, but does not provide guidance on when to use each mode or compare to alternative tools. Lacks 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?

No annotations are provided, so the description carries the full burden. It describes the comparison operation and output, but does not mention side effects (e.g., read-only, destructive), required permissions, or behavior when baseline is missing. It is adequate but not fully transparent.

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

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

The description is a single, concise sentence that includes all key aspects (comparison, baseline path, tolerance, budget, masks, return value). It is front-loaded with the main action, but its density could be slightly improved by splitting into two sentences.

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 and absence of an output schema, the description covers core functionality but misses details on the return format (e.g., diff stats structure) and prerequisites (e.g., baseline file existence, UI state). It is adequate for basic understanding 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?

The description adds meaning beyond the schema by explaining tolerance as per-channel, budget as allowed differing-pixel fraction, and masks as volatile region ignore. However, it does not cover all parameters (e.g., 'description' param is not mentioned). Schema coverage is 71%, so description adds good context.

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

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

The description clearly states the tool compares a UI render against a baseline PNG pixel by pixel, with specific optional parameters (tolerance, budget, masks) and return value. This distinguishes it from sibling tools like check_layout or match_aria_snapshot.

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

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

The description explains what the tool does but does not explicitly state when to use it versus alternatives, nor does it provide exclusion criteria. The purpose implies usage for visual regression testing, but no direct guidance is 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?

The description discloses two key behaviors not implied by the name: stable references and return of nearest candidates on a miss. This adds transparency beyond the name, though it does not explicitly state read-only nature (no annotations provided).

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 succinct sentences: the first states the core function, the second adds critical error-handling behavior. No wasted words, front-loaded with the action.

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

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

Adequate for a query tool with output schema present, but incomplete regarding parameters size and theme. The description covers the main behavior but misses input details for two of four parameters.

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

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

With 50% schema description coverage, the description adds minimal parameter context. Only the 'selector' is explained via an example in the schema; size and theme are undocumented in both schema and description, leaving their purpose unclear.

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 finds UI nodes using a semantic selector and lists selector fields (role, name, value, or id). It also specifies the outcome: returns matches with stable refs or nearest candidates on a miss, distinguishing it from sibling tools like check_a11y.

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 the 12 sibling tools (e.g., check_a11y, interact). No mention of alternatives, prerequisites, or conditions for use.

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, description discloses that tool returns a typed accessibility tree, downscaled preview, and automatic accessibility warnings. It also notes that full-resolution PNG comes as a resource_link and advises reading the access tree first. This provides useful behavioral context beyond a simple 'render' statement.

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

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

Three sentences, no redundancy. First sentence lists core outputs, second sentence gives action guidance (read tree first), third clarifies image format. Front-loaded with most important info.

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 output schema, description adequately explains what the tool returns (tree, preview, warnings, resource_link). Siblings suggest alternative rendering/comparison tools, but description is sufficient for an agent to understand the tool's role.

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 schema already describes parameters completely. The description adds no additional meaning beyond what the schema provides for 'description', 'size', or 'theme'. 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 clearly states verb ('Render') and resource ('fenestra/1 UI description'), lists three specific outputs (accessibility tree, preview image, warnings). Does not explicitly differentiate from siblings like film_ui or match_screenshot, but the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives like film_ui or match_screenshot. No 'when not to use' advice or context about prerequisites. The description assumes the agent knows to use it for rendering, but lacks explicit selection criteria.

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

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

With no annotations, the description fully bears the burden and discloses key behaviors: drives steps, asserts expectations, compares screenshot post-interaction, returns a report with ok and breakdown, provides preview (diff image on mismatch). It also clarifies that failed checks are normal.

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 paragraph with clear front-loading of purpose. While informative, it could be slightly more concise by merging some sentences. Overall, no unnecessary verbiage.

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 output schema, the description adequately explains the return format (report with ok and per-check breakdown, preview image). It covers the scenario components, execution, and handling of failures, making it complete for a complex tool.

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

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

Schema coverage is 100% (only one parameter), and the description adds meaningful context beyond the schema by elaborating on the scenario structure (fenestra/1 description, steps, expect bundle).

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 runs a verification scenario in one pass, listing components (fenestra/1 description, steps, expectations). This distinguishes it from sibling tools that perform individual checks (e.g., check_a11y, interact).

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

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

The description explains what the tool does but does not explicitly state when to use it versus alternatives (e.g., using individual tools for step-by-step verification). While the purpose implies it's for a combined run, no exclusions or alternatives 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 the full burden. It explains that structural and semantic errors are detected and returned 'path-pointed', and that 'isError' indicates invalidity. However, it does not mention if the tool is read-only, any side effects, or authentication needs.

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 no extraneous content. The first sentence states the core function, the second details types of errors found. It is efficiently 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?

Given no output schema, the description should clarify the return structure more fully. It mentions 'path-pointed' errors and 'isError', but does not specify the actual response format or fields. For a simple single-parameter tool, it is adequate but not complete.

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

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

The input schema already describes the parameter as 'The UI description: a fenestra/1 JSON object.' The description adds value by explaining what validation entails (structural and semantic checks), going beyond the schema's minimal 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 validates a 'fenestra/1' description, specifying the action and the resource. It also distinguishes itself by noting 'without rendering', contrasting with siblings like 'render_ui'.

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 when validation without rendering is needed, but does not explicitly state when it should be used over siblings like 'check_a11y' or 'check_layout'. No exclusions or alternatives are given.

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