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

Beyond the readOnlyHint annotation, the description discloses the return shape ('0-100 score with per-category breakdown and actionable recommendations') and defines the scope of what is—and isn't—analyzed. This adds meaningful behavioral context 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 compact and front-loaded: it opens with the core action, lists the evaluated dimensions, describes the output, and closes with an explicit exclusion and alternative. Every sentence contributes value, and there is no redundant wording.

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

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

For a 3-parameter tool with no output schema, the description supplies the essential operational context: what it analyzes, the result format, and its boundary relative to audit_onpage. Required parameters are fully covered by the schema, and no critical invocation detail is missing.

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

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

Schema description coverage is 100%, so the schema already documents url, locale, and timeout. The description adds only slight context by mentioning 'multilingual' readability, which relates to locale, but it does not substantially expand parameter semantics beyond what the schema provides.

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

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

The description clearly identifies the tool's purpose with a specific verb ('Analyze content quality of a web page') and enumerates the concrete aspects it evaluates: word count, readability, text-to-HTML ratio, heading structure, link density, media richness, and engagement signals. It also explicitly distinguishes itself from audit_onpage by stating what it does NOT check, making it easy for an agent to select the correct 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 gives explicit guidance by stating that it does not check SEO meta tags and directs the agent to 'use audit_onpage for that'. This establishes a clear condition for choosing between audit_content_quality and its sibling tool, which is sufficient for correct tool selection.

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

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

Annotations already declare readOnlyHint=true, and the description adds that the tool 'Returns a list of technical issues found', informing the agent about output shape. It also discloses the full technical scope of the audit, so the agent knows which aspects are inspected. This complements the read-only annotation without contradicting it.

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-loads the core purpose in the first sentence, followed by a clear enumeration of checks and exclusions. The long list of checks is warranted because it defines the audit scope. No filler or redundancy is present.

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 high schema coverage and a read-only annotation, this description is largely sufficient: it defines scope, exclusions, and return type. It does not mention how the audit handles JavaScript-rendered content or edge cases like non-HTML responses, but these are minor given the simple input and read-only safety. Overall it positions the tool well among the many sibling check tools.

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

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

The single parameter url is already fully documented in the schema with 'The URL to audit for on-page technical issues', so schema description coverage is 100%. The description adds no additional parameter-level detail, but the schema fully covers the parameter. Baseline 3 is appropriate given the 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 opens with 'Technical on-page HTML audit', a specific verb-resource pair, then enumerates exactly which elements are checked (title, meta description, canonical, robots, lang, headings, images alt, OG, Twitter Card, structured data). It explicitly lists what it does NOT analyze (keywords, rankings, backlinks, traffic), which distinguishes it from analytics-focused tools. This makes the tool's purpose unmistakable among siblings.

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 when to use this tool: when a technical on-page HTML audit covering the listed elements is needed. It explicitly excludes keyword/ranking/backlink/traffic analysis and directs users to Semrush for those. However, it does not name sibling tools or specify when to choose this over check_structured_data or check_accessibility for narrower checks.

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 readOnlyHint=true already covering safety, the description adds useful behavioral context: it collects URLs from configurable sources, runs a 'lightweight' audit, and returns aggregate scores, top problems, quick wins, and critical pages. This goes beyond the annotation without contradicting it.

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 short sentences, each earning its place: what the tool does, how it collects URLs, and what it returns. The core 'batch audit' behavior is front-loaded, and there is no filler or redundant phrasing.

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

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

The description explains the input source options and the main output categories (aggregate scores, problems, quick wins, critical pages), which is adequate given there is no output schema. It could mention behavior around the urls parameter or defaults, but the schema already covers parameter-level details.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description adds some context by tying the source parameter to the 'sitemap, crawl, or a provided list' behavior, but it does not add meaningful detail 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 a specific action ('Batch audit multiple pages'), a resource ('a site'), and the method of URL collection ('sitemap, crawl, or a provided list'). It distinguishes itself from single-page audit siblings like audit_onpage by emphasizing batch and aggregate behavior.

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

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

Usage context is implied: this tool is for auditing multiple pages in batch, while siblings like audit_onpage or crawl_site cover narrower or different tasks. However, the description never explicitly says when to prefer this tool over those alternatives 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?

Annotations provide readOnlyHint=true, which the description does not contradict. The description adds valuable behavioral detail: parallel execution of three sub-tools and the production of a unified report with score, severity, and cross-tool diagnosis.

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

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

The description is one sentence with no filler. It front-loads the core purpose, names the components, and summarizes outputs efficiently.

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

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

With no output schema, the description adequately conveys what the tool returns at a high level. It could specify score ranges or failure behavior, but for a single-parameter read-only audit tool, the key context is 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?

