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

Annotations already carry the safety profile (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false), and the description adds genuinely useful context beyond them: the specific external destination (W3C Jigsaw), a 'bounded' size constraint, and the privacy implication that local file content is sent to a third party. It does not contradict the annotations; openWorldHint aligns with the external send.

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

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

Two sentences with zero waste; the core function is front-loaded in the first sentence and the critical security constraint lands in the second. Every word earns its place.

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

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

For a single-parameter tool with a full schema, strong annotations, and an output schema, the definition is nearly complete: it names the external service, flags the sharing boundary, and scopes the input. The only real gaps are that 'bounded' is unspecified as to the actual size cap, and there is no routing to sibling tools for related but different validations.

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

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

Schema description coverage is 100%, with filePath already described as 'Absolute or workspace-relative path to a CSS file.' The description adds only marginal qualifiers ('bounded', 'local') that do not substantially enrich parameter understanding, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Reads a bounded local CSS file and sends it to the W3C Jigsaw CSS Validator.' The domain (CSS validation) and input type (local CSS) clearly distinguish it from siblings like html.local, seo.metadata, and links.broken, so an agent can tell it apart without opening schemas.

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 (validating a local CSS file) and adds an authorization constraint ('Use only files the user is authorized to share'), but it never states when to prefer this over alternatives or when not to use it. No explicit exclusions or sibling routing 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 establish read-only, idempotent, non-destructive behavior. The description adds valuable context that the file's markup is transmitted to an external third-party service (W3C Nu HTML Checker), which explains the authorization warning. It does not detail response processing, but the output schema likely covers that.

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

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

The description is two short, front-loaded sentences with no filler. It states the core mechanism first, then the critical authorization constraint, making every word earn its place.

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

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

For a single-parameter read-only validation tool with an output schema and strong annotations, the description covers the essential operational facts: input type, external service interaction, and authorization requirement. Nothing critical is missing for an agent to decide whether and how to invoke this tool.

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

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

The schema provides 100% description coverage for the single filePath parameter, including its type and path semantics. The tool description adds tool-level context about reading local HTML but adds no new parameter-specific meaning beyond what the schema already documents, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('reads', 'sends its markup to the W3C Nu HTML Checker') and a specific resource ('local HTML file'), which clearly identifies what the tool does. The locally-scoped resource also distinguishes it from the sibling html.url without needing to inspect that tool.

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

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

The description clearly frames the tool as operating on local HTML files, and the authorization note ('Use only files the user is authorized to share') provides an important usage condition. It does not explicitly name alternatives such as html.url for remote files, but the local vs. URL distinction is strongly implied by the title and 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 declare readOnly/idempotent/non-destructive behavior. The description adds useful behavioral constraints beyond that: the fetch is 'bounded', and the tool rejects private, reserved, credentialed, and nonstandard-port URLs. 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?

Two concise sentences, each earning its place: the first states the core operation, the second states the rejection criteria. The most important action is front-loaded and there is no filler.

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

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

For a one-parameter tool with rich annotations, the description is largely complete: it covers the action, the validation target, and security constraints. It leaves open what 'bounded' means exactly and does not describe the return value, but neither is essential for a caller to select and 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 schema covers 100% of the single parameter with 'Public HTTP(S) URL on port 80 or 443'. The description reinforces the same restriction but adds no new parameter semantics, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('fetches') and resource ('public HTTP(S) page') and explains the follow-through action ('sends its markup to the W3C Nu HTML Checker'). It clearly distinguishes this as a validation tool from the sibling set (e.g., links.broken, screenshot.capture) by describing its unique pipeline.

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 for use is clearly implied: validate a public HTML page via W3C Nu. It also gives exclusions (private, reserved, credentialed, nonstandard-port destinations are rejected), but it does not explicitly name alternatives or say when not to use this versus other 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?

Beyond annotations, the description adds meaningful behavioral details: redirects are reported but not followed, and response bodies are discarded. These are important for understanding how links are checked and align with readOnlyHint and idempotentHint. 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?

Two sentences, front-loaded with the core purpose and followed by concise behavioral constraints. Every clause adds information, and there is no filler.

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

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

Given the output schema exists, return values don't need description. The description covers limit, redirect handling, and body handling, which are the key operational details an agent needs before invoking. It doesn't mention possible errors or network dependencies, but annotations and schema cover much of that 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?

Schema description coverage is 100%, so the baseline is 3. The description does not directly explain parameters but reinforces maxLinks ('up to 25') and htmlContent ('supplied HTML'), while baseUrl is left to the schema. No extra value beyond schema, but no gap.

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

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

The description clearly states the tool checks public HTTP(S) links in supplied HTML, with a precise verb ('checks') and resource ('up to 25 public HTTP(S) links'). It also distinguishes itself by noting redirects are reported but not followed and response bodies are discarded, making its function 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 implies usage for link checking in HTML but does not explicitly state when to prefer this tool over alternatives or when not to use it. It doesn't mention sibling tools like html.url or report.validation, leaving the selection partly to inference.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, lowering the bar. The description adds meaningful behavioral context by listing the exact validation categories and noting that the public-link check is 'bounded,' while also stating the report is Markdown and structured. It does not explain error behavior or the exact boundary of the link check, but the annotation coverage makes this 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 entire description is one efficient sentence with no filler. It front-loads the main purpose, enumerates the validation components in a compact list, and ends with the output format, making it easy to scan.

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

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

