ZadenWorks

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

No annotations are provided, so the description carries the full burden. It clearly discloses the paid nature, the payment amount, and the x402 flow, and it states the tool performs HEAD checks for robots.txt and sitemap.xml. While it doesn't explicitly label itself as read-only, the audit nature and lack of side effects are implied. This is transparent enough but could be more explicit about persistence or side effects.

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: scope, output, usage limits, performance, and payment flow are each covered succinctly in separate sentences. No fluff or redundant information; every sentence adds 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?

Despite being a paid tool with a multi-step payment process and several optional parameters, the description gives sufficient context: what it does, what it returns, how many URLs, and how to handle the payment. An agent can correctly invoke the tool without missing critical information.

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 each parameter already has a detailed description. The main description does not add per-parameter semantics beyond the schema (e.g., the payment flow for x_payment is already in the schema). This matches the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool audits on-page SEO fundamentals, enumerating specific elements (title, meta description, canonical, Open Graph, Twitter Card, headings, robots directives, viewport, robots.txt, sitemap). This differentiates it from sibling tools like check_links or scan_accessibility, making its 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 explicit usage guidance: up to 10 URLs per call, no browser (fast), and a detailed payment workflow via x402 (call once without x_payment to receive challenge, then retry with it). It also explains the output format (prioritised issue list and 0-100 score), which helps agents know what to expect.

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?

No annotations are provided, so the description carries the full burden. It discloses the paid nature ($0.02), the first-call challenge, the site limit, the sampling limit (maxUrlsToSample), and the output structure (score, grade, severity, issue list). This is highly transparent.

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

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

The description is detailed but not excessively verbose. It lists the audit checks and then the return/limit/payment aspects in a logical order. Some redundancy with the schema exists, but it remains appropriately sized for the complex behavior.

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

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

Given there is no output schema, the description adequately describes the return type and the payment flow. It covers all necessary invocation context (limits, payment, sampling) and is complete for an agent to understand and call the tool.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds no new meaning beyond the schema; for example, the x_payment flow and bare-domain note already appear in the schema 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?

States a specific verb 'Audit' and the precise resource ('site crawlability from robots.txt and XML sitemaps'). It clearly distinguishes from siblings like audit_seo (broader SEO) and check_links (link checking) by focusing on sitemap/robots checks.

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

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

Provides clear usage guidance, including the payment challenge flow (call once without x_payment, then retry with it) and the site limit (max 2). It does not explicitly contrast with alternatives like audit_seo, but the domain-specific wording makes when-to-use sufficiently clear.

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

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

The description discloses the payment flow, including the first unpaid call to receive a challenge, the flat fee, and the weight-based sizing. It does not mention side effects or data retention, but the operations are read/watch/verify/compare/extract, which are non-destructive by nature.

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 mostly clear but repeats the weight and pricing details twice, making it longer than necessary. The structure is logical, but trimming redundant sentences would improve focus.

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 lack of an output schema, the description still provides enough context about supported operations, required fields, payment behavior, and weight limits. It does not describe result formats, but that is not essential for selecting and invoking the tool.

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

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

The main parameters (items and x_payment) are explained, and the nested op-specific fields are partially described in the schema. However, optional fields like key, selector, includeLinks, and maxRowsPerTable are not explained beyond their names and type constraints, leaving some ambiguity about their intended usage.

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 batches multiple page operations into a single payment, with explicit verbs like 'run a mix of' and 'process more than one URL'. It also distinguishes this from paying per operation individually.

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 explicitly says to use this whenever processing more than one URL and explains the savings on payment negotiations. It also lists the supported operations and which fields each op requires, making selection straightforward.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses the network behavior (HEAD/GET requests), payment requirement ($0.02 per call via x402), and response details (status, redirect, time, severity, score). It does not mention data persistence or side effects beyond the request itself, but the essential behavior is well covered.

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 somewhat verbose and repeats similar information (e.g., 'Each anchor is resolved...' and 'Gives a 0-100 score...') but every sentence adds useful detail about behavior, payments, or limits. It could be tightened without losing information, but it is not redundant enough to harm usability.

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

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

The description fully explains the input constraints, payment challenge flow, link-checking methodology, output metrics (status, redirect, time, severity, score, grade), and exclusions. Even without an output schema, the description gives a complete picture of what the tool does and what to expect, making it self-sufficient for an agent.

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

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