The schema already fully documents the single 'url' parameter with type and format, and schema description coverage is 100%. The description adds no new meaning to the parameter itself, so a 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 operation ('Full tracking audit'), lists the exact sub-tools it runs, and describes the output (unified report with global score, severity summary, cross-tool diagnosis). This clearly distinguishes it from the individual 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 clearly positions audit_tracking as the comprehensive combined audit option relative to the individual check tools. It does not explicitly state when not to use it, but the context is clear enough for an agent to choose it over a single check.

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 only provide readOnlyHint=true, so the description carries responsibility for behavioral context. It goes beyond that by explaining the audit is lightweight, returns a 0-100 score with per-category breakdown, references WCAG criteria, and omits two categories due to technical constraints. This is valuable and consistent with the read-only annotation.

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. The first sentence states the core action clearly. The second enumerates check scopes efficiently, and the third delivers return value and limitations without padding. Every sentence 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?

There is no output schema, but the description fully specifies what the tool returns: a score, per-category breakdown, WCAG references, and actionable issues with CSS selectors. The limitations are stated explicitly. For a read-only audit tool with two simple parameters, no critical contextual information is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the url and timeout parameters. The description adds nothing about parameter usage or format, but it does not need to because the schema covers everything. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Run a lightweight WCAG accessibility audit on a web page.' It enumerates concrete check categories (alt text, form labels, landmarks, heading hierarchy, etc.) and clearly distinguishes this tool from performance, mobile, and other audit siblings by focusing solely 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 clear boundaries of what the tool covers and explicitly states what it does not check ('Does NOT check color contrast or keyboard navigation') along with the reason ('requires browser rendering'). It does not name specific alternative tools, but the explicit limitations give an agent enough context to decide when this tool is inappropriate.

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 readOnlyHint=true, the safety profile is already covered by annotations. The description adds value by disclosing that the tool returns a 0-100 GDPR compliance score with detailed findings and clarifying that the operation is an audit rather than a modification. No side-effect claims are made, and none are needed.

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

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

The description is two sentences with zero filler. The main purpose is front-loaded, the detailed checks are compactly listed, and the return value is stated in the final clause. It does not waste space repeating schema or annotation information.

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

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

There is no output schema, but the description explicitly states that a 0-100 compliance score and detailed findings are returned. Together with the fully documented input schema, this gives an agent everything needed to invoke the tool correctly and interpret its result.

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

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

Input schema coverage is 100%, with clear descriptions for both url and wait_ms. The description does not add parameter-specific detail, but none is required because the schema already documents the parameters adequately. Baseline 3 is appropriate.

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

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

The description opens with a specific verb ('Audit') and precise resource ('Google Consent Mode v2 implementation and cookie compliance'), then enumerates the exact checks performed: CMP vendor detection, consent default/update configuration, IAB TCF API, GA4 gcs/gcd signals, and pre-consent cookie behavior. This clearly distinguishes it from generic tracking or GTM-related 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 makes the intended use case evident: consent-mode and cookie-compliance auditing. It does not explicitly name alternatives or exclusion conditions, such as when to prefer audit_tracking or check_gtm_snippet, but the context is clear enough for an agent to select it correctly.

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 supply readOnlyHint=true, and the description adds meaningful context: it loads the page in a headless browser, waits for runtime state, and looks for a specific anomaly (dataLayer redefinition after GTM init). No contradiction with the read-only annotation; the description supplements it.

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. The core function is front-loaded and the enumerated checks are packed into the second sentence without redundancy.

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

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

The description tells the agent what it checks and how (headless browser, runtime), which is sufficient to invoke it correctly. The absence of an output schema is partly mitigated by the explicit list of checks, though the exact result shape is left unspecified.

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 both url and wait_ms are already documented. The description does not add parameter-level detail, which is acceptable given the schema handles it; 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?

Description opens with a specific verb-resource pair: 'Inspect window.dataLayer at runtime using a headless browser,' which clearly distinguishes it from static HTML checks like check_gtm_snippet or network-based tracking checks. It then enumerates the exact checks performed (existence, contents, GTM/gtag load state, suspicious redefinition patterns), so an agent can tell what this tool is for.

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

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

The phrase 'at runtime using a headless browser' implies the tool is for observing the live dataLayer state, rather than static source inspection. However, it does not explicitly say when to prefer this over siblings such as check_gtm_snippet, intercept_tracking_requests, or audit_tracking, nor does it state any 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?

The readOnlyHint annotation already marks this as safe, and the description adds meaningful behavioral detail beyond that: what exactly is detected (IDs), what is verified (placement, noscript, duplicates). This gives the agent a good sense of the tool's results and limitations without overstating scope.

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

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

