CheckWebsiteNow

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

Beyond the annotations (readOnly, openWorld, non-destructive), the description discloses substantive behavior: evidence is bounded and static, no scripts run, MCP discovery is advertised rather than tested, WebMCP is declared but not browser-verified, and every deduction names its fix. It even defines the failure-mode contract (score is null when too little could be measured), which is exactly the kind of context annotations cannot 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 text is dense but nearly every clause carries information — evidence sources, transparency caveats, null behavior. It is slightly crammed into two long sentences rather than cleanly front-loaded, but there is minimal 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?

An output schema exists, so return-value explanation is not required, and the description covers scope, evidence boundaries, and the null-result case well. The one missing piece is sibling differentiation (check_website vs this tool, and the get_agent_readability_method companion), which an agent would still need to resolve.

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 hostname parameter is already fully documented in the schema (public domain, no path/port/IP). The description adds no additional parameter meaning beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb+resource: it computes an Agent Readability Score (0-100) for a website, and enumerates the exact evidence sources used (homepage HTML, robots.txt, llms.txt, discovery files, sitemap, Markdown negotiation). It is clear and concrete, but it never distinguishes itself from the sibling check_website or references get_agent_readability_method, so an agent cannot route confidently from the description alone.

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

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

The description explains what evidence is inspected but gives no explicit when-to-use, when-not-to-use, or alternative selection guidance against check_website or get_agent_readability_method. Usage is only implied by the tool's purpose.

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 readOnly/openWorld/destructive/idempotent, so the bar is low; the description still adds real behavior: results reflect one measurement point, the response leads with agent_guidance meant to be relayed, and sponsored_offers are optional labelled ads that must not be auto-opened. It does not state timing, timeouts, or rate limits, which for a live network check would be useful.

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 purpose and its limitation are front-loaded, which is exactly right. The tail explaining agent_guidance and sponsored_offers field semantics is dense and partly duplicates what the output schema already describes, so it is slightly over-loaded rather than wasteful.

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, return values need not be spelled out, and annotations carry the safety profile, so the description is close to complete. It omits prerequisites and any notion of how long a check takes or whether repeat calls are cheap, minor gaps for a read-only network probe.

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 and schema description coverage is 100%, so the schema already documents 'hostname' as a public domain with no path, port, or IP. The description says 'one public website' but adds no format or constraint detail beyond the schema. 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 concrete verb and resource ('Check one public website now: HTTPS homepage response headers and safe redirects from one measurement point') and immediately bounds the claim with 'Not a global outage verdict.' An agent can distinguish this from list_status_sites or get_access_solutions 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?

Explicitly scopes the tool to a single site from one measurement point, rules out the global-outage interpretation, and names the alternative path ('empty when a regional block is suspected (then call get_access_solutions)'). Both the when-to-use and when-to-switch conditions are 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 establish the safe read-only, idempotent, non-destructive profile, so the description's added value is the ad policy ('lookups carry no ads... offers come only with check_website results') and the ranked-match return shape. It discloses behavior beyond the structured safety hints, though return details partially overlap the existing output schema.

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

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

Three sentences, front-loaded with the core action and examples before the return shape and ad policy. Every sentence carries information, though the trailing ad/offers sentence is dense and reads more like a sibling-routing note than core usage.

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 lookup with an output schema and full annotation coverage, the description supplies what is needed: input forms, ranking cap, and the shape of guidance returned. Minor gaps remain around no-match behavior and how it differs from get_error/list_errors.

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 0% schema description coverage, the description compensates by enumerating accepted query forms: a browser error token, an HTTP status code, or pasted error text. That is meaningful semantic guidance beyond the bare string schema, though it says nothing about the 200-character limit or normalization behavior.

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 set: 'look up a browser error, HTTP status code or pasted error text', with concrete examples (ERR_CONNECTION_REFUSED, 503). It does not explicitly differentiate itself from the sibling tools get_error and list_errors, so the agent must infer the distinction from the 'up to five ranked matches' phrasing.

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?

