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

Despite annotations already declaring read-only and idempotent behavior, the description adds substantial interpretive context: which blocks are enforceable, vendor-documented provenance, vendor quirks, and the caveat that absence of a rule is not a verdict. This is beyond what the annotations or schema 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 long but well structured: purpose, differentiators, Args, Returns, and example. The Args section is somewhat redundant with the schema, but the overall organization and front-loaded purpose keep it usable given the tool's complexity.

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

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

For a one-required-parameter tool with moderate complexity, this description is complete: coverage list, special cases, return shape, output formats, defaults, and an example. Nothing an agent needs to decide on or invoke the tool 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 coverage is 100%, and the description's Args section mostly restates the schema's names, defaults, and enum values. It adds a helpful example but does not materially extend the parameter semantics beyond what the input 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 first sentence states a specific verb and resource: resolving every known AI/LLM crawler against a site's robots.txt to see what may fetch a path. It also distinguishes the tool from a naive robots.txt reader by naming concrete crawler coverage and special-case behaviors.

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: use this for AI/LLM crawlability questions, with an explicit example and useful distinctions like training vs. citation blocking. It does not explicitly name a sibling alternative or state when to prefer a different tool, so it stops 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?

Beyond the readOnly and idempotent annotations, the description discloses useful behavioral details: it reports whether HTTP is upgraded to HTTPS, whether redirects are permanent versus temporary, and which variants do not serve content. This gives the agent a concrete picture of what the tool will compute.

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

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

The description is well organized: purpose, additional behavior, Args, Returns, and Example. It is front-loaded with the core function, and every section earns its place without redundant 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?

With a full output schema, complete parameter documentation, behavioral details, and an example call, the description gives an agent everything needed to select and invoke the tool correctly. No important operational context is missing.

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

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

Although schema coverage is 100%, the description adds meaning by explaining that 'www and scheme are ignored' for the site parameter, specifying the default for response_format, and showing a natural-language-to-API example. This goes beyond the schema's property descriptions.

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

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

The description states a specific verb and resource: fetch all four host/scheme variants and confirm they converge on a single canonical URL. This clearly distinguishes the tool from siblings like redirect_trace, which traces a single redirect path rather than comparing variants.

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

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

The description provides clear context by noting divergence is the classic cause of a homepage competing with itself in the index, and it gives an example query. It does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

With readOnlyHint=true and idempotentHint=true already covering safety, the description adds valuable non-obvious behavior: content is scoped to the <main>/<article> landmark so navigation/footer chrome don't inflate counts, and both English and Spanish stopwords are filtered. The return contract's used_content_landmark field reinforces this. It does not disclose fallback behavior when no landmark exists, which is a minor residual 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?