The schema covers 75% of parameters with descriptions. 'urls' and 'x_payment' have thorough descriptions, 'checkExternalLinks' is clearly described, and 'maxLinksPerPage' lacks a description but its name and min/max/default constraints make its meaning unambiguous. Overall parameter intent is well conveyed.

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

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

The description uses a specific verb ('Check') and resource ('links'), and clearly distinguishes this tool from SEO, sitemap, and rendering tools by focusing on broken-link detection with detailed methodology. The role is unmistakable even without sibling names.

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 the workflow (first call without x_payment to get challenge, then retry with payment), and clarifies exclusions (anchors, mailto, tel) and constraints (max pages, max links). It does not explicitly contrast with sibling tools, but the unique focus on link integrity is evident and sufficient for most selection 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?

The description discloses the paid nature and the x402 payment challenge flow, which is important behavioral context. However, it does not explicitly state that the tool is read-only or that it fetches external URLs, though these are implied. Given no annotations are provided, the description carries the full burden but is only partially transparent.

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

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

The description is a single, focused sentence followed by a concise payment note. It is efficient, well-structured, and free of redundant information.

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

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

The description explains what the tool returns (unique paragraphs, word count delta, identical flag) and outlines the payment challenge flow. It lacks output format details or error handling, but the essential information for calling and understanding the result is provided.

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 has 80% coverage (descriptions for 4 of 5 parameters). The tool description itself adds no parameter-specific information, so it falls to the baseline of 3 for high schema coverage. It does not clarify maxDiffItems, but the schema's default and constraints already communicate its meaning.

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

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

The description clearly states the tool compares two URLs and reports differences: unique paragraphs, word count delta, and identical status. This is specific and distinguishes it from the sibling tools, which focus on single-page audits or batch operations.

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 explicit guidance on the payment flow ('call once without x_payment to receive the payment challenge'), which is a key usage instruction. It does not explicitly mention alternatives, but the purpose is unique among siblings, so the intended use is clear.

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

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

The description discloses the paid nature ($0.01) and the x402 payment challenge flow, but it does not mention behavior for pages with no tables, errors, or rate limits. More importantly, it claims 'every HTML table' while the maxTables parameter caps extraction at 20, creating a misleading expectation.

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

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

The description is compact and front-loaded with the core purpose and output format. The payment instructions are necessary and clearly separated, though the 'Saves hand-parsing' clause is a minor value-prop addition rather than essential usage guidance.

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?

It describes the output shape well (headers, row arrays, row objects, caption) and the payment workflow, but there is no output schema and no mention of edge cases like absent tables, malformed HTML, or what the first response (payment challenge) looks like. Given the tool's complexity, this leaves some gaps.

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

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

Of the five parameters, the description only elaborates on x_payment; url, selector, maxTables, and maxRowsPerTable are left to the schema descriptions. Since schema coverage is moderate (60%), the prose should add more guidance on how these parameters affect extraction.

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

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

The description uses a specific verb ('Extract') and resource ('every HTML table') and clearly states the structured JSON output format. It distinguishes this tool from sibling tools like read_page or render_url by focusing on table extraction.

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 the x402 payment flow (call without x_payment to get a challenge, complete payment, retry), which is useful. However, it does not explicitly say when to use this tool versus alternatives such as read_page or render_url, aside from the implicit 'saves hand-parsing' value proposition.

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?

No annotations are provided, so the description must disclose side effects or read-only behavior. It only says 'list' which implies read-only, but it does not explicitly confirm no side effects, rate limits, or authentication requirements.

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

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

The description is a single concise sentence that front-loads the action and resource. It includes a relevant note about being free without unnecessary detail.

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 should clarify what the response contains. It states 'ranking categories' but does not specify the format (e.g., list of strings, objects) or whether it includes metadata. This leaves some ambiguity for the agent.

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

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

The tool has no parameters, so there is nothing to explain. The baseline for zero parameters is 4, and the description does not need to add param details because none exist.

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 lists available x402 service ranking categories, using a specific verb and resource. It is distinct from sibling tools like rank_x402_services, which perform ranking rather than listing categories.

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 hints at usage by noting it is free and returns currently available categories, implying it should be used to discover valid categories before ranking. However, it does not explicitly state when to prefer this tool over rank_x402_services or other 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It transparently reveals that the tool is paid, requires a two-step payment process, and that it uses the live Coinbase Bazaar feed. However, it does not explicitly state whether the operation is read-only or mention any potential side effects, so it is not fully transparent.

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

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

