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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add useful context: concurrent and async processing, a cost of 0.005 USDC, and a return format of summary and content preview. However, it omits potential failure modes, rate limits, or side effects beyond the network operation. For a scraping tool, the lack of explicit read-only or error-handling information leaves some gaps, but the provided details are helpful.

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-organized, with the core function stated first, followed by a clear usage guideline and return summary. It avoids unnecessary filler and is front-loaded with the most critical information. The structure aids quick comprehension.

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 presence of an output schema and the tool's relatively simple purpose, the description covers the essential context: when to use it, what it does, and the output format. The only minor gap is the lack of explicit differentiation from sibling tools, but the batch aspect is clear from the 'up to 10 URLs' and the usage guideline. Overall, an agent can correctly invoke this tool.

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

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

The input schema covers 100% of the parameters with descriptions: 'urls' lists up to 10 URLs, and 'auth_token_or_tx' is optional. The tool description adds no new meaning beyond restating the limit ('up to 10 URLs') that is already in the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: it concurrently scrapes and extracts clean markdown from up to 10 URLs. The verb 'scrapes' and resource 'URLs' are specific, and the 'up to 10' limit distinguishes it from single-URL tools like clean_web_content. The purpose is unambiguous and immediately actionable.

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 includes an explicit usage guideline: 'Use when an agent needs to perform multi-source research across multiple search results simultaneously.' This provides clear context for when to invoke the tool, though it does not explicitly list alternatives or when not to use it. The guidance is sufficient for typical 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?

No annotations are provided, so the description carries full burden. It discloses the 15MB size limit, that password-protected/DRM/scan-only PDFs won't work without OCR, and summarizes return values. However, it doesn't disclose failure behavior on oversized inputs, rate limits, or how partial page parsing is signaled (only 'total/parsed page count' hints at it).

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

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

Front-loaded opening sentence and clearly labeled sections (Usage Guidelines, Constraint, Returns, Do NOT use). Slightly verbose with the multiple Do-NOT bullets, but every bullet adds routing 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?

Given there is no output schema disclosed in the prompt beyond a mention, the description compensates by naming what is returned (title, page counts, word count, text). Combined with the constraint and negative routing, an agent has everything needed to 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 coverage is 100% so the schema documents url, max_pages, and auth_token_or_tx. The description adds meaningful constraints beyond the schema: the required direct-PDF URL form and the 15MB limit. It doesn't explain when to supply auth_token_or_tx, but the schema description covers that.

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: 'parses and extracts structured plain text, sections, and academic metadata' from PDFs. Distinguishes itself from siblings clean_web_content and clean_youtube_transcript by naming them 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?

Explicitly states when to use it (scientific papers, technical docs, financial reports) and provides three Do-NOT-use clauses naming the correct alternative sibling for each case (HTML → clean_web_content, YouTube → clean_youtube_transcript, DRM/scanned → OCR caveat). Nothing is left 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the monetary cost (0.001 USDC) and that the operation returns page title, word count, text and token metrics, which suggests a read-only extraction. It still omits whether the optional auth_token_or_tx is ever required, any rate limits, or failure modes.

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?

Well front-loaded: purpose in the first clause with price attached, then a short labeled usage block. Every line is short and scannable, with only a minor redundancy in restating return fields that an output schema already covers.

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 strictly needed, and cost context is a genuine addition. The main gap is sibling disambiguation within a crowded family of clean_* tools and any auth requirement for the optional token parameter, leaving the definition adequate but not 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 100%, so the url and auth_token_or_tx parameters are already documented in the schema. The description adds no syntax, format, or auth semantics beyond it, 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 and resource ('Extracts ... plain text') and adds the intended downstream use ('optimized for RAG embedding and vector indexing'). However, it never distinguishes itself from the sibling clean_web_content, which appears to overlap heavily, so an agent cannot tell the two apart from the text 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?

Gives implied context ('when ingesting raw webpage text directly into vector databases') which is a real usage signal. But it offers no when-not guidance and, critically, does not route the agent to or away from clean_web_content, clean_pdf_research, or clean_youtube_transcript, so the alternative-selection decision is left unresolved.

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 burden and does well: it discloses the cleaning behavior (ads, cookie banners, nav clutter stripped), the return shape, and the failure boundary (paywalled/login-required/bot-blocked sites). It stops short of mentioning that some sites may require the micropayment auth token, which the schema hint implies.

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?

Front-loaded with the core purpose, then a tightly scoped bulleted usage block. Every line 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?