Two sentences with no filler. The first sentence states the core action, and the second lists the concrete verifications. Every word earns its place, and the 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 single-parameter, read-only tool, the description is quite complete: it outlines the specific checks performed. It doesn't describe the output format, but with no output schema and a straightforward detection tool, the absence is acceptable. Minor gaps like whether the page is rendered or whether snippets in subframes are checked don't undermine overall callability.

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 fully describes the single 'url' parameter with 100% coverage, so the description does not need to elaborate much. It adds minimal extra meaning beyond confirming that the page is checked; the description aligns with the parameter's purpose but doesn't provide additional format or usage details.

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

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

The description uses a specific verb ('Check') and resource ('a page for Google Tag Manager (GTM) and gtag.js snippets'), and then enumerates distinct detection capabilities: container IDs, GA4 measurement IDs, snippet placement, noscript fallback, and duplicate IDs. This clearly differentiates it from sibling tools like check_datalayer or audit_tracking, which focus on other aspects of tracking.

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 conveys a clear use case: verifying the presence and correctness of GTM/gtag snippets on a page. It does not explicitly name alternatives or state when not to use the tool, but the focused scope makes the intended usage evident given the sibling list.

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 readOnlyHint=true, and the description adds meaningful behavioral context: exactly which validations are performed, that URL accessibility is checked, and that it returns a 0-100 score with per-alternate analysis. This goes beyond the annotation without contradicting it.

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: purpose first, then the list of checks, then the output format. Every sentence adds information and there is no filler or redundancy.

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

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

For a read-only audit tool, the description covers the input (a URL), the behavior (multiple concrete checks), and the output (0-100 score plus per-alternate analysis), which is especially important because there is no output schema. It provides enough information for an agent to select and invoke the tool correctly. No critical detail appears missing.

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

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

Schema description coverage is 100%, with url, timeout, and followAlternates already documented in the input schema. The description provides conceptual context, such as 'reciprocal linking', but does not need to restate parameter details; 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 a specific verb, 'Validate', identifies the resource, 'hreflang alternate language tags on a page', and lists concrete checks such as ISO 639-1 validity, reciprocal linking, x-default presence, and canonical consistency. This clearly distinguishes it from sibling audit tools like check_links, check_structured_data, or audit_onpage.

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 context is strongly implied by the domain-specific first sentence: an agent would know to use this when hreflang validation is needed. However, it gives no explicit when-to-use/when-not-to-use guidance and names no alternatives, so the agent must infer routing rather than being told.

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 readOnlyHint annotation already signals a safe read operation, so the bar for behavioral disclosure is lower. The description adds useful context by enumerating exactly which signals are analyzed and stating that the tool returns a verdict with detailed reasoning, which helps the agent understand the tool's scope and output style.

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 concise sentences with no wasted words. It front-loads the core purpose, then efficiently lists the analyzed factors and the expected return shape.

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 tool, the description is complete enough: it states the input, the checks performed, and the nature of the output. It does not specify the exact verdict format, but given the absence of an output schema, the phrase 'verdict with detailed reasoning' provides sufficient expectation-setting 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?

The schema already fully describes the only parameter ('url') with 100% coverage. The description adds no additional parameter-level semantics beyond confirming that the URL is a page to check, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific action ('Check if a page is indexable'), a concrete resource (a page), and the key factors analyzed. It distinguishes itself from sibling tools like check_robots_txt and check_hreflang by presenting a broader composite check that returns a verdict rather than a single-factor 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 gives clear context on when to use the tool: when an overall indexability assessment is needed for a page. It does not explicitly name alternatives or exclusion conditions, but the list of analyzed signals makes the intended use evident and distinct from narrower 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?

With readOnlyHint=true already covering the safety profile, the description adds meaningful behavioral context: it performs network-level checks, detects 404/timeout/connection errors, and returns categorized results with status codes. It does not go into rate limiting or external request volume, but that is partially covered by the delay/concurrency parameters.

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

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

Two sentences with no wasted words. The main purpose is front-loaded, and the return value is stated immediately after 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?

For a page-level, read-only link checker with fully documented parameters, the description adequately covers scope, purpose, and return output. Since there is no output schema, the explicit mention of broken/redirected/OK with status codes provides the key information an agent needs.

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

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

Schema description coverage is 100%, and the description adds no parameter-specific meaning beyond what the schema already documents. Baseline 3 applies because the schema carries the full parameter-documentation burden.

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 action ('Check all links') with a clear resource ('a web page') and explicit outcome categories (broken, redirected, OK with status codes). This makes it easy to distinguish from siblings like extract_links and check_redirect_chain.

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 the tool: to discover broken or misbehaving links on a single page. It does not explicitly name alternatives or exclusions, but the purpose is unambiguous enough that an agent can 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?

With readOnlyHint=true, the safety profile is already known. The description adds meaningful behavior: headless browser execution, exact viewport (375x812), mobile User-Agent, and the specific checks performed. It also discloses the return of a mobile screenshot, going beyond the annotation.

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-loading the core purpose and context. Every detail (viewport size, user-agent, check categories, screenshot output) earns its place without redundancy or filler.

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

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