Clearly signals the input contexts it is meant for (browser errors, HTTP status codes, pasted error text) and implicitly routes website-checking to check_website by noting offers appear only there. No explicit when-not or statement of how it differs from get_error/list_errors, which would have made this a 5.

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

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

Annotations cover only the safety profile (readOnly, non-destructive, open-world), and the description adds substantial non-obvious behavior: free solutions are ordered first, VPN providers appear only when a regional block is suspected, ordering uses documented criteria without commission, sponsored offers appear regardless of assessment/cache state, and affiliate links must not be opened automatically. That is real operational policy an agent could not infer from structured fields.

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 purpose is front-loaded in one clear sentence, but the remainder is a dense run-on that mixes output-field semantics, ordering rules and advertising policy into one paragraph. Much of that content is genuinely useful policy, yet it is hard to scan and partially duplicates fields the output schema already defines.

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 annotations covering safety and an output schema covering return shape, the description supplies the missing policy layer — ordering, disclosure obligations and how sponsored content must be presented. Coverage is strong for a read-only lookup; only operational limits (rate limits, cache freshness/expiry semantics) are absent.

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 are already documented, including the enum and the visitor_reported condition — and the description largely repeats that same visitor_reported explanation. It adds only marginal extra meaning (the HTTP 451 → news_or_legal_block default rationale), so the baseline 3 is appropriate.

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

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

States a specific outcome — 'Ways to reach a website that may be blocked in a country or region (geoblocking)' — which is clearly a different job from siblings like check_website or check_agent_readability. It also ties itself to those siblings by explaining it consumes the cached check result, so an agent can place it in the workflow. It stops short of explicitly naming the sibling tools it supersedes.

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 rather than stated: you call it when a site may be geoblocked, and the input notes cover the visitor-reported case. There is no explicit when-not guidance and no named alternative (e.g. 'use check_website first if you have no cached result'), which matters because a sibling does the underlying check.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds genuinely new context: that the method is 'versioned', what domains it covers, and the 'Not an official standard' caveat, all of which an agent needs to interpret the returned methodology correctly.

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 names the resource first and then lists contents efficiently, with the disclaimer placed last. Dense but every clause earns its place; 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?

An output schema exists, so return-value structure need not be explained, and for a zero-param read-only reference tool the description covers scope, versioning and the non-official caveat. The only missing element is a routing hint toward the scoring tool this methodology explains.

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 parameter semantics are not applicable and the baseline of 4 applies. The description correctly does not invent any input requirements.

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+resource ('versioned method of the ... Agent Readability Score') and enumerates what it returns (groups, 14 weighted checks, calculation, caps, bands, limits, MCP/WebMCP judging). This clearly distinguishes it from the sibling check_agent_readability, which computes a score rather than documenting how it is computed, though the description never names that sibling 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?

Usage is only implied: the agent can infer this is the reference doc to fetch when it needs to explain or justify a readability score. There is no explicit when-to-use or when-not-to-use statement, and no pointer to the related check_agent_readability sibling that produces the score this method describes.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds useful content-shape context (what fields a solution entry includes), which is more than the annotations give, but says nothing about lookup failure behavior when a slug doesn't exist.

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 tight sentence with no filler, front-loaded with the key noun phrase. It is efficient, though the field enumeration slightly crowds out an actual statement of what the tool does.

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?

An output schema exists and annotations cover the safety profile, so the return-value gap is minor. However, for a one-parameter lookup tool the description omits the input semantics and any routing versus explain_error, leaving the two most decision-relevant pieces unaddressed.

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

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

The single required 'slug' parameter has 0% schema description coverage and the description never mentions it at all, so an agent gets only the regex pattern to infer meaning. The description does not compensate for the coverage gap by explaining what a slug identifies or where it comes from.

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 enumerates what a solution entry contains (meaning, causes, steps, pitfalls, sources), which implies fetching a full entry, but never states a verb+resource directly ('retrieve the full solution for one error') and gives no differentiation from the sibling explain_error or list_errors. The purpose is inferable but the framing is a content list rather than a clear action statement.

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

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