An output schema exists and the description still summarizes the return payload (markdown body, title, word count, metadata). For a single-URL scraping tool, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, including the x402 token and robots.txt flag. The description adds no further parameter semantics, so baseline 3 applies.

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

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

States a specific verb (scrapes/converts) and resource (web page), and explicitly enumerates what it strips. It distinguishes itself from siblings clean_youtube_transcript and clean_pdf_research by name.

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 explicit when-to-use (real-time articles, blogs, docs into LLM context) and three explicit when-NOT-to-use clauses naming the correct alternative tool for each. Nothing is left 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?

With no annotations, the description carries the full burden and does disclose return contents, unsupported inputs (private/unlisted/age-restricted/live), and fallback error reporting. However, it is silent on a major behavioral trait implied by the schema: the x402 micropayment/auth token requirement, which an agent must satisfy before calling.

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?

Front-loads the core capability, then uses labeled sections for usage and returns, which is easily scannable. Slightly padded by marketing phrasing like 'Google Gemini Flash intelligence' and 'high-precision', which don't affect selection.

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 details are optional, yet the description still summarizes outputs and covers input restrictions and failure modes thoroughly. The one real omission is the payment/authorization context tied to auth_token_or_tx.

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 the url pattern, lang default and examples, and auth_token_or_tx all documented in the schema itself. The description adds no syntax or format 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?

States a specific verb (extracts) and resource (subtitles, timestamped transcripts, AI summaries) for public YouTube videos. Explicitly differentiates itself from the named sibling tools clean_web_content and clean_pdf_research.

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

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

Provides an explicit when-to-use list (lectures, tutorials, tech talks, podcasts) plus three concrete 'Do NOT use' exclusions that route the agent to the correct alternative and warn about unsupported video types. The fallback-error behavior is also 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the cost (0.150 USDC) and the return shape (executive briefing markdown with citations and takeaways), but says nothing about auth requirements (the x402 param), latency, failure modes, or source-verification 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?

Well front-loaded: the core purpose and price lead, followed by labeled 'Usage Guidelines' and 'Returns' sections. Slightly redundant to restate the return format when an output schema exists, but the description is compact and free of 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 re-explained, and the cost plus primary use case are covered. The notable gap is the absence of annotations and any description of auth/permission behavior around auth_token_or_tx, which an agent paying per call would benefit from knowing.

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

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

Schema description coverage is 100%, so the schema already documents query, max_sources (1-5), and auth_token_or_tx. The description adds no syntax, format, or defaulting guidance beyond what the schema provides, 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?

States a specific compound action (multi-source web crawling + AI synthesis) and a concrete deliverable (executive research briefing), which is clearly differentiated from the 'quick' sibling search_web_quick by the word 'deep'/comprehensive. It stops short of explicitly naming that sibling, so an agent must infer the contrast from the adjective 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 'Usage Guidelines' section gives a clear contextual trigger ('use when an agent needs a comprehensive deep dive ... with verified source citations'). However it never states when NOT to use it, nor names search_web_quick as the cheap/fast alternative, so the routing decision is left implicit.

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 exist, so the description carries the full burden. It usefully discloses the underlying model (Gemini AI) and the cost (0.030 USDC), which is real behavioral value. However, it says nothing about auth/payment requirements despite an auth_token_or_tx parameter, nor about rate limits or failure 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?

Front-loaded one-line purpose followed by clearly labeled Usage Guidelines and Returns sections. Every line is relevant; it is tight and scannable with 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 detail is not required. The description covers purpose, usage context, cost, and return shape, which is sufficient for invocation. The main missing piece is any note on the payment/auth flow implied by auth_token_or_tx.

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 in the schema, making baseline 3 appropriate. The description restates the 'schema_description' concept and the JSON return but adds no syntax or format detail beyond the schema.

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

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

Names a specific verb and resource: 'Extracts schema-constrained structured JSON data from any webpage,' and adds distinguishing detail (Gemini AI, 0.030 USDC). It does not explicitly differentiate itself from close siblings like clean_web_content, search_web_quick, or deep_research_topic, but the purpose is 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?

An explicit 'Use when...' condition with concrete examples (pricing, specs, event dates) directly from a URL. It lacks any when-not-to-use guidance or named alternatives among the many sibling web/content tools, so it stops short of the top score.

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 return values (Pass tier, remaining balance, expiration timestamp) and the input types, but does not mention potential side effects, rate limits, or error conditions. For a read-only status check, this is adequate but not rich.

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 front-loaded with the core purpose, followed by a usage guideline and return summary. It is efficient, though the 'Returns:' line is somewhat redundant with the output schema.

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

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