The tool is simple (one parameter, no output schema), and the description captures the inputs, execution context, checks, and output. It does not explicitly state what form the audit findings take beyond the screenshot, but the provided detail is sufficient 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?

The schema covers 100% of parameters—only 'url'—with a clear description. The tool description does not add parameter-specific semantics, but none are needed since the schema is complete and the parameter is self-explanatory. 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 ('Audit') with a clear resource ('a web page for mobile-friendliness') and lists concrete checks (viewport meta, horizontal scroll, font sizes, tap target sizes). This clearly distinguishes it from siblings like screenshot, check_performance, and check_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 establishes a clear context for use: when a mobile-friendliness audit is needed, using a specific iPhone viewport and mobile user-agent. It does not explicitly name sibling tools or state when not to use it, 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?

Annotations already indicate readOnlyHint=true, and the description adds meaningful behavioral context: it uses a headless browser, applies network throttling on mobile, and returns a score, timings, network stats, and actionable issues. This goes beyond the annotation without contradicting it.

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 wasted words: the first names the metrics and method, the second states profiles and return value. Information is front-loaded and highly 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?

For a tool with no output schema, the description adequately enumerates the return categories (0-100 score, detailed timings, network stats, actionable issues) and the supported device profiles. Slight gaps remain around the exact shape of the output and any execution-time or cost implications, 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 coverage for parameters is 100%, so the schema already documents url and device with descriptions including dimensions and throttling. The description mostly restates the device behavior already in the schema, adding no new parameter-specific meaning.

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 ('Measure') with a clear resource ('web page performance metrics') and enumerates the exact metrics measured (TTFB, FCP, LCP, DOM Content Loaded, Fully Loaded). This clearly differentiates it from sibling tools like check_mobile or check_links.

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 the tool: when performance metrics and a performance score are needed, with support for mobile and desktop profiles. It does not explicitly name alternatives or exclusions, but no obvious sibling tool directly competes with 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?

readOnlyHint=true already establishes safety; the description adds value by revealing the method (manual redirect), the per-hop output fields, and the built-in detections (loops, long chains, HTTP→HTTPS). No contradiction; it omits potential network latency or partial-result behavior, but these are not critical for selection.

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 short sentences, each carrying distinct information: action/scope, return contents, and anomaly detection. No filler or repetition of schema data.

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 does enough by specifying per-hop fields and the anomalies detected, but it does not specify the exact shape of the result or behavior when maxRedirects is exceeded. This is a minor gap for a relatively simple read-only 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?

Input schema already provides 100% coverage, documenting both url and maxRedirects with types/defaults/constraints. Description doesn't add parameter-level detail beyond implying the hop-by-hop nature, so 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?

Description opens with a specific verb ('Follow') and resource ('redirect chain of a URL'), explicitly frames the action as hop-by-hop manual redirect, and specifies the outputs (status, Location, Server). This differentiates it clearly from sibling fetch/crawl/link-checking 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 intended context is evident: use when you need to inspect redirect behavior, loops, or protocol upgrades. It does not name alternatives or state when not to use it, but the focus is clear enough for an agent to select it over fetch_page or check_links.

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, so the safety profile is covered. The description adds behavioral context beyond the annotation by detailing the multi-step analysis: parsing directives, fetching/checking sitemap accessibility, and detecting inconsistencies. It does not mention edge cases like missing robots.txt, but the provided details go beyond what annotations convey.

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 well-structured sentence with a colon introducing a concise list of capabilities. Every phrase adds value, and the main action is front-loaded. No fluff or redundancy.

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

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

For a single-parameter, read-only analysis tool with no output schema, the description is complete: it names the resource, the operations performed, and the type of findings (undeclared sitemaps and inconsistencies). The schema covers input semantics, and annotations cover safety, so nothing essential is missing.

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

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

Schema description coverage is 100%: the 'url' parameter is described as 'The site URL (robots.txt will be fetched from the origin)'. The tool description adds no additional parameter-level semantics, so the baseline 3 applies. The parameter meaning is fully captured by the schema and the tool's purpose.

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

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