The description is well-structured and concise despite including necessary details. It starts with the main purpose, then lists ranking criteria and the data source, and clearly separates the payment instructions. There is no redundant information, and every sentence adds 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?

The tool lacks an output schema, so the description is the only source of information about what is returned. It states that a ranked list of services is provided, with ranking based on specific criteria, which gives a reasonable expectation. However, it does not specify the exact fields or structure of each service entry, leaving some ambiguity.

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?

Both parameters are thoroughly explained. The category parameter is described as a name from list_rank_categories, and the x_payment parameter is fully detailed, including its optional nature, its role as an X-PAYMENT header, and the instruction to use it after a completed payment. This goes beyond the schema descriptions to give clear semantic meaning.

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

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

The description clearly states the tool's function: to retrieve a ranked list of x402 pay-per-call services for a given category, with ranking based on price, usage volume, and recency. It also distinguishes itself from the sibling tool list_rank_categories by indicating that list_rank_categories should be used first to obtain valid categories.

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 explicit guidance on when and how to use the tool. It instructs to call list_rank_categories first to see valid categories, and it explains the payment model: the first call should omit x_payment to receive a payment challenge, then after completing payment the tool should be called again with the x_payment value. This is a clear usage sequence.

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?

No annotations are provided, so the description carries the burden. It discloses the paid nature and payment challenge, but does not explicitly state whether the operation is read-only or if any side effects occur.

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 concise and well-structured, with the core function stated first and the payment mechanism in a separate sentence.

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?

It covers the main function, output type, and payment flow. Since there is no output schema, it does not need to specify return fields, but could mention potential limitations like page size or error conditions.

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 descriptions already cover all parameters. The description adds useful context about the x_payment flow, but does not elaborate on selector, includeLinks, or includeImages 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 action ('Extract'), the resource ('URL'), and the output ('clean readable markdown/text'), differentiating it from raw rendering by specifying stripped navigation/ads/scripts.

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 provides some operational guidance on the x402 payment flow, but does not explicitly compare against sibling tools like render_url or extract_tables to indicate when read_page is the preferred choice.

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

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

With no annotations, the description carries full burden. It transparently discloses that the tool is paid ($0.02 per call) and explains the two-step payment mechanism. It also notes it uses a 'real headless browser,' implying JavaScript execution and external resource loading, setting accurate expectations.

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

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

The description is two sentences, front-loaded with the primary action and output types, followed by concise payment instructions. No filler or redundant information; every sentence adds 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?

The description handles the complex payment flow well and sets expectations about the headless browser. It lacks explicit guidance on when to choose this over siblings like read_page, but the distinct output capabilities and paid nature make the context reasonably complete for a tool at this complexity.

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 only 29% (2 out of 7 parameters described). The description adds little about width, height, waitMs, fullPage, and format beyond what the schema already provides via defaults and enums. It only indirectly references format via the output types mentioned, but fails to explain the purpose of layout-related parameters.

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 renders any public URL with a headless browser and returns a screenshot, PDF, or JS-rendered HTML. The verb 'Render' and resource 'any public URL' are specific, and the output formats distinguish it from read_page or other simple retrieval tools.

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

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

The description explicitly explains the payment flow: call once without x_payment to get a challenge, then complete payment with x402 tooling and retry with the x_payment header. This is actionable guidance for when and how to use the tool, preventing common mistakes.

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

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

With no annotations, the description carries the behavioral burden. It transparently describes the static-only nature, the specific checks performed, the return summary, and the x402 payment challenge/retry 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?

The description is reasonably concise given the amount of information it conveys. It front-loads the purpose and key checks, then details limitations and payment behavior without unnecessary 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?

Even without an output schema, it describes the return contents (score, letter grade, severity, prioritized issue list). It also covers payment requirements and static limitations, making it complete enough for an agent to decide and invoke 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 covers 100% of parameters and both have meaningful descriptions. The x_payment parameter is especially well explained with the challenge-and-retry flow, and urls is clearly scoped to pages to scan with a max of 10.

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?