Given the tool has a single parameter, an output schema, and no nested objects, the description is nearly complete. It explains the purpose, usage context, and return values. It could mention error cases or what happens if the wallet/token is invalid, but that is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents the parameter. The description adds a bit of context by mentioning the example 'WELCOME100' and the 0x... format, but it largely repeats what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool checks subscription status, remaining query quota, and validity period for an agent EVM wallet address or VIP Pass Token. It uses a specific verb ('Checks') and resource, and the usage guideline clarifies its role in verifying micropayment allowance before heavy scrape batches, distinguishing it from siblings like get_payment_info.

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 to use the tool: 'Use to verify micropayment allowance or query entitlements before dispatching heavy scrape batches.' It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it appropriately among siblings.

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

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

With no annotations, the description carries the behavioral burden well. It states the tool is informational ('Returns', 'discover ... before making x402 paid queries') and discloses return format (structured markdown table, contract addresses, vault endpoints), implying a read-only preflight operation. It does not explicitly say 'does not initiate payment' or mention auth/rate limits, but those are less material for a config-retrieval 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?

The key return information is front-loaded in the first sentence, and the usage/do-not-use bullets are concise. Minor redundancy exists between the opening 'Returns...' and the 'Returns:' bullet, but the bullet adds useful return-format details.

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

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

For a read-only configuration tool with no required parameters and an output schema, this is complete: it covers what data is returned, which chains are supported, why an agent would call it, and what not to use it for. No additional context is needed to select or invoke it correctly.

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

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

Schema coverage is 100% and both optional parameters already have clear descriptions in the schema, so the baseline applies. The tool description adds chain IDs (137, 8453, 42161) and context about pricing tiers, but it does not significantly expand on the tier or chain parameter inputs beyond what the schema already 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?

The opening sentence names a specific action and result: returns complete Web3 x402 micropayment configuration, USDC contract addresses, chain IDs, recipient wallet, and pricing tiers for CleanWeb Studio tools. This clearly distinguishes it from sibling tools, especially get_vault_balance.

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 gives explicit guidance: use this tool to discover network parameters and deposit requirements before x402 paid queries, and explicitly warns against using it for wallet balances, directing to get_vault_balance. This is exactly the when/when-not/alternative guidance the rubric asks for.

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 behavioral burden. The verb 'Checks' implies a read-only operation, and the return fields are listed, but it does not explicitly state safety traits (e.g., read-only, non-destructive) or authentication/rate-limit requirements. Partial transparency.

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

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

The description is front-loaded with purpose, then cleanly organized into usage guidelines and returns. Every sentence adds value, and there is no redundant or filler text.

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

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

For a simple read-only balance check with one parameter and an output schema, the description covers purpose, usage guidelines, and return fields. The output schema handles return values, so the description is complete without needing to explain them further.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter thoroughly. The description restates 'for an agent wallet address or session key' but adds no additional syntax, format, or edge-case detail beyond the schema. Baseline 3.

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 (checks) and resource (remaining pre-funded USDC balance, total usage, session status), scoped to an agent wallet address or session key. It distinguishes itself from the sibling get_payment_info by explicitly excluding pricing and chain parameters.

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 gives explicit when-to-use guidance ('Use this tool before executing heavy tasks to verify sufficient balance') and when-not-to-use guidance ('Do NOT use for querying pricing or chain parameters (use get_payment_info)'), naming the alternative tool directly.

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 behavioral burden. It discloses a cost (0.002 USDC) and the return shape, which is useful, but says nothing about rate limits, auth requirements (the auth_token_or_tx param is silently optional), failure behavior for unreachable sites, or the distinction between sitemap discovery and anchor traversal modes.

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?

Front-loads the verb and resource in the first sentence, then uses a labeled 'Usage Guidelines' block and a 'Returns' line. Slightly redundant ('Firecrawl /map equivalent' is a marketing reference rather than operational guidance), but overall tight.

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 the description still summarizes the return fields (target URL, domain, URL count, URL list, sitemap status), which is helpful but not strictly required. The main gap is that auth/payment semantics for the optional auth_token_or_tx parameter are left unexplained despite an advertised per-call cost.

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, max_links, auth_token_or_tx) are already documented in the schema with examples, defaults, and bounds. The description adds no parameter-level detail beyond what the schema 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?