There is no guidance on when to use this tool versus explain_error, list_errors, or get_access_solutions, and no mention of prerequisites or lookup behavior. The agent must infer usage entirely from the name and 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, so the safety profile is covered. The description adds behavioral context beyond them: the data is 'public' (implying no auth or tenant scoping) and explicitly excludes visitor analytics, which is the main risk of misinterpretation for a generic 'service info' tool.

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

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

One sentence plus a three-word exclusion fragment, with the content enumeration front-loaded. Every clause carries information (what metadata, what is excluded) 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?

An output schema exists, so return values need not be explained, and the description covers the content categories and the data boundary. The only gap is whether this is a global service-wide call or site-scoped, which is inferable from the zero-parameter schema but not stated.

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 and the schema is empty with additionalProperties=false, so there is nothing to document; baseline for a no-param tool is 4. The description correctly does not invent parameter details, and no input semantics are left ambiguous.

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 concrete resource (public service metadata) and enumerates its contents: measurement method, limits, schema versions, knowledge-base counts. The 'Never visitor analytics' clause carves out scope against adjacent data tools, but no sibling tool is named explicitly, so differentiation is by exclusion rather than routing.

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 'use this when...' guidance and no alternative named. The only usage signal is the negative scoping statement 'Never visitor analytics', which implies the tool is for service/configuration questions rather than analytics queries, leaving the positive trigger 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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds no behavioral context of its own — no pagination, result size, ordering, or whether an unfiltered call returns everything. It neither contradicts nor meaningfully enriches 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?

A single tight sentence with no filler, correctly front-loading the core verb and the optional filtering. It is efficient, though its brevity is achieved partly by omitting the guidance an agent actually needs.

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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. Still, for a two-parameter listing tool, the description leaves the param vocabulary and the sibling-routing question unanswered, making it only minimally complete.

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

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

Schema description coverage is 0% and the two parameters (kind, category) carry only maxLength constraints. The description merely restates their names through "filtered by category or kind" without explaining accepted values, formats, or the relationship between the two filters, so it fails to compensate for the coverage gap.

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

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

The description gives a verb and resource ("List knowledge-base entries"), but it is notably broader and vaguer than the tool name and title, which scope this to error messages. An agent cannot tell from the description alone how this differs from siblings like get_error or explain_error, which also concern errors.

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 says nothing about when to reach for this tool versus get_error/explain_error, nor any prerequisites or context. The only usage-adjacent content ("optionally filtered") is really parameter information, not 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 that this is a safe, idempotent, non-destructive read, so the description rightly focuses elsewhere. It adds genuinely useful caveats beyond the annotations: links appear 'only where verified' and the content is editorial rather than live user reports, which sets expectations about freshness and trustworthiness.

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

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

Three sentences, front-loaded with what the dataset is, then progressively more specific about fields (about text, error_slug/url, category_fixes). Dense with parentheticals and slightly note-like, but every clause carries information and nothing is 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?

With an output schema present, the description is not obliged to enumerate return fields, yet it helpfully names the key ones (error_slug, url, category_fixes) and explains their role. Combined with the zero-param schema and read-only annotations, this is complete enough for an agent to call and interpret the tool; only explicit when-to-use guidance 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?

The tool takes no parameters, so there is nothing for the description to disambiguate; baseline for a zero-param tool is 4. The description instead spends its words on result semantics, which is the right allocation for this tool.

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 makes clear this surfaces a curated set of popular services that have status pages, plus their verified official status links, editorial blurb and error-guide links. The verb 'list' is implicit from the name, but the content and scope are unambiguous enough that an agent can distinguish it from check_website or list_errors.

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: 'Editorial, not live user reports' hints that this is reference data rather than a live check, which nudges an agent away from using it for real-time status. However, no sibling tool is named and there is no explicit 'use this when…' condition, so the agent must infer the routing itself.

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