The description is well-organized and front-loaded: purpose, behavioral note, args, returns, and a concrete example. Each block earns its place, though the Args section duplicates schema content and the Returns block partially repeats what the output schema already documents, keeping it from a 5.

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 two well-documented parameters, an output schema covering the rich return shape, and annotations covering safety, the description covers the remaining essentials: extraction behavior, supported languages, output contract, and a usage example. It omits only edge-case behavior (unreachable URLs, or the content fallback when no landmark is present), which is a minor gap for an otherwise complete definition.

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 fully documents both url and response_format, including the enum and default. The Args section largely repeats that structured data, adding no meaning beyond inline convenience and an example value. A baseline 3 is appropriate since the description does not need to compensate.

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 ('Measure') and resource ('the page's main content') and enumerates a concrete metric list: word/sentence/paragraph counts, Flesch reading ease, reading time, text-to-HTML ratio, thin-content detection, and top non-stopword terms. This clearly distinguishes it from siblings like robots_txt_check, meta_tags_check, and link_audit, which target wholly different concerns.

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 metric list and the worked example ('Is the content on https://example.com/post too thin?') provide clear context for when to invoke this tool: content-depth, readability, and thinness questions. It does not explicitly name alternatives or exclusion criteria versus the closest sibling (seo_audit), so it stops short of a 5, but the context is unambiguous enough to route an agent 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 declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description doesn't need to restate safety. It adds behavioral context beyond annotations: the rationale for not scoring llms.txt, the distinction between AI search crawlers and training crawlers, and the return structure. No contradictions with annotations.

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

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

The description is moderately long but well structured: purpose, weighting, unique value, args, returns, example, and a clarifying note. Each section earns its place; the bullet points condense key differentiators. It is not overly verbose, though it could be tightened slightly without losing value.

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

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

For a composite audit tool with two parameters and an output schema (present but not shown), the description is remarkably complete. It covers purpose, methodology, edge cases (llms.txt), example usage, and return structure. An agent has everything needed to decide when and how to invoke it, and the llms.txt note prevents a common misunderstanding.

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

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

Schema coverage is 100% with descriptions for both url and response_format, so the baseline is 3. The description adds an example invocation ('Is https://example.com/guide ready to be cited by ChatGPT?' -> geo_audit(url=...)) and the exact return object shape, which goes beyond the schema and helps an agent understand parameter usage and output. That lifts it to 4.

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

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

The description opens with a specific verb and resource: 'Score how readily an AI answer engine can fetch, parse and cite this page.' It enumerates the weighted categories and explicitly names the two unique catches (AI crawlers not executing JS and AI search crawler blocking) that distinguish it from classic SEO tools. This clearly separates it from the many sibling tools that focus on individual aspects like robots_txt_check or render_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 implies when to use this tool by contrasting it with 'classic SEO tools' and listing its composite nature, but it does not explicitly name alternative tools or conditions for selecting them. It does clarify what it does NOT score (llms.txt) and why, which helps an agent avoid misusing it. A clear exclusion is present, but explicit routing to siblings is missing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's job is lighter. It adds value by specifying the exact metrics computed (level_skips, question_headings, grade/score) and the rationale for question headings being a strong snippet/citation signal. No contradictions with annotations.

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

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

The description is well-structured with an Args, Returns, and Example section, front-loading the core purpose. It is slightly verbose but every sentence adds functional or contextual value (e.g., the snippet-signal note). No filler or tautology.

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

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

Given the tool's moderate complexity, the description covers the input, output format (with return fields), and an example invocation. The presence of an output schema reduces the need to spell out return structure, and the description provides enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so both url and response_format are already well documented. The description repeats the parameter list and adds an example call, but does not add new meaning beyond the schema. The baseline of 3 applies because the schema carries the full semantic weight.

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 ('Extract') and resource ('full h1–h6 outline'), then details exactly what is evaluated (h1 count, level skips, empty headings, question phrasing). It clearly distinguishes itself from sibling tools like meta_tags_check or content_analysis by focusing solely on heading structure and its SEO signals.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention that heading analysis is part of a broader SEO audit or when to prefer seo_audit over this specific check. The context is implicit from the name and description, but the tool does not state exclusions or preferred scenarios.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context by disclosing that enabling check_reciprocity fetches each alternate and explaining that non-reciprocal hreflang is silently ignored by Google and undetectable from a single page. It stops short of mentioning timeouts or rate limits, but the behavioral disclosure is strong.

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

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

The description is well organized: purpose first, then the advanced reciprocity behavior, followed by compact Args, the return shape, and a concrete example. Every section earns its place 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?

With 100% schema coverage, relevant annotations, an output schema, and a description that explains the non-obvious reciprocity behavior and return payload, an agent has everything it needs to select and invoke the tool correctly. The example query further anchors intended usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats each parameter's name and default value but adds some useful context, especially for check_reciprocity ('catches the most common hreflang bug'). This is helpful but doesn't substantially go beyond what the schema already documents.

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 resource (a page's `<link rel="alternate" hreflang>` annotations), the action (validate), and the specific validation checks: BCP-47 validity, self-referencing entry, x-default fallback, and duplicate codes. This is specific enough to distinguish it from sibling tools like sitemap_check or geo_audit.

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 opening sentence explicitly states the tool's purpose, making it clear when an agent should use it. The check_reciprocity paragraph also tells the agent when to enable that option and why it matters. It doesn't explicitly name alternative tools or give when-not-to-use guidance, but the scope is unambiguous.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it explains what counts as modern delivery ('<picture> sources are counted as modern delivery'), what the audit covers, and the return payload structure. It does not disclose rate limits or failure behavior, but for a read-only audit tool the added context is solid.

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

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

The description is well-structured: a dense first sentence enumerating checks, a compact Args block, a Returns line, and an example. It is slightly longer than necessary because the Returns line duplicates the output schema, but every sentence earns its place and the key scope is front-loaded.

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

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

The tool has an output schema, so the description need not explain return values in depth, yet it still provides a Returns summary. The description covers the audit scope, parameters, and an example. It lacks explicit guidance on edge cases (e.g., pages with no images) but is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds a brief mention of the parameters in the Args block but does not add meaning beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 a precise resource ('every <img> on the page'), then enumerates the exact checks performed: missing alt, decorative alt, missing dimensions, lazy-loading, and modern formats. This clearly distinguishes it from sibling SEO tools like meta_tags_check or robots_txt_check, which target different page elements.

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

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

The description implies when to use this tool: when auditing image-specific SEO/accessibility issues on a page. It does not explicitly state when NOT to use it or name alternatives, but the detailed scope makes the use case clear. The example query reinforces the intended usage pattern.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows it's a safe read operation. The description adds valuable behavioral context beyond that: it explains the optional sample verification, the HEAD-then-GET retry logic, and the exact structure of the returned payload. This gives the agent insight into how the tool behaves without contradicting any annotations.

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

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

The description is well-structured: the core purpose is front-loaded, followed by a clear Args list, a Returns summary, and a concrete example. It is slightly longer than strictly necessary because it repeats parameter details from the schema, but every sentence serves a purpose and the layout aids scanning. It is appropriately concise for a tool with four parameters and a non-trivial output.

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 four parameters, an output schema, and no hidden prerequisites, the description is complete. It covers the full behavior (including the optional broken-link verification), the return structure is explicitly described (redundant with the output schema but still useful), and the example shows realistic invocation. Nothing an agent needs to call it 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% – every parameter has a clear description, including defaults and constraints (e.g., sample_size min/max, response_format enum). The tool description largely restates these in its Args list, adding little semantic value beyond the schema. The example does clarify the interplay between check_broken and sample_size, but that is also present in the schema. Per the rubric, baseline 3 is appropriate when the schema does the heavy lifting.

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 a clearly defined resource ('a page's outbound links'), then enumerates the exact aspects it covers (internal/external split, rel attributes, anchor text issues, domain distribution, broken-link verification). This specificity distinguishes it from siblings like seo_audit or meta_tags_check, which target different SEO facets. An agent can immediately recognize that this tool is the one for link-level analysis.

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

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

The description provides a concrete example query that maps to the tool, illustrating when it should be invoked ('Are there broken links...'). It also implies the tool is for outbound-link auditing rather than broader SEO checks, though it does not explicitly name alternatives or state when not to use it. The context is clear enough for correct selection, but explicit exclusions are absent.

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 this as read-only, idempotent, and open-world, so the safety profile is covered. The description adds valuable behavioral detail beyond that: it always reports adoption_status and explains the llms-full.txt convention, and it clarifies the tool's limitations regarding AI visibility. This gives the agent an accurate model of what the tool will and won't tell them.

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

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

The description is longer than the minimum but well-structured: the core action is front-loaded, followed by important contextual caveats, then args and returns. The extra context about llms.txt's non-adopted status is relevant to correct usage, so it earns its place. However, it could be tightened by omitting the schema-redundant parameter block.

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

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

The tool has an output schema (per context signals), so the return-value list in the description is supplementary. The description covers the non-obvious aspects: validation criteria, full-variant detection, and the adoption-status context an agent needs to interpret results. With a simple two-parameter input and a live read-only check, 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%, so the parameter meaning is fully carried by the input schema. The description's Args section repeats the schema content without adding new semantics, and the example usage illustrates a call pattern rather than parameter meaning. 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: 'Check whether a site publishes /llms.txt and validate it against the llmstxt.org proposal.' It also names the alternate variant detection (/llms-full.txt), which distinguishes it from sibling robots.txt/sitemap checks. An agent can immediately tell exactly what this tool does.

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

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

The description explicitly states when to use it: 'Use this tool to answer "do they publish one, and is it well-formed?"' and, more importantly, what not to use it for: 'not as evidence that a site is or is not AI-optimised.' It also embeds relevant context about llms.txt's non-standard status, which helps the agent decide if the tool is appropriate for a given user question.

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, idempotentHint=true, and destructiveHint=false, establishing the safety profile. The description adds behavioral context by listing the return object and noting it checks both meta robots and the X-Robots-Tag header, which is a non-obvious detail. It also states what it flags (length problems, duplicates, non-indexable), giving insight into output behavior. No contradiction with annotations.

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

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

The description is well-organized: a concise overview sentence, then Args, Returns, and Example sections. Each part serves a purpose—no redundancy. The main purpose is front-loaded, and the structured format makes it easy for an agent to scan. It is detailed but not verbose.

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

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

Given the tool's moderate complexity (checks many tags, returns a structured object) and the presence of an output schema (implied by 'Has output schema: true'), the description covers the essential information: the return fields, the flags it produces, and an example. It doesn't discuss error handling or redirect behavior, but those are minor gaps given the annotations and schema richness. Overall, it is sufficiently complete 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 input schema fully describes both parameters: url with example and scheme default, response_format with enum and default. Schema coverage is 100%, so the baseline is 3. The description repeats these parameters but does not add new semantic information; the example call reinforces usage but doesn't deepen parameter understanding 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 ('Inspect') and resource ('a page's head tags'), enumerating the exact tags checked (title, meta description, canonical, robots directives, lang, charset, viewport, favicon). This is precise and implicitly distinguishes it from sibling tools like robots_txt_check (which inspects robots.txt) or seo_audit (broader audit). It also describes the outcome (flags length problems, missing/duplicated tags, non-indexable issues), making the purpose unambiguous.

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

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

The description provides a clear example query ('Are the meta tags on https://example.com correct?') that illustrates when to use the tool. However, it does not explicitly mention alternatives or when not to use it, lacking the explicit 'when-not' guidance that would earn a 5. Still, the context is clear and the example provides practical direction.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description is not burdened with proving safety. It adds meaningful behavioral context beyond annotations: it describes hop-by-hop traversal, flags crawl-budget waste, detects loops, and identifies temporary vs permanent redirects. The Returns section also outlines the structured result fields, which is useful context even though an output schema exists.

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

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

The description is well-structured with a front-loaded purpose, followed by Args, Returns, and an example. Every section serves a purpose, and the example is highly actionable. There is some redundancy between the Args section and the schema, but it does not harm clarity enough to warrant a lower score.

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 definition fully equips an agent to select and invoke the tool: it states the exact operation, the conditions it flags, parameter defaults and formats, the return payload shape, and provides a natural-language example. Combined with the rich annotations and schema, nothing needed for correct usage 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 coverage is 100%, so the schema itself already documents url and response_format in detail, including defaults, enums, and the https:// scheme fallback. The description duplicates this information with its Args section and adds a useful example, but it does not meaningfully extend parameter semantics beyond the schema.

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

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

The description opens with a specific verb and resource: 'Follow a URL's redirect chain hop by hop', and explicitly enumerates the reported status codes and targets. It also lists the issues it flags (long chains, loops, temporary redirects, non-HTTPS endings), which clearly distinguishes it from the 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 tool's use case is clearly stated in the first sentence and reinforced with a concrete example query-to-call mapping. It does not explicitly name alternatives or state when not to use it, but the context makes it obvious that this is the redirect-specific diagnostic tool among the 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?

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds specific behavioral details such as detecting SPA shells, counting server-side words, and flagging script-heavy pages. It also describes the return fields, enriching beyond the annotations without contradicting them.

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

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

The description is well-structured and front-loaded with the core purpose, followed by context, arguments, and returns. While it is somewhat lengthy, every sentence contributes to understanding, and the structure aids scanning.

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 an output schema and safety annotations, the description covers purpose, usage context, parameters, and return format, including an example. It lacks edge-case handling or error details, but these are not essential given the available structured data.

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 both url and response_format are documented. The description reinforces the meaning of response_format, provides the default, and gives a concrete example mapping a natural-language query to the tool call, adding value beyond the schema.

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

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

The description clearly states the tool determines whether content is server-rendered or appears only after JavaScript runs, and explicitly contrasts this with classic SEO concerns. It distinguishes itself from siblings like robots_txt_check and ai_crawler_access by focusing on rendering rather than access or 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?

It explains when the tool matters (AI visibility over classic SEO) and gives an example query, implying when to use it. However, it does not explicitly name alternatives or state when NOT to use it, though the context is sufficient 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description goes well beyond by disclosing exact parsing behavior (per RFC 9309), the special flags for `Disallow: /` and 5xx responses, and the structure of the returned payload. No contradictions with annotations.

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

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

Every sentence earns its place: purpose, special behavior flags, args, return shape, example, and sibling routing. The structure is logical and front-loaded with the core purpose before operational details.

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 two params and rich annotations, the description includes everything needed to select and invoke it correctly: parameter usage, return fields, default behavior, and a clear alternative for a related but different task. The example further anchors 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 fully explains `site` and `response_format`. The description repeats the args and adds a concrete example mapping a natural-language query to a call, but does not add meaning beyond the schema's existing detail.

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

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

Starts with a specific verb and resource: 'Fetch and parse a site's robots.txt per RFC 9309'. It clearly defines the scope (every user-agent group, Allow/Disallow rules, sitemaps, unparseable lines) and distinguishes itself from sibling `ai_crawler_access` by naming that alternative explicitly.

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

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

Provides an example query ('What does example.com's robots.txt allow?') and an explicit when-not-to-use instruction: 'For AI-crawler specifics use ai_crawler_access instead'. It also signals a diagnostic use case by explaining the two silent deindexing failures it flags.

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 read-only/idempotent behavior, and the description adds meaningful behavioral context beyond that: it fetches the page once, caps the score on noindex or robots-blocked pages, and reports errors for unreachable, non-HTML, or HTTP-error responses. It also tells the agent what payload shape to expect.

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

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

The description is appropriately sized for a comprehensive tool: purpose, usage rule, args, return shape, example, and critical edge-case note each earn their place. It is front-loaded with the most important scoping information and remains scannable despite covering a lot of ground.

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 4-parameter aggregator with many siblings, the description covers selection context, output format, error behavior, and a crucial caveat (noindex/robots-block caps the score). The return structure is spelled out in prose, and the error note addresses the main call-time risks, so an agent has what it needs to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, defaults, and side effects. The description's Args section largely restates that information, but the natural-language example ('Audit the SEO of https://example.com/pricing' -> seo_audit(url=...)) adds a concrete invocation pattern beyond the structured schema.

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

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

The description opens with a specific verb and resource: 'Fetch a page once and audit it across seven weighted sections', enumerating exactly what is audited and the outputs (0–100 score, A–F grade, prioritised fix list). It also distinguishes itself from the many single-purpose siblings by positioning itself as the starting audit tool, so an agent can tell it apart from tools like meta_tags_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 explicitly says 'This is the tool to start with for any "how is this page doing for SEO?" question; drill into the single-purpose tools afterwards for detail.' This gives a clear selection rule and points to follow-up tools, though it does not enumerate exactly which sibling to choose for each specific follow-up need.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description adds real behavioral detail: robots.txt discovery, fallback paths, index/gzip handling, exact limits (50,000 URLs, 50 MiB), lastmod validation, off-origin checking, duplicate detection, and the returned fields. This gives the agent a precise model of what the tool does 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 front-loaded with purpose, then discovery logic, validation criteria, arguments, return payload, and an example. Although it is long, each section contributes directly to selecting and invoking the tool correctly, and the structure is easy to scan.

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

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

The definition covers discovery strategy, supported edge cases, validation rules, parameter behavior, return fields, and even includes an example invocation. Given the output schema is available, nothing critical is missing for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, and the description largely restates what the schema already says: site semantics, sitemap_url discovery behavior, follow_children default, and response_format choices. It adds little new parameter-level meaning beyond the structured schema, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Discover, fetch and validate an XML sitemap.' It then details the discovery fallbacks and validation checks, which clearly differentiates it from sibling tools like robots_txt_check or llms_txt_check by focusing on the XML sitemap artifact and its rules.

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 usage is clear: call this tool when an XML sitemap needs to be found, fetched, or validated, including index and gzip handling. It does not explicitly name alternatives or say when not to use it, but the context is strong enough to route an agent 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 cover the safety profile (readOnlyHint, idempotentHint, openWorldHint, non-destructive). The description adds genuinely useful behavioral context beyond that: it discloses that the tool optionally issues a HEAD request to verify the og:image loads, and that it specifically flags relative og:image URLs — a classic pitfall behavior an agent wouldn't infer from annotations alone.

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

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

The description is well-structured: purpose is front-loaded in the first sentence with platforms and tag families, followed by behavioral specifics, then Args/Returns/Example sections. The Args section is somewhat redundant with the fully-covered schema, which prevents a 5, but every other sentence earns its place and the example is tightly scoped.

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-URL validation tool with 3 well-documented params, rich annotations, and an output schema, the description is complete: it explains the return payload shape, provides an example, and covers the main behavioral nuance (image reachability check). Nothing essential for correct invocation 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 coverage is 100%, so the baseline is 3. The description's Args section largely restates what the schema already documents (defaults for check_image and response_format are duplicated). The example does demonstrate realistic invocation syntax, but the description adds minimal semantic value beyond the schema's parameter descriptions.

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

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

The description names a specific verb-resource pair ('Validate the tags that build link-preview cards') and enumerates the exact tag families (og:title, og:description, og:image, og:url, og:type, og:site_name, twitter:*) as well as the target platforms (X, LinkedIn, Facebook, Slack, WhatsApp, Discord). This clearly distinguishes it from siblings like meta_tags_check (generic meta tags), image_seo_check, and render_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 example query ('Why does my link preview look broken on LinkedIn?') provides a concrete, actionable when-to-use signal that an agent can match against a user's intent. However, it does not explicitly name alternatives or state when NOT to use this tool (e.g., versus meta_tags_check for general tag validation), so it stops short of full exclusion guidance.

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

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

Annotations already establish the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lowered. The description adds meaningful behavioral context beyond that: it discloses that unparseable JSON-LD blocks are 'invisible to search engines' and that the tool reports missing required and recommended rich-result properties against Google's requirements. This describes the checking behavior and its significance without contradicting the read-only, non-destructive 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 front-loaded with its core purpose in the first sentence, then layers covered types, args, returns, and an example in a logical order. It is longer than typical but the length is justified by the tool's breadth (many schema types and a complex return payload). The Args section is somewhat redundant with the schema, but the Returns section and example earn their 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?

With an output schema present, the description needn't detail return values, yet it still lists the return fields, which is helpful. It covers what is extracted, what is validated, which types are recognized, parameter defaults, and a concrete example. For a read-only analysis tool whose safety profile is carried by annotations, nothing essential for an agent to call it 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 both url and response_format are already fully documented with type, default, and format details. The description's Args section largely restates the schema rather than adding new meaning, though it does provide an illustrative example invocation. Per the rubric, with high schema coverage the baseline is 3, and the description adds only marginal value beyond the schema.

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

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

The description opens with a specific verb+resource pair — 'Extract and validate JSON-LD, microdata and RDFa' — which names both the action and the exact subject matter. The tool title and covered-types list (Article, Product, FAQPage, etc.) reinforce the scope, and the focus on Schema.org structured data clearly differentiates it from siblings like robots_txt_check, meta_tags_check, and sitemap_check, which target entirely different SEO concerns.

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 example ('Does https://example.com/product have valid Product schema?') implies a concrete use case, and the covered-types enumeration hints at when the tool applies. However, there is no explicit statement of when to use this versus an alternative, nor any exclusionary guidance (e.g., 'for general SEO issues use seo_audit'). The usage context is implied but never stated, which is a genuine gap given the 16 sibling tools.

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