Nuxt SEO

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds real behavioral value by disclosing the return contents and the edge case that the file may not exist at all, though it says nothing about redirect handling, fetch failures, or timeouts.

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 sentence, front-loaded with the action, then the outputs as a compact list. No filler and nothing wasted.

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 usefully enumerates the returned fields and flags the missing-file case, and the single parameter is fully documented. It stops short of describing the response structure or failure modes, so it is strong but not fully complete.

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

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

There is a single required parameter with 100% schema description coverage ('URL or domain to fetch robots.txt from'), so the schema already carries the semantics. The description adds nothing about accepted URL forms (scheme optional? path ignored?), which keeps it at 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?

States a specific verb pair (fetch and parse) on a specific resource (robots.txt) and enumerates exactly what is extracted: per-user-agent rules, sitemap directives, syntax errors, and existence. This is clearly separable from siblings like validate_sitemap and check_meta_tags.

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 the tool is useful (inspecting a site's crawl directives), but never states when to prefer it over adjacent tools such as diagnose_url or validate_sitemap, nor any exclusions. Usage is inferable but not guided.

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, openWorldHint=true and destructiveHint=false, so safety is covered by structured data. The description adds real value on top by scoping exactly what will be read from the remote page, including the JSON-LD block count. It stops short of 5 because it says nothing about fetch behavior — redirects, non-HTML targets, timeouts, or failure modes for an open-world network read.

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

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

A single front-loaded sentence with a colon-delimited inventory; every element earns its place and there is no filler.

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

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

With no output schema, the description correctly compensates by listing the return contents, which is the main thing an agent needs. It is slightly incomplete on error/edge-case behavior for a network-facing read tool, but nothing essential to invoking it 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?

Only one parameter exists and schema description coverage is 100%, so the schema already documents it fully. The description adds nothing beyond confirming the resource is a URL, making the baseline 3 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 verb ('Read') and resource ('head metadata of a URL') and enumerates the exact fields returned (title, meta tags, canonical, hreflang, JSON-LD count), which is far more precise than a generic 'check' tool. However it never differentiates itself from overlapping siblings such as debug_social_share, which also inspects Open Graph/Twitter tags, so it stops short of a 5.

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

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

Usage is implied by the purpose (inspect a page's head metadata), but there is no explicit when-to-use, when-not-to-use, or named alternative. An agent must infer for itself why it would pick this over debug_social_share or diagnose_url.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds that the tool strips navigation/footer when extractContent is set, but that duplicates the schema; it says nothing about network/rate-limit behavior from fetching a URL or what a failed fetch returns.

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

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

A single sentence that front-loads the core action and packs the two input modes plus the optional extraction behavior without filler. Every clause carries 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?

For a read-only converter with no output schema, the description should at least state the return shape (a Markdown string) and conflict/error behavior when url fetch fails or both inputs are given. It is adequate for calling the tool but leaves the result contract implicit.

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 three parameters (url, html, extractContent) are already documented at the same level the description provides. The description's 'optional if html provided' restates the schema's mutual-optionality without adding format or precedence rules.

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 gives a specific verb (convert), resource (HTML/web page), and output (Markdown), plus both accepted input modes (URL or raw HTML string). It is clear on its own, but it never distinguishes itself from the sibling get_page_markdown, which an agent could easily confuse with this 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?

There is no explicit when-to-use guidance, no mention of what to do when both url and html are supplied, and no differentiation from get_page_markdown or the other page-oriented siblings. Usage is only inferable from the phrase 'by URL or a raw HTML string'.

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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds real value beyond that by disclosing what the call produces (resolved image, per-tag warnings for missing/invalid tags), which is meaningful given there is no output schema, though it says nothing about fetch failures, rate limits, or how external rendering is simulated.

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

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

A single dense sentence with the action and its enumerated outputs front-loaded and no filler. Slightly long as one clause-chained sentence, but 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 simple one-parameter read tool, the description covers purpose, inputs (via schema), and expected outputs, and annotations cover safety and open-world behavior. The absence of an output schema is compensated by the enumeration of returned checks, leaving only minor gaps around failure modes.

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

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

With a single parameter at 100% schema description coverage, the schema already documents 'url' as the URL to debug. The description adds no syntax, format, or constraint detail beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb (check) plus the resource (how a URL renders as a share card) and enumerates the concrete outputs: Open Graph/Twitter Card tags, resolved image, and per-tag warnings. It is clearly distinguishable from generic siblings like check_meta_tags by focusing on social/chat card rendering, though it never explicitly names an alternative.

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

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

Usage is only implied: an agent can infer this is for auditing social preview cards for a URL, but there is no explicit when-to-use, when-not-to-use, or pointer to check_meta_tags / diagnose_url as alternatives. Adequate but leaves 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?

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds the useful constraint that only public URLs can be audited, plus the ranked-by-severity, fix-per-finding output shape — though with an output schema present that return detail is largely redundant, and no auth, rate-limit or failure behavior is disclosed.

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

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

A single front-loaded sentence: verb and scope first, then the enumerated coverage list. Dense but every clause carries information; the trailing list of six areas is slightly long but justified by the combined-audit claim.

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 documented required parameter, three annotations, and an output schema, the description supplies what the structured fields do not: the audit's breadth and the fact that it is a one-call umbrella review. The only gap is the absence of any routing guidance versus the single-purpose sibling 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 schema fully documents the single 'url' parameter at 100% coverage, so the baseline is 3. The description adds only the 'public' qualifier and re-lists the diagnostic areas already enumerated in the schema description, adding no new constraint such as format, http/https requirement, or behavior on redirects.

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?

Names a specific verb ('Audit') and resource ('one public URL') and immediately bounds the scope to six named audit areas. The phrase 'in a single call' cleanly separates it from narrow siblings like check_meta_tags, validate_schema, validate_sitemap and analyze_robots_txt, which each cover one slice.

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

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

Usage is only implied: 'in a single call' hints that this is the umbrella tool and that the single-purpose siblings are subsets, but no alternative is named and no when-not-to-use condition is given. An agent could infer the routing, but it is not stated.

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=true, destructiveHint=false, openWorldHint=false), lowering the bar. The description adds real value by enumerating the three return components, which is important since no output schema exists. It still omits anything about lookup failure behavior for an unknown slug, keeping it from a 5.

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

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

A single sentence with the resource and scope front-loaded and zero filler. Nothing is wasted or repeated.

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 carries the burden of describing returns and does so by naming the three payload components. For a simple one-param lookup this is nearly sufficient, though it could note behavior for invalid slugs or doc freshness.

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 single enum parameter is fully self-documenting, so the baseline is 3. The description only reinforces cardinality ('one module') and adds no format or selection guidance 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 gives a concrete verb (Get) and resource (install command, installation guide, docs navigation) scoped to a single Nuxt SEO module, which separates it from list_modules without naming it. Sibling differentiation is implied by 'one module' rather than explicitly stated, so it falls just short of a 5.

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

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

Usage is implied: an agent should call this when it needs setup instructions for a specific module from the enum. There is no explicit when-to-use/when-not guidance and no named alternative (e.g., list_modules for discovery), so it stays at the minimum viable level.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description contributes the output format ('as markdown'), which is genuinely useful given there is no output schema, but says nothing about failure modes for bad routes or how the page is fetched.

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

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

A single front-loaded sentence with zero filler. Everything stated 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 one-parameter, read-only tool whose annotations cover the safety profile, the essentials are present. It is still thin on what 'this site' scopes to and what happens for invalid or non-page routes, which matters given the absence of an output schema.

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 route parameter is documented with a concrete example ('/blog/hello-world'), so the schema carries the burden. The description adds no syntax or format detail beyond what the schema already provides; 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 and resource ('Reads a page ... as markdown'), which is clear on its own and distinguishable from list_pages and search_pages. It does not, however, differentiate itself from the sibling convert_html_to_markdown, so the agent must infer the boundary.

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 when-to-use guidance, no exclusions, and no named alternative. An agent reading this cannot tell whether to use it or convert_html_to_markdown, and 'this site' is never defined.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing behavioral beyond that (no freshness/rate-limit notes on npm/GitHub data), though for a pure read tool little more is required.

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

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

A single sentence that front-loads the action and resource, then lists the concrete data fields, with zero filler. Nothing is padded or repeated from the title.

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, so the description usefully compensates by naming the exact fields returned (package, docs link, version, stars, downloads). What is missing is any note on data freshness or whether results are filtered/ordered, which is minor for a static catalog listing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There are no arguments whose semantics need explaining, and the description correctly spends no words on inputs.

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 ('List') and resource ('Nuxt SEO modules') and even enumerates the fields returned (npm package, docs link, version, stars, downloads). The resource is distinct from every sibling (pages, robots.txt, sitemap), so no sibling confusion arises.

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

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

Usage is only implied: this is a zero-argument catalog listing, so an agent can infer it is the discovery entry point. However, the description gives no explicit when-to-use guidance or relationship to siblings like get_module_setup, which would help route an agent from listing modules to inspecting them.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description usefully adds the shape of the result (route, title, description), but says nothing about pagination limits or what happens when a site is longer than the returned window.

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

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

A single front-loaded sentence with no filler. Every clause earns its place by naming the resource and the returned fields.

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 paginated read tool with full annotation coverage and a fully documented schema, the description is nearly sufficient, and listing return fields compensates for the absent output schema. It falls short only on routing versus search_pages.

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 limit and offset are already fully documented in the schema including defaults and bounds. The description adds no parameter-level meaning, which matches the baseline of 3 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?

States a specific verb (Lists) and resource (pages on this site), and names the returned fields (route, title, description). It does not differentiate itself from the sibling search_pages, which an agent could easily confuse with this enumeration 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?

There is no statement of when to use this tool versus alternatives such as search_pages or get_page_markdown. Usage is only implied by the word 'Lists', leaving the agent to infer that this is the unfiltered enumeration path.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that results are 'best matching' (i.e. relevance-ranked) and names the returned fields, useful context compensating for the absent output schema, but says nothing about ranking behavior, result limits interacting with the cap, or empty-result behavior.

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

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

A single front-loaded sentence that identifies the search scope, the resource type, and the return fields with zero filler. Nothing restates the name or title verbatim in a wasteful way.

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 usefully names the returned fields (route, title, description), and the annotations carry the safety profile, so an agent has what it needs to call this correctly. Minor gaps: no mention of ranking order, limit interaction, or behavior on zero matches.

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 both 'query' (with an example phrase) and 'limit' (default and range) fully documented in the schema. The description adds no syntax, format, or matching-mode detail beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb ('Searches') and a clearly scoped resource ('the full content of this site'), then names the return shape ('route, title and description'). This naturally distinguishes it from siblings like list_pages (enumeration) and get_page_markdown (single-page fetch).

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

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

Usage is implied by 'full content' search semantics, but the description never says when to reach for this instead of list_pages, get_page_markdown, or diagnose_url, and gives no exclusions or prerequisites. Adequate but leaves 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description goes beyond them by disclosing the result shape (each detected type with its errors and warnings for rich results) and that both JSON-LD and Microdata are scanned, which is genuinely useful. It stops short of noting rate limits, auth needs, or how an unreachable/unsupported URL is handled.

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 tightly structured sentence, front-loaded with the verb and resource, then a colon-delimited elaboration on the return content. No filler or restatement of the title.

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 only one parameter and no output schema, the description does the necessary work by summarizing what comes back (per-type errors and warnings for rich results). That is adequate for a read-only validator, though a touch more on return granularity or failure modes would make it fully self-sufficient.

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

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

Schema coverage is 100% for the single url parameter, so the schema already carries the semantics and the baseline is 3. The description adds no format guidance (absolute vs relative URL, public accessibility) beyond what the schema states.

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 pair (find and validate) against a named resource (Schema.org structured data, explicitly JSON-LD and Microdata) scoped to a URL. That scope cleanly separates it from siblings like check_meta_tags and validate_sitemap, which an agent can distinguish without opening any 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?

Usage is only implied by the resource: an agent can infer it should call this when it wants to check structured data on a page. No explicit when-to-use condition, prerequisite, or alternative (e.g. check_meta_tags for meta tags) is named, so the routing guidance is thin.

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 this is a read-only, non-destructive, non-open-world operation, so the bar is lower. The description still adds value by disclosing the actual validation dimensions (duplicates, date/protocol errors), which tells the agent what a run will surface beyond the generic safety hints.

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 sentence, front-loaded with the action and resource, then the concrete checks. Every clause earns its place with no padding.

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

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

For a one-parameter, read-only validation tool with annotations and no output schema, the description covers what the agent needs to call it correctly and what kinds of findings to expect. Only the precise response shape is left unspecified, which is a minor gap given no output schema exists.

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

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

There is a single 'xml' parameter with full schema description coverage, so the schema already documents it. The description only marginally adds meaning by clarifying it may be a sitemap or sitemap index; baseline 3 is appropriate when the schema does the work.

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 (validate) and resource (XML sitemap/sitemap index) and enumerates exactly what is checked: URL count, duplicates, invalid URLs and dates, protocol errors. This clearly separates it from siblings like validate_schema or analyze_robots_txt, which target different artifacts.

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 'you pass in' usefully signals the caller supplies XML content rather than a URL to fetch, which is real usage context. However, there is no explicit when-to-use/when-not guidance and no routing to or away from sibling tools.

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