The description states a specific verb+resource ('Discovers domain sitemap or traverses internal anchor links to return a canonical URL tree'), which is clear and unambiguous. It does not, however, differentiate itself from named siblings like search_web_quick or clean_web_content, which an agent might reasonably confuse with site traversal.

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 says to use it to map an entire website or documentation site before scraping, which gives a clear pre-scrape context. It stops short of naming an alternative tool or stating when NOT to use it, so it's clear context without exclusions.

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

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

With no annotations, the description carries the full burden and does well: it discloses the 0.035 USDC cost, the cryptographic signing, the EIP-712 scheme, the verifier contract, and how the signature can be checked on-chain or off-chain. It omits rate limits, failure/refund behavior, and auth flow specifics, keeping it short of 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?

The core capability sentence is front-loaded and the remaining content is organized as scannable bullets. The pipeline enumeration is dense but each clause adds real information; nothing is 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?

For a paid, signing oracle tool with an output schema and full param coverage, the description supplies cost, return shape, and verification path. It could still say more about the payment/auth prerequisite and error modes, but an agent has enough to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents query, max_sources, auth_token_or_tx, and target_schema_json. The description adds only the cost figure (0.035 USDC) that loosely relates to the payment param, so baseline 3 applies.

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

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

The description names a concrete multi-step pipeline (web search, markdown extraction, Gemini JSON structuring, EIP-712 signing) that clearly states what the tool does. It implicitly distinguishes itself from sibling tools like search_web_quick or clean_web_content by adding the signed-attestation step, but it never names a sibling to route the agent 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?

It gives a clear when-to-use condition: 'when an autonomous agent or smart contract requires verified, tamper-proof ground truth from the live web.' That is good context, but there are no exclusions or named alternatives (e.g., search_web_quick vs deep_research_topic), so the agent must infer which sibling to pick.

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 supplied, so the description carries the full burden. It usefully discloses real-time latency, per-call cost (0.002 USDC), and that returned URLs are 'verified', and the operation is a non-destructive read. It omits rate limits, whether the auth_token_or_tx parameter is required for a paid call, and any failure behavior, which a no-annotation mutation-capable service should ideally state.

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?

Content is front-loaded: purpose, cost, then a compact 'Usage Guidelines' block. Every sentence carries information, though framing two short lines as 'Usage Guidelines' is slightly padded and could be a single clause.

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 fields need not be spelled out, and the description stays appropriately brief on that front. Yet with zero annotations, the description leaves gaps around authentication (the optional x402 token), pricing verification, and how this tool relates to the deep-research siblings, so an agent must still guess at the invocation context.

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

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

Schema description coverage is 100%, so the schema already documents query, max_results, and auth_token_or_tx. The description adds no syntax, format, or constraint detail beyond the schema, only the cost and the shape of results. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'fast real-time keyword web search' returning titles, links, and snippets, plus a cost figure. This is far more concrete than a tautology. However, it does not distinguish itself by name from siblings like deep_research_topic or oracle_grounding, leaving the agent to infer the boundary from the word 'quick' 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 line 'designed specifically for LLM autonomous agent retrieval' describes a general audience but gives no when/when-not conditions and names no in-toolset alternative (Tavily and s.jina.ai are external competitors, not routing targets). Usage is implied by 'fast' and 'keyword' contrasting with deeper research tools, but it is never made explicit.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that verification is off-chain and gas-free and that it returns a validity verdict plus signer/oracle/message, but it omits error behavior, what an invalid result implies, and any permission or rate assumptions.

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?

Front-loaded with the core operation, then a short usage block and return summary. It is tight overall, though the 'Returns' line partly duplicates information the output schema already carries.

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 four-required-parameter verification tool with both a full-coverage input schema and an output schema, the description is nearly sufficient. The only real gap is distinguishing it from the sibling oracle_grounding.

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

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

Schema description coverage is 100%, so the schema already explains all four parameters (query, data_hash, signature, timestamp). The description adds no format or edge-case details 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 gives a specific verb ('Verifies') and a precise resource ('EIP-712 cryptographic attestation produced by CleanWeb Oracle'), plus the notable constraint that it runs off-chain. It does not, however, differentiate itself from the sibling 'oracle_grounding', so an agent cannot route between the two from this text 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?

It gives a clear when-to-use condition ('to mathematically verify that data received from CleanWeb Oracle has not been tampered with'), which is concrete and actionable. It stops short of naming alternatives or stating when not to use it (e.g., vs. oracle_grounding), so it falls below the top tier.

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