With a full output schema and 100% parameter schema coverage, the description does not need to re-explain return values or parameter syntax. It covers the tool's scope and output format well. The main gap is the absence of explicit guidance on when to choose this aggregator versus individual sibling tools, but the included components make that mostly inferable.

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

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

Schema description coverage is 100%, so the schema already documents htmlFilePath, cssFilePath, and baseUrl. The description's mention of W3C HTML/CSS validation and public-link checks loosely maps to parameters, but it does not add explicit parameter-level meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description uses a specific verb ('Combines') and clearly identifies the resource: a validation report covering W3C HTML/CSS, SEO/a11ility, JSON-LD, and public-link checks. It distinguishes itself from the single-purpose sibling tools by presenting this as the aggregate reporting tool, so an agent can tell them apart.

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 the tool to use when a comprehensive validation report is needed, since it explicitly bundles multiple validation types into one output. However, it does not explicitly name alternatives or state when not to use it, such as 'for a single HTML check use html.local'.

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 carry the safety profile (readOnly, idempotent, non-destructive), so the description's added value lies in the local-execution trait and the precise failure modes it reports (empty blocks, JSON syntax errors). Those behaviors are not derivable from the schema or annotations, and the semantic-validation exclusion further reduces surprise.

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 and roughly two dozen words. The main action and expected results are front-loaded, with the scope exclusion in a compact second sentence. No filler or redundant restating of the tool name.

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

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

For a single-parameter tool with full annotations and a provided output schema, the description covers input, scope, execution context, action, and non-goals. The only unaddrressed boundary is HTML that contains no JSON-LD blocks at all, a minor gap given the output schema likely handles it.

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%: htmlContent is already documented as 'Raw HTML containing JSON-LD script blocks.' The description's phrase 'supplied HTML' adds no parameter-level information beyond the schema, so the baseline of 3 applied.

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

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

States a specific verb and resource ('Parses JSON-LD blocks in supplied HTML') and names the concrete reported outcomes ('empty blocks or JSON syntax errors'). The explicit exclusion of vocabulary semantics sets it apart from the broader validation and metadata siblings despite the generic 'schema' name.

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

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

Provides clear context: it operates on locally supplied HTML and targets syntactic validation, which helps an agent decide when to reach for it. The closing limitation ('does not validate vocabulary semantics') functions as an implicit when-not-to-use, though it stops short of naming a specific sibling tool for that job.

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 carry destructiveHint=true and idempotentHint=true; the description adds useful nuance by saying existing matching files 'may be replaced' and noting the run occurs in a sandboxed local Chromium browser. This clarifies the mutation risk beyond the raw annotations, though it does not detail the output file naming pattern or external network behavior implied by openWorldHint.

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, no filler, and the core rendering-and-output behavior is front-loaded. The replacement caveat is placed at the end where it is easy to notice but does not obscure the primary purpose.

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

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

For a tool with full schema coverage, rich annotations, and an output schema, the description is largely complete: it covers input type, output type, destination, and destructive behavior. The only meaningful gap is the lack of explicit guidance on when to choose this tool over sibling tools, and the exact filename derivation for generated screenshots.

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 loosely aligns targetPath with 'local HTML file or HTTP(S) URL' and outputDir with 'requested directory,' but it does not add new meaning beyond the schema, which already documents all three parameters and the viewport structure.

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

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

The description states a specific action ('Renders a local HTML file or HTTP(S) URL'), a concrete mechanism ('sandboxed local Chromium browser'), and a clear output ('writes PNG screenshots'). It distinguishes itself from sibling validation/metadata tools by focusing on visual capture rather than analysis or reporting.

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: use this tool when a rendered screenshot of an HTML file or URL is needed. However, it does not explicitly state when to prefer this over sibling tools like html.local, html.url, or report.validation, nor does it mention any conditions 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 cover read-only, idempotent, non-destructive behavior. The description adds valuable context beyond those annotations: analysis happens locally, implying the HTML is not sent to an external service—a meaningful behavioral disclosure for privacy-sensitive usage. 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?

A single 18-word sentence that front-loads the verb and resource, then enumerates the audit scope efficiently. Every word earns its place; no filler, repetition, or hedging.

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

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

Given the tool's moderate complexity, an output schema exists for return values, annotations fully cover the safety profile, and the description enumerates the analysis areas. The only minor gap is no mention of how results are structured or presented, but the output schema handles that, so the description is complete enough 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?

Schema description coverage is 100%, so the schema already documents htmlContent as 'Raw HTML markup to inspect locally.' The description reinforces that the input is supplied HTML and lists what will be inspected, but adds no new format, encoding, or usage details beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Analyzes'), a clear resource ('supplied HTML'), and lists concrete checks: metadata, heading structure, viewport, image alternatives, Open Graph fields. While it doesn't explicitly contrast with siblings like html.local, the SEO-audit focus makes its scope reasonably distinct from the generic HTML and screenshot 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 word 'locally' and 'supplied HTML' implicitly signal that this tool is for raw HTML you already have, not for fetching a URL (contrast with html.url). However, there is no explicit when-to-use guidance, no mention of alternatives, and no exclusion statements—so the routing is left to inference.

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