The description uses a specific verb ('Analyze') with a clear resource ('a site's robots.txt') and enumerates the exact analyses performed: parsing Allow/Disallow rules per User-Agent, Crawl-delay, declared sitemaps, and cross-checking sitemap accessibility. This clearly distinguishes it from siblings like parse_sitemap or fetch_page.

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

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

The description establishes a clear context: use this tool when you need robots.txt analysis including rule parsing, sitemap declarations, and consistency checks. It does not explicitly mention alternatives or exclusions, but the purpose is specific enough that an agent can infer when it is appropriate.

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

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

The readOnlyHint annotation already covers the safety profile, so the description's burden is low — and it exceeds it. It discloses the return contract (0-100 score, A-F grade, per-header analysis, actionable recommendations) and the execution profile (single HTTP request, no browser). This helps the agent set expectations for cost and output without an output schema. No contradiction with annotations; 'audit' is consistent with readOnlyHint=true.

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, each earning its place: the first states purpose, the second defines the output contract, the third communicates the resource profile. The most decision-relevant information is front-loaded. Zero filler, no repetition of schema or annotation content.

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 tool with no output schema, the description is contractually complete: the agent knows what is audited, what result shape to expect, and what the operation costs. Minor assumptions (e.g., URL must be publicly reachable, redirect handling) are acceptable for a tool of this simplicity. Nothing decision-critical is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the url parameter ('The URL to audit for security headers'). The description reinforces the URL-as-target relationship by mentioning the audited headers, but adds no extra parameter-level semantics such as URL format constraints, protocol handling, or redirect behavior. 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 opens with a specific verb-plus-resource: 'Audit HTTP security headers,' and enumerates concrete examples (HSTS, CSP, X-Frame-Options, Referrer-Policy, Permissions-Policy). This makes the tool unmistakably distinct from siblings like check_performance, check_redirect_chain, or check_mobile, which audit different dimensions. The scope is precise and self-identifying.

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

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

Usage context is implied rather than explicit. The 'lightweight — single HTTP request, no browser needed' note gives a meaningful hint about when this tool is appropriate (fast, cheap header spot-checks) versus heavier browser-dependent siblings like screenshot or crawl_site. However, the description never names alternatives or states when-not-to-use conditions, leaving routing to inference.

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

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

The readOnlyHint annotation already signals this is a safe read operation. The description adds meaningful behavioral scope by specifying exactly which structured data formats are handled and which JSON-LD types receive validation. However, it does not disclose return format, validation reporting style, or any limitations, which would have made it more 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 well-constructed sentence that front-loads the core action and resource, then packs the supported formats and validation types into a compact, readable list. There is no redundant wording or filler, and every clause contributes useful information.

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

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

With one fully described parameter, a read-only annotation, and no output schema, the description explains the input and scope adequately. However, it omits what the agent should expect as output—raw extracted data, validation errors, a report, or a combination—which is important since there is no output schema to fill that 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?

The schema covers 100% of the single parameter, url, with a description that clearly states it is 'The URL to extract structured data from'. The tool description adds no additional parameter-level meaning, so the schema carries the full burden. Baseline 3 is appropriate because the schema already does the job.

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 phrase, 'Extract and validate', and a clear resource, 'structured data from a web page'. It goes further by enumerating the exact formats covered (JSON-LD, Microdata, Open Graph, Twitter Card) and calling out type-specific validation for Product, Organization, BreadcrumbList, and Article. This makes the tool easily distinguishable from siblings like fetch_page or extract_content.

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

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

The description implies the tool should be used when structured data extraction or validation is needed, but it gives no explicit guidance on when to choose this tool over closely related siblings such as extract_with_schema or check_datalayer. There are no stated exclusions, prerequisites, or alternate tool recommendations.

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

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

readOnlyHint=true already declares the safety profile, lowering the bar. The description adds genuine behavioral context beyond the annotation: the tool analyzes 10 specific SEO dimensions and optionally captures screenshots of both pages, implying a heavier fetch-and-render operation. It does not disclose return format or failure behavior for inaccessible URLs, but the annotation covers the core safety concern.

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 filler: the primary action and scope are front-loaded, the criteria are packed into an efficient enumeration, and the optional screenshot behavior sits at the end. Every element 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 tool with no output schema, the description gives no hint of the return format — an agent cannot tell whether screenshots are returned as URLs or data, or whether the comparison comes back as a table or structured report. Prerequisites (both URLs must be publicly accessible) and error behavior for one failing URL are also unaddressed. The full parameter schema and readOnly annotation compensate partly, but the missing return-value context is a real gap.

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

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

Schema description coverage is 100%, so the baseline of 3 applies — urlA, urlB, and includeScreenshot are already documented with useful descriptions including the JPEG quality 60 detail. The description's mention of 'Optionally captures screenshots' is redundant with the schema's includeScreenshot description, adding no new parameter meaning.

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

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

The description states a specific verb and resource — 'Compare two web pages side by side' — and enumerates the exact SEO criteria (title, meta description, headings, word count, links, images alt, Open Graph, Twitter Card, JSON-LD, canonical). The two-page comparison scope clearly distinguishes it from the 30 siblings, none of which perform side-by-side comparison.

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 use case is implied by the description: call this when you need a side-by-side SEO comparison of two pages. However, there is no explicit when/when-not guidance or alternative routing, e.g., no 'for a single-page audit use audit_onpage' or 'for screenshots alone use screenshot', despite those siblings covering overlapping functionality.

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 readOnlyHint annotation already communicates that the tool is non-destructive. The description adds meaningful behavioral detail beyond that: it follows internal links, respects depth and page limits, and returns discovered pages with titles and status codes. This is a reasonable level of transparency for a read-only crawler.

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 and every sentence adds value: it states the core action, the recursive behavior, the key limits, and the output format. There is no redundant or filler content.

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, combined with a fully described input schema and the readOnlyHint annotation, gives an agent enough context to invoke the tool correctly. It explains the main behavior and output, even without an output schema. Minor details like how external links are handled or exact error conditions are not described, but they are not essential for calling the tool.

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

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

Schema coverage is 100%, so the parameter descriptions already document each input. The description adds little beyond the schema; it mentions depth and max pages but these are already described directly in the input schema. It does not introduce any new meaning that the schema does not already provide.

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

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

The description clearly states a specific action ('Crawl a website recursively starting from a URL'), names the resource, and describes the recursive link-following behavior and output. It is easy to distinguish from sibling tools like fetch_page or parse_sitemap because it uniquely identifies full-site recursive crawling.

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 this tool is appropriate: when you need to recursively crawl a website from a starting URL and discover pages. It does not explicitly name alternatives or say 'when not to use', but the recursive crawling language strongly implies this is for site-wide discovery rather than single-page fetches or sitemap parsing.

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, and the description adds meaningful behavioral context beyond that: which page elements are analyzed, how near-duplicates are determined, and that results are grouped. This gives an agent realistic expectations about the analysis logic without contradicting the read-only annotation.

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 tight sentences, front-loaded with the core action and then adding supported sources. No filler or redundant restatement of the tool name. Every sentence contributes useful information.

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

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

The description covers the main purpose, the analyzed content areas, the duplicate detection logic, and supported page sources. Since there is no output schema, a bit more detail about the result shape would be ideal, but the description still provides enough context for a correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters. The description adds context about source modes and analysis scope, but it does not add meaningful parameter-level semantics beyond the schema. Baseline 3 is appropriate.

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

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

States a specific action ('detect duplicate and near-duplicate content'), a clear resource ('a site's pages'), and the distinct behavior of grouping exact duplicates while identifying near-duplicates by word similarity. This distinguishes it from sibling tools like audit_content_quality or compare_pages. The purpose is immediately understandable.

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 when to use this tool: whenever the agent needs duplicate or near-duplicate content analysis. It also indicates the supported page sources (sitemap, crawl, URL list), which helps route the invocation. It does not explicitly exclude alternatives, so it falls just 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?

Annotations already mark readOnlyHint=true, so safety is covered. The description adds useful behavioral context: it performs a crawl, cross-references data sources, and outputs specific analyses (classification, hubs, coherence stats). This goes beyond the annotation without contradicting it, though it does not disclose potential rate-limit or sitemap-missing edge cases.

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, each adding distinct value: the first states the action and method, the second details the specific page categories found, and the third summarizes the output types. Information is front-loaded and there is no redundant phrasing or wasted words.

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

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

For a read-only analysis tool with no output schema, the description sufficiently conveys what it returns (classification, hubs, coherence stats) and what it requires (a URL, crawling, sitemap cross-referencing). It doesn't detail the output structure or behavior when a sitemap is absent, but given the annotations and 100% parameter coverage, these are minor gaps.

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

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

Schema description coverage is 100%, so each parameter is already documented (url, delay, crawlDepth, concurrency, maxCrawlPages). The description adds no parameter-specific meaning beyond what the schema provides; it refers generally to crawls and sitemaps but doesn't clarify any of the parameters or their interplay. Baseline 3 is appropriate given full 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 opens with a specific verb phrase 'Detect orphan pages' and a resource, then explains the method (cross-referencing sitemap URLs with crawled pages and internal link graph). It explicitly enumerates the categories of pages it identifies, which clearly differentiates it from sibling tools like crawl_site or parse_sitemap, even without naming them.

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

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

The intended use is implied by the tool's purpose: use it to find orphan pages or analyze sitemap/crawl coherence. However, there is no explicit 'when to use' guidance, no exclusions, and no mention of alternatives (e.g., 'if you only need a crawl, use crawl_site'). The description relies on the agent inferring suitability from the tool name and first sentence.

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 readOnlyHint annotation already establishes that the tool performs a read-only operation, lowering the disclosure burden. The description adds useful context about the output composition (headings, paragraphs, images, links, statistics) but does not reveal behavioral traits such as rate limits, redirect handling, or JavaScript rendering. There is 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 a single, well-structured sentence that leads with the action verb and resource, then lists the extracted content types in a compact, readable sequence. There is no wasted wording or repetition 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 simple single-parameter extraction tool with no output schema, the description adequately communicates the expected result: structured content elements and statistics. It does not mention potential limitations like dynamic content or redirects, but these are minor for a read-only tool whose safety profile is already covered by annotations.

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 fully documents the single 'url' parameter with a type, format, and description, so schema coverage is 100%. The tool description adds no additional parameter-level meaning beyond implying a URL from 'web page', which meets the baseline but does not enhance it.

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: extracting structured content from a web page, and enumerates the specific content types (headings hierarchy, paragraphs, images, links, plain text with statistics). This goes beyond a generic phrase and helps differentiate it from fetch_page or simple link extractors, though it does not explicitly name 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 provides no guidance on when to choose this tool over the many sibling tools such as extract_links, extract_with_schema, or fetch_page. There is no mention of appropriate use cases, alternatives, or exclusions, leaving the agent to infer usage solely from the tool name and generic 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?

It adds meaningful behavior beyond the readOnlyHint: it uses Puppeteer, captures lazy-loaded images, and analyzes specific attributes (format, alt text, srcset, sizing, lazy loading, LCP). It also specifies the output as a 0-100 score with per-image details and recommendations, which aligns with a read-only inspection.

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 the core purpose in the first and output/coverage in the second. Every clause adds information 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?

For a tool without an output schema, the description sufficiently explains inputs, method (Puppeteer), what it checks, and what it returns (score, per-image details, recommendations). The scope of checks and the lazy-loaded behavior fill in the operational behavior an agent needs to set expectations.

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 describes all three parameters (url, device, timeout) with defaults and constraints, so the description carries no additional parameter-level burden. It doesn't add syntax or format details but none are needed at 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?

Describes the tool as a 'Comprehensive image audit for a web page' with a specific verb (audit) and resource (images on a page). The list of analyses (WebP/AVIF adoption, alt text, srcset, sizing, lazy-loading, LCP) distinguishes it clearly from sibling tools such as check_performance or audit_onpage.

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 first phrase 'Comprehensive image audit for a web page' gives an unambiguous use case, and the detailed analysis list clarifies it is for image-specific investigation. However, it does not explicitly say when to prefer an alternative tool, such as check_performance for overall performance or audit_onpage for general SEO.

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 readOnlyHint=true already covering safety, the description earns credit for disclosing what the operation returns (anchor text, URL, rel attributes, and nofollow status) and the filtering behavior. It does not detail edge cases like redirect handling, but it adds meaningful behavioral context beyond the annotation.

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

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

Two sentences with no filler: the first sentence names the operation and resource, the second covers filtering and return payloads. Every clause adds information, and the core 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?

For a simple read-only tool with two parameters and no output schema, the description is complete: it names inputs, filter options, and return fields. Nothing needed to invoke the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already explains both parameters fully. The description's 'Can filter by internal, external, or all links' paraphrases the type enum without adding new meaning, and it offers no additional semantics for the url parameter. 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+resource phrase — 'Extract all links from a web page' — which clearly distinguishes it from sibling tools like fetch_page, crawl_site, and extract_content. It also specifies the three filter modes and the exact return fields (anchor text, URL, rel attributes, nofollow status), making the tool's scope 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 conveys the clear context for use: when you need links from a single page and want to filter them by type. It does not, however, explicitly name alternatives or say which other tools to use for site-wide link analysis (e.g., crawl_site, check_links), so it 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?

The readOnlyHint annotation already establishes that this tool is safe and non-destructive. The description adds useful behavioral context about per-field transforms and fallback selectors, but it does not disclose the output format, error behavior, or whether dynamic/JavaScript-rendered pages are supported.

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 dense, well-ordered sentences front-load the core purpose, then summarize presets and field configuration without redundancy. There is no filler and every sentence contributes useful information.

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

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

The input side is well covered, including nested schema objects and fallback selectors, but there is no output schema and the description does not state the shape of the returned data or behavior on empty/missing selectors. For a tool with this complexity, that is a notable gap.

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

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

Schema description coverage is 100%, so all parameters are already documented in the structured schema. The description restates the field-level concepts and lists transform values, but it adds no additional meaning beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Extract structured data from a web page using configurable CSS selectors.' It clearly distinguishes itself from generic siblings like extract_content and extract_links by emphasizing custom schemas, built-in presets, and field-level selector configuration.

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 conveys a clear usage context: use this tool when you need structured, schema-driven extraction from a webpage with custom or preset selectors. It doesn't explicitly name alternatives or state when not to use it, but the intended use case is clear enough for an agent to route appropriately among siblings.

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

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

The readOnlyHint annotation already covers the safety profile, and the description adds the output format options and metadata note. It does not mention size limits, redirect handling, or JavaScript rendering, but for a simple read-only fetch this is a moderate, not severe, gap.

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

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

Two sentences with no wasted words, and the core action and output formats are front-loaded. It is concise while still conveying the essential 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?

Given the simple schema, the read-only annotation, and the absence of an output schema, the description covers the main contract: fetch a URL, choose a format, receive content plus metadata. It could be more explicit about failure/error behavior, but the description is largely sufficient for a single-page fetch 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 input schema already documents all three parameters with 100% coverage, so the baseline applies. The description repeats the format options from the schema but adds no new semantic detail beyond what the schema provides.

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

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

The description states an exact action — fetching a single web page and returning its content in a selectable format — and mentions metadata. This clearly distinguishes it from multi-page tools like crawl_site and visual tools like screenshot, even though those siblings are not named.

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

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

There is no guidance on when to choose fetch_page over extract_content, crawl_site, or screenshot, and no mention of situations where it should not be used. The description explains the operation but not the decision 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?

Annotations already mark the tool as read-only, and the description is consistent with that. It adds useful behavioral detail: Puppeteer request interception is used, GA4 /g/collect hits are parsed, and obsolete UA/duplicate events are detected, which goes beyond the annotation without contradicting it.

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 filler, front-loaded with the main action and resource. Each sentence adds distinct information: interception scope, parsed GA4 details, and detection of obsolete UA/duplicate events.

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

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

Given the tool has only two parameters and no output schema, the description covers the essential behavior and expected findings well. It does not specify the exact return structure, but the enumerated detection types give an agent enough context to understand what the tool delivers.

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%: both url and wait_ms are already described in the schema. The tool description adds little beyond high-level context like 'during page load', so it does not meaningfully improve parameter understanding beyond the baseline.

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

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

Describes a specific action (intercept and analyze) on a specific resource (tracking network requests), with concrete subtypes (GA4 hits, GTM, gtag) and outputs (event names, measurement IDs, obsolete UA, duplicate events). This clearly distinguishes it from sibling tools like check_gtm_snippet or check_datalayer that inspect configuration rather than network traffic.

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 makes the intended context explicit: use when you need to intercept and analyze tracking requests fired during page load. It does not name alternatives or state when not to use it, but the focus on network interception gives a clear enough signal compared to the 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, and the description adds meaningful behavioral context: auto-detection behavior, support for sitemap index files (suggesting recursion), and the exact return fields. This gives an agent confidence about side effects and output scope, beyond what the annotation alone provides.

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

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

One compact sentence that front-loads the main action, then adds three high-value specifics (auto-detect, index files, return fields). No filler and no repetition of schema content.

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, single-parameter tool with no output schema, the description is sufficient: it explains what input to provide, what behavior to expect (auto-detection, index expansion), and what the output contains. There is no missing guidance that would hinder correct invocation.

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

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

Schema description coverage is 100%, and the schema already documents the 'url' parameter as either sitemap URL or website root for auto-detection. The description adds no additional parameter-level meaning beyond what the schema states, 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?

States a specific verb ('Parse') and resource ('sitemap.xml'), and adds distinguishing details: auto-detection from a website root, support for sitemap index files, and the specific return fields (lastmod, changefreq, priority). This clearly separates it from sibling tools like crawl_site or extract_links.

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 when to use the tool: when you want URLs from a sitemap.xml or need auto-detection from a site root. It does not explicitly contrast with alternatives like crawl_site or extract_links, but the scoping is clear enough that an agent can infer the right context. Missing explicit 'when-not-to-use' guidance, so not a 5.

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

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

With no annotations, the description carries the full burden and does disclose key behaviors: a real headless-browser render, base64 return encoding, and the capture modes (custom viewport, full-page, waiting for a selector, cookie-banner dismissal). However, it omits failure behavior, timeout/resource cost of full-page capture, and the potentially very large size of the base64 output — gaps an agent would benefit from knowing.

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 filler: the first states the action and return format, the second enumerates the distinguishing capabilities. The core verb is front-loaded, and every clause 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 an 8-parameter tool with no output schema, the description compensates well by stating the return encoding (base64 PNG/JPEG) and the main feature flags, while the schema covers parameter details. The only meaningful gap is the absence of selection guidance against the fetch/extraction siblings.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters. The description echoes them in prose ('custom viewport size, full-page capture, waiting for a CSS selector, dismissing cookie consent banners') without adding format, constraint, or interaction details beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Capture a screenshot of a web page using a headless browser') and specifies the return format (base64 PNG/JPEG). None of the 29 sibling tools capture visual output — they fetch, extract, audit, and parse — so the tool is instantly distinguishable without inspecting the schema.

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

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

The second sentence implies when this tool is appropriate (when rendered visual evidence is needed, with options like full-page capture and waiting for a selector), but it never explicitly names alternatives or conditions for choosing screenshot over fetch_page or extract_content. Usage context is implied rather than stated.

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