Clearly states it is a quick WCAG-oriented accessibility scan of page markup, enumerates specific checks (alt attributes, labels, lang/viewport, link names, duplicate IDs, heading levels), and distinguishes its return value (score, grade, severity, issue list).

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?

Explains when to use it by framing it as static HTML analysis and explicitly lists what it does not check (colour contrast, focus order, keyboard traps, runtime ARIA), which helps an agent avoid using it for dynamic accessibility audits. It also gives the payment challenge workflow.

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?

Discloses the payment requirement, the $0.01 per call cost, the x402 payment flow, and the need to first call without x_payment to receive a challenge. Also describes the output format (score, grade, issue list). It does not mention rate limits or error handling, but the key behaviors are covered.

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

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

The description is a single, information-dense paragraph that covers all necessary aspects without fluff. While slightly long, it is efficient and flows logically from purpose to details to payment.

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 payment complexity and the multiple validation aspects, the description provides sufficient context for invocation, output, and use cases. It explains the payment challenge flow, output format, and typical scenarios, making it self-contained for an agent.

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

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

The schema descriptions fully cover both parameters, including the max 10 URLs limit and detailed x_payment instructions. The tool description reinforces the payment workflow, 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 validates JSON-LD structured data and social preview tags, and enumerates specific checks (schema.org types, required fields, JSON parse, Open Graph, Twitter Card). This distinguishes it from sibling tools like audit_seo which likely cover broader 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?

Explicitly notes usefulness before publishing and for diagnosing missing preview cards when shared. While it does not directly compare to sibling tools, the specificity of the described checks makes its niche evident.

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

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

The description clearly discloses the main output behavior (verdicts: exact_match, close_match, not_found) and mentions the payment challenge process. Since no annotations are provided, it carries this burden well, though it does not explicitly state that it is read-only or non-destructive.

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

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

The description is compact and well-structured: a clear purpose statement, a summary of return values, and the payment note. No redundant or tangential wording.

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

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

The description covers the essential operational details: the return verdict set, the payment challenge, and the URL/claim parameters. Since there is no output schema, the description could have elaborated slightly on the confidence score format, but it is otherwise sufficient for the tool's simple purpose.

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?

All 4 parameters have descriptive schema entries, and the description adds important context for x_payment (the payment challenge flow). The 100% schema description coverage fully compensates for any missing detail in the prose.

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

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

The description clearly states the tool's purpose: 'Check whether a claimed quote or fact actually appears on a URL' with a specific verb, resource, and a helpful label ('cheap citation/hallucination checker'). This distinguishes it from sibling tools like read_page and render_url.

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 some usage context by describing it as a cheap citation checker and explaining the x402 payment flow ('call once without x_payment to receive the payment challenge'). However, it does not explicitly mention when to prefer this over sibling tools such as read_page or compare_pages.

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?

No annotations are provided, so the description carries full responsibility. It discloses the paid nature (via x402), the baseline establishment, and the diff output. It does not explicitly mention that the tool does not modify the URL or have side effects beyond fetching, but given its read-only intent, the transparency is adequate. Minor lack of detail on error handling or rate limits prevents a perfect score.

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 mostly clear but contains redundant phrasing: the sentence about first call establishing a baseline and subsequent calls returning true/false with added/removed content appears twice. This repetition adds unnecessary length without new information. Otherwise, the structure is logical and easy to follow.

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?

Since there is no output schema, the description explains the output format: null on first call, true/false plus a diff on later calls. It also covers the payment workflow and the optional namespace. It does not mention potential error scenarios or what happens if the URL is unreachable, but for a standard use case, the description is complete enough for an agent to proceed.

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 tool description adds meaningful context, especially for the x_payment parameter (the challenge-and-retry flow) and for the diff semantics. The description of 'key' as a private namespace complements the schema. The 'selector' parameter is adequately explained in both schema and description.

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

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

The description clearly states the tool's purpose: to check whether a URL's content has changed since the last check, using a paragraph-level diff. It distinguishes itself from sibling tools like read_page or render_url by focusing on change detection. The verb 'watch' and resource 'page' are specific and unambiguous.

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

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

The description provides explicit when-to-use instructions: first call establishes a baseline, subsequent calls report changes. It also explains the shared vs. private baseline mechanism via the 'key' parameter and the x402 payment workflow (omit x_payment to get a challenge, then retry). This leaves no ambiguity about how to invoke the tool correctly.

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