webbersites-x402-data-api

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

The description contradicts the annotation destructiveHint=false by stating the tool deletes data, which is a destructive action. While it adds context about cost and quota, this contradiction undermines transparency and may confuse the agent. No additional behavioral traits beyond the cost and quota are disclosed.

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

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

The description is concise with two sentences. The first sentence states the primary action clearly, and the second adds necessary context (quota and cost). Every sentence serves a purpose with no redundancy or superfluous 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?

Given the tool's simplicity (single parameter, simple operation) and the presence of an output schema, the description covers the key aspects: purpose, quota management, and cost. It does not mention error conditions or return values, but the output schema likely provides that information. Slightly incomplete for a delete operation, but acceptable.

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 the parameter 'name' described as 'Pad name in the URL path'. The tool description does not add extra meaning to this parameter. According to the rubric, with high schema coverage, a baseline of 3 is appropriate, and no additional semantic value is provided.

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 verb 'Delete' and the resource 'one of your wallet's scratchpads', distinguishing it from sibling tools like post_scratchpad_name (create) and get_scratchpad_name (read). The purpose is unambiguous and specific.

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 context on when to use this tool: to clean up and stay under the 50-pad quota. It also mentions the cost ($0.001 per call). However, it does not explicitly exclude other tools or provide comparative guidance against alternatives like not deleting. The guidance is sufficient but not exhaustive.

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 claims the tool 'drops' a collection (implying destruction), but the annotation destructiveHint=false indicates the tool is not destructive. This is a direct contradiction, severely misleading the agent about the tool's effect. Additional cost info is provided but does not resolve the contradiction.

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 with no redundant information. The first sentence clearly states the action, and the second adds context on cost and quota management. Every sentence serves a purpose.

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?

While an output schema exists (mitigating return value concerns), the description fails to clarify the tool's destructive nature due to the contradiction with annotations. It adds cost and quota context but omits behavioral details like permissions or reversibility, which are critical given the deletion action.

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 'collection' parameter. The description repeats the parameter name without adding new semantic meaning, meeting the baseline standard.

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 the specific verb 'drop' to indicate deletion, clearly identifying the resource as 'one of your wallet's collections and all its rows.' This distinguishes it from sibling tools like get_store_collection (read) and post_store_collection (create).

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 mentions 'clean up after yourself and stay under quota,' providing context for when to use the tool (managing storage limits). However, it does not explicitly state when not to use it or name alternative tools, though the sibling set makes delete unique.

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?

Description adds value beyond annotations by revealing static analysis nature, honest reporting of limitations, and pricing ($0.01 per call). No contradiction with annotations (readOnly, idempotent, not 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?

Description is dense but readable; front-loaded with purpose. Could be slightly more structured but effectively communicates key points without fluff.

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 output schema exists, the description fully covers what the tool checks, its limits, and pricing. Context about siblings is implied through the specific checks listed.

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 already covers both parameters; the description adds context for the level parameter with format '?level=A|AA|AAA' and clarifies that filtering includes lower levels. This enhances 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 explicitly states it performs a 'WCAG accessibility check (static analysis)' and lists many specific checks (alt text, page title, lang, etc.), clearly differentiating it from siblings like get_a11y_contrast and SEO audit 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?

It mentions filtering with level and honestly notes limitations (cannot check contrast, focus, keyboard). However, it does not explicitly name alternative tools for those limitations; the sibling get_a11y_contrast could be suggested.

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

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

Annotations already declare readOnlyHint true and destructiveHint false, so the safety profile is clear. The description adds valuable behavioral context: it returns the exact contrast ratio, AA/AAA pass/fail for different text sizes, and a plain-English verdict, as well as cost information.

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, all essential: it explains the tool's function, output, differentiation, input format, and cost. Every sentence adds value with no wasted words.

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

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

Given the tool's simplicity, the input schema fully documents parameters, and an output schema exists (not shown but present), the description covers the tool's purpose, usage context, input types, and output content completely for an agent to select and 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%, so baseline is 3. The description adds meaning by specifying that colors can be given as hex or rgb() strings and provides the query format (?fg=&bg=), enhancing understanding beyond the schema's property descriptions.

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

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

The description clearly states the tool computes WCAG contrast ratio between two colors and differentiates itself from the sibling get_a11y_check by noting it does a check that the URL-based endpoint cannot do. This provides a specific verb and resource.

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

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

The description implies when to use this tool (when you need a specific color contrast ratio rather than a full page audit) by comparing with the URL-based a11y endpoint. It does not explicitly state when not to use it but provides enough context for appropriate usage.

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?

Adds value beyond annotations: mentions public access, newest-first ordering, pinned posts, free per call with x402 paid option. Complements readOnlyHint and idempotentHint well.

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?

Two sentences conveying essential behavior, ordering, filtering, and cost model. No fluff.

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 output schema present, description covers reading semantics, filtering, ordering, and cost. Complete for a read-only 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 covers both parameters with descriptions. Description reinforces filtering but adds 'feature, critique, praise, bug, tip' enum values not fully detailed in schema. Good synergy.

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?

Description clearly states 'Read the Machine Message Board' and explains what it contains (feature requests, critiques, praise, etc.). Distinct from sibling write tools like post_board.

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?

Indicates 'Free to read' and filtering options, but does not explicitly state when not to use or direct to alternatives. Contextually clear enough for an agent.

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 provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds significant context: deterministic behavior, no AI involvement, never executed as code, and cost details ($0.001 per call via x402).

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 yet comprehensive, with each sentence serving a clear purpose. It front-loads the core purpose and efficiently covers key details without redundancy.

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

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

Given the simple input (one parameter with full schema coverage) and presence of an output schema, the description adequately covers behavior, cost, and determinism, making it complete for the tool's 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?

The single parameter 'expr' is fully described in the schema (100% coverage). The description adds value by specifying max 400 chars and providing concrete examples, enhancing understanding 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 is for exact math that LLMs get wrong, specifies high-precision evaluation (50 significant digits), and distinguishes from siblings by mentioning specific operations like big-integer multiplication, roots, logs, and unit conversions.

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

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

The description implies when to use (when you need exact arithmetic that LLMs handle badly) but does not explicitly list when not to use or compare to alternative tools. However, it provides clear context for usage.

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?

Adds significant behavioral context beyond annotations: UTC, Mon-Fri business days, calendar validation, and even pricing. No contradiction with readOnlyHint/idempotentHint.

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?

Single paragraph efficiently covers purpose, usage, and behavioral notes without redundancy. Every sentence serves a purpose.

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?

Covers core use cases well, but does not specify behavior when all parameters are omitted (though optional). Output schema exists, so return format is handled. 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?

Description adds detailed usage patterns and examples (e.g., '?from=&to= → days', '?date=&add=30d') that go beyond schema descriptions, clarifying how parameters combine and expected formats.

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?

Description clearly states which date arithmetic operations it performs (difference, addition, info extraction) with specific examples and distinct patterns, distinguishing it from the generic get_calc sibling.

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 examples of how to use parameters for each operation, but does not explicitly state when not to use this tool or compare to alternatives beyond implied specificity.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable behavioral details: caching duration, cost per call, and the specific return fields (rate, converted amount, underlying prices). No contradiction with annotations.

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

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

The description is concise (three sentences plus a brief example) with no fluff. Core purpose is front-loaded, and each sentence adds distinct value: purpose, example, return values, and caching/cost information. Excellent structure.

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 an output schema (not shown but mentioned), the description appropriately covers usage context, accepted identifier formats, caching behavior, cost, and return fields. It is complete for an agent to understand and invoke the tool correctly.

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

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

With schema coverage at 100%, baseline is 3. The description adds meaningful context beyond schema descriptions: it explains that 'from' and 'to' accept CoinGecko IDs, tickers (e.g., btc, eth), or fiat codes, and provides an example query with amount. This enriches parameter understanding.

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 performs live crypto conversion between any coin/coin or coin/fiat using CoinGecko prices. It uses specific verbs and resources, and the example query further clarifies scope. This distinguishes it from siblings like get_price_coin which likely only returns prices without conversion.

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 context on caching (≤30s) and cost ($0.001/call), implying the tool is safe to call in loops. It does not explicitly list when not to use or alternatives, but the context of many get_* siblings makes the use case clear. A slight gap in explicit 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?

Annotations already indicate safe read-only behavior. Description adds details about the specific DNS records returned and the cost per call, which are useful beyond annotations. No contradictions.

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?

Description is a single, well-structured sentence that includes key information like records types, use cases, and pricing. It is front-loaded and efficient, though slightly lengthy.

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 that an output schema exists (indicated), the description adequately covers what the tool does without needing to explain return values. It is complete for a DNS lookup 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 has 100% coverage with a clear description of the 'domain' parameter. The description does not add additional semantics beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states it provides DNS and domain intelligence including specific record types and email security posture. It distinguishes from sibling tools like get_email_verify by focusing on DNS records and email security.

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 it is for deliverability, security, and research agents, and gives an example usage. However, it does not explicitly mention when not to use it or compare to alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: no signup, no external services, and a cost model ($0.002 per call via x402). It also lists all checks performed, which goes beyond the annotations.

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

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

The description is one sentence plus a cost note, which is concise and front-loaded with purpose. However, it could be slightly more structured by separating the checks list from the note. It earns its place with no wasted words.

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 complexity (multiple verification steps), annotations, and presence of an output schema, the description is largely complete. It explains the tool's scope, cost, and self-contained nature. It does not explain return values but that is covered by the output schema.

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

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

Schema coverage is 100% (the 'email' parameter has a full description). The description adds high-level context about what checks are performed but does not add new meaning to the parameter beyond what the schema already provides. Baseline score 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 clearly states the tool's purpose: verifying emails for outreach and CRM agents. It lists specific checks (syntax validation, MX lookup, disposable detection, etc.) and distinguishes itself from siblings like get_dns or get_seo_* by being the only email verification tool.

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

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

The description implies it is for outreach and CRM agents but does not explicitly state when to use it vs. alternatives or provide exclusion criteria. No sibling differentiation is provided, leaving ambiguous when this tool should be preferred.

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 provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral details: scanned PDFs are flagged for OCR, pricing is $0.02 per call via x402, and the tool 'honestly flags scanned PDFs'. No contradictions with annotations.

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

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

The description is concise (3 sentences) and front-loaded with the core action and output. Every sentence adds value: format specifics, scanning behavior, pricing, and target audience. No fluff.

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

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

Given the tool's complexity (3 params, multiple formats, output schema), the description covers output format, scanning handling, and pricing. Minor gaps: no mention of URL restrictions (must be public http(s)) or error handling beyond scanned PDFs.

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 parameters are already described in the schema. The description adds context for the type parameter (auto-detect vs force) and mentions max_rows for CSV, but does not significantly enhance parameter understanding 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 fetches documents (PDF, DOCX, CSV) by URL and returns clean Markdown plus structured JSON, with specific details per format. However, it does not explicitly differentiate from sibling tools like get_scrape, which might also handle document content.

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 usage context ('For agents that need document contents, not bytes') and mentions pricing, but lacks explicit guidance on when not to use this tool or alternatives. It does not reference siblings for comparison.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating safe, idempotent lookup. The description adds behavioral context: 'fast in-memory lookup' and a cost of $0.001 per call (via x402). This goes beyond annotations without contradiction.

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?

Two sentences with no filler. The first sentence lists output fields; the second gives use cases and cost. Information is front-loaded and every word earns its place.

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

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

With a single optional parameter, 100% schema coverage, and an existing output schema, the description fully covers the tool's purpose, usage context, behavior, and cost. No gaps remain.

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%: the only parameter 'ip' has a description. The description adds context by stating 'any IPv4 or IPv6 address' and that omitting it geolocates the caller. This clarifies the parameter's usage beyond the schema alone.

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 returns IP geolocation data (country, region, city, coordinates, timezone) for any IPv4 or IPv6 address. It uses the specific verb 'get' and resource 'geo', and the sibling tools (e.g., get_dns, get_email_verify) serve different purposes, so differentiation is clear.

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

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

The description explicitly says the tool is for 'analytics, fraud, and personalization agents', providing clear use case guidance. It does not mention when not to use it or alternative tools, but no sibling exists for IP geolocation, so exclusions are unnecessary.

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, so the description adds value with pricing ($0.002 per call) and mentions ranking of results. This goes beyond what annotations provide, though no details on pagination or rate limits.

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?

Two sentences, no wasted words. Front-loaded with purpose, then usage instruction, then pricing. Well-structured for an AI agent to quickly grasp.

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 does not need to explain return values. It covers purpose, usage with another endpoint, pricing, and search behavior. Complete for a search 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%, so the schema already documents both parameters. The description adds example keywords for 'q' and clarifies the optional filter 'style' (solid, regular, brands). This adds meaningful context 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?

Description clearly states it searches Font Awesome Free icons by keyword, matching names, labels, and official search terms, and returns icon names and styles. It distinguishes itself from sibling tools that are unrelated (e.g., SEO, DNS, etc.) and hints at a follow-up tool (post_icon_generate).

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 instructs to use the chosen icon name in POST /api/icon/generate, providing a clear workflow. It mentions pricing, which is helpful. However, it does not explicitly state when not to use this tool or provide alternatives, but given siblings are mostly unrelated, this is adequate.

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

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

Annotations already mark the tool as read-only and idempotent. The description adds critical behavioral context: cost ($0.01 per call, paid via x402), the full set of returned data (tracklist, genres, etc.), and that it uses the Discogs database. No contradictions with annotations.

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

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

Two sentences: first conveys primary function and search methods, second adds target users and cost. Every sentence is informative and no unnecessary words. Front-loaded with key 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?

Given the presence of output schema (implied by 'tracklist...'), annotations covering safety, and the description listing return fields, the tool definition is complete. It covers what the tool does, how to use it, behavioral traits, and 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 coverage is 100% with descriptions for each parameter. The description adds grouping and usage patterns ('search by artist + title (or free-text q, or Discogs id)') which provides higher-level meaning beyond individual parameter descriptions.

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

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

The description clearly states 'Album metadata lookup' (verb+resource) and distinguishes from siblings like get_music_cover by focusing on full album data. It lists multiple search methods, making the tool's 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 explicitly states target users ('For music, playlist, and cataloging agents') and outlines three search methods (artist+title, free-text q, Discogs id). It does not, however, explicitly compare to alternatives like get_music_cover or state when not to use this tool.

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

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

Annotations already indicate readOnly, idempotent, non-destructive behavior. Description adds value by detailing the return format (base64 + data URI, dimensions, content type) and pricing, exceeding basic 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?

Extremely concise single sentence with no wasted words. Includes key details and pricing in a compact format.

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 output schema present and full parameter descriptions, the description is adequate. Pairs with sibling tool, explains return values, and mentions cost, making it contextually 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 coverage is 100% with each parameter described. The description adds limited context by referencing selectors from a sibling tool but does not significantly enhance parameter meaning 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 it retrieves album cover art via Discogs, specifying it returns base64 + data URI with dimensions and content type. It distinguishes from sibling get_music_album by focusing on cover image rather than album metadata.

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 pairs with get_music_album and mentions same selectors, providing clear context for when to use it. However, no explicit exclusions or alternative instructions are given.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds that it verifies image loading and format, returns problems/warnings/verdict, and mentions cost ($0.001 per call). No contradiction with annotations.

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

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

Two sentences: first front-loads the core function, second adds context and cost. Every sentence earns its place with no waste.

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, the description covers purpose, behavior, use case, and cost. It is complete enough for an AI agent to select 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 coverage is 100% with a clear description for the 'url' parameter. The description adds no further parameter semantics beyond 'any URL,' so 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 it is a social share/OpenGraph checker that extracts specific meta tags (og:*, twitter:*, title, description, canonical, robots) and verifies the og:image loads and is raster format. It distinguishes from siblings by focusing on sharing/SEO verification.

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

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

The description explicitly says 'For publishing and SEO agents shipping pages that get shared,' providing clear context. However, it does not mention when not to use or list alternatives explicitly.

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 idempotent, read-only, and non-destructive behavior. The description adds valuable behavioral context: deterministic, caching (~1.5s), cost model (x402), auto-fallback between exchanges, and no API keys required. No contradictions with annotations.

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

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

The description is detailed and informative, covering purpose, usage, parameters, and output. While it is relatively long, every sentence adds value. It is front-loaded with the core purpose. Minor room for tightening, but overall well-structured.

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

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

Given the tool's complexity (3 optional params, output schema present), the description is remarkably complete. It explains return fields (bids/asks, mid, spread, liquidity, slippage), cost, caching, exchange fallback, and depth limits. No gaps remain for agent understanding.

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 all parameters described. The description adds practical context: default depth (50), source options with examples, and pair format (e.g., 'BTC-USD'). It also provides a concrete query example, enhancing the schema's clarity.

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 specifies the tool's purpose: retrieving L2 order-book depth for crypto pairs, normalized across multiple exchanges, with specific analytics. The verb 'get' and resource 'orderbook' are well-defined, and the tool is distinct from siblings by its focus on live bid/ask ladder data.

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 outlines when to use this tool (live order book data, analytics like slippage estimates) and provides context (deterministic, no keys, cache, cost per call). However, it lacks explicit guidance on when not to use it or how it compares to sibling tools like 'get_price_coin' or 'get_report_coin'.

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, openWorldHint, idempotentHint, destructiveHint. Description adds behavior: 'Any HTTP response below 500 counts as up; redirects are reported, not followed.' No contradiction.

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?

Compact, front-loaded, every sentence adds value. No fluff.

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 good annotations and existing output schema, description covers purpose, usage, behavior, and cost. Complete for a simple ping 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?

Only one parameter (url) with 100% schema coverage. Description adds minimal meaning beyond schema (e.g., 'cheapest liveness ping'), but not needed. 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?

Description states specific verb+resource (ping URL for liveness) and distinguishes from siblings (get_uptime, get_uptime_report) by highlighting it's the cheapest and for high-frequency loops.

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 clarifies when to use (high-frequency monitoring loops) and when not (use get_uptime for redirect following or full report). Provides clear alternatives.

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 adds value beyond annotations by explaining the deterministic, single-fetch method, the fact that it works even when sites strip meta tags, and the cost. It does not contradict annotations (which indicate read-only, idempotent, non-destructive). A minor improvement could mention failure cases or rate limits.

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 (four sentences), front-loaded with the core question, and includes key details: method, platforms, evidence, cost. Every sentence adds value without redundancy.

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

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

Given the single parameter and existing output schema, the description sufficiently explains what the tool does and what outputs to expect (evidence, generator tag, server stack). It covers essential aspects for agent invocation.

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

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

Schema coverage is 100% for the single parameter 'url', so the description does not need to add much. The description states the URL should be public and http(s), but the schema already says that. No additional enrichment 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's purpose: 'What is this website built with?' and specifies deterministic fingerprinting from one fetch, listing many detectable platforms. It distinguishes from sibling tools like get_scrape by focusing on platform detection with evidence.

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

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

The description implies the use case (identifying website platform) but does not explicitly state when to use or when not to use this tool versus alternatives. There is no mention of exclusions or comparisons with sibling tools, so guidance is only 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description adds value by disclosing additional traits: cost ($0.001 per call), payment method (x402), and that it is a 'cheap, high-volume' operation. No contradictions with annotations.

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

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

The description is three sentences, each serving a distinct purpose: defining functionality, indicating usage context, and disclosing cost. It is front-loaded with the core purpose and contains no unnecessary words.

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 tool with one parameter and an existing output schema, the description covers all essential aspects: what it retrieves (price and 24h change), usage context (trading/analytics), cost, and payment method. Nothing critical 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 input schema has 100% coverage for the single required parameter 'coin' with a clear example. The description does not add further semantic details beyond reiterating 'by CoinGecko id', so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves the current USD spot price and 24-hour percent change for any crypto asset by CoinGecko ID. It uses specific verbs and resources, and the mention of 'cheap, high-volume price lookups' distinguishes it from potentially related tools like get_report_coin.

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

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

The description provides clear context by stating the tool is intended for 'trading and analytics agents' and highlights its low cost, implying frequent use is appropriate. However, it does not explicitly state when not to use the tool or mention alternatives like get_report_coin, so it misses the highest level of 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 declare readOnlyHint and idempotentHint. The description adds valuable behavioral info: cost ($0.02 per call, paid via x402) and describes the output contents. No contradiction with annotations.

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

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

Two sentences, front-loaded with key output details, no fluff. Efficient and clear.

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 simple schema, rich annotations, and presence of an output schema, the description provides sufficient context about the report contents. Adequate for an informed 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?

Schema covers the single parameter 'coin' with description and examples (100% coverage). Description repeats 'one asset' but adds no new meaning beyond the schema. Baseline 3 for full 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?

Description clearly states it provides an enriched crypto market report for one asset, listing specific data points (rank, multi-timeframe price changes, all-time-high context, signals, summary). It distinguishes from simpler price tools like get_price_coin by emphasizing 'not just a price'.

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 'For agents needing market context, not just a price', which implies when to use this tool versus a simpler price tool. However, it doesn't explicitly name the sibling get_price_coin as the alternative, leaving some inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating safe read. The description adds key behavioral details: the output is in Markdown, and the tool strips 'navigation, ads, and boilerplate.' It also reveals the cost and payment method (x402), which is critical for agent decision-making. No contradiction with annotations.

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

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

The description is two sentences long with zero waste. The first sentence front-loads the core operation and output; the second adds a use-case context and cost. Every part earns its place.

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

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

Given the tool's simplicity (one parameter), rich annotations, and presence of an output schema, the description is fully adequate. It covers purpose, use case, cost, and transparency about content stripping. No gaps remain.

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%: the single required parameter 'url' is described as 'Public http(s) URL of the page to fetch and convert to markdown.' The description does not add additional semantic detail about the parameter beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Fetch'), identifies the resource ('any public web page'), and specifies the output format ('clean, readable Markdown'). It clearly distinguishes the tool's role from siblings like get_extract or get_seo_* by focusing on generic scraping with boilerplate removal. The title 'Get Scrape' reinforces the purpose.

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 states the intended use case: 'For agents that need article text or documentation as Markdown.' It also mentions the cost model ($0.001 per call), which helps with selection. However, it does not explicitly exclude scenarios or name alternatives, missing an opportunity to differentiate from similar tools like get_extract or get_summarize.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds cost and payment method ($0.001 via x402), which is useful behavioral context beyond 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?

Two sentences, no wasted words. First sentence states purpose and output, second provides usage advice and cost. Efficient and front-loaded.

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

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

Given zero parameters, an output schema exists (context signal), and the description covers purpose, usage timing, return fields, and cost. No 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?

No parameters exist, schema coverage is 100% vacuously. The description adds value by naming the output fields, compensating for lack of param details. With zero params, this 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 action ('list your wallet's scratchpads') and the specific fields returned (names, sizes, updated and expiry dates). It distinguishes from siblings like get_scratchpad_name by implying a list of all scratchpads.

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 context for when to use: 'the cheap 'do I have memory here?' call for the start of a session.' Also mentions cost ($0.001 per call). Does not explicitly state when not to use, but the guidance 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?

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds value by disclosing that reading extends the pad's life by 30 days and that calls incur a $0.001 fee via x402. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose, then adding the raw parameter detail and key behavioral notes. No 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?

Given the tool's simplicity (2 parameters, high schema coverage, output schema present, and annotations covering safety), the description is complete. It covers purpose, usage, parameters, side effects, and cost, leaving no critical 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?

Schema coverage is 100% with descriptions for both parameters. The description adds slight additional meaning for the raw parameter ('?raw=1 for the bare document'), but the name parameter is already clear from schema. Baseline is 3, and description does not significantly enhance beyond 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 it reads a scratchpad, specifying the exact text/JSON from any session/machine, with identity tied to paying wallet. This is a specific verb-resource pair that distinguishes it from write operations like post_scratchpad_name, though sibling differentiation from get_scratchpad is implicit.

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

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

The description provides clear context on what the tool does and when to use it (reading a scratchpad). It includes details like adding ?raw=1 for bare document, but does not explicitly exclude other tools or state when not to use it. However, the context is sufficient for typical use.

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 adds behavioral details beyond annotations: it counts decorative alt='' separately, flags specific issues, and mentions cost ($0.001 per call, paid via x402). Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, which align with the description.

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: the first lists all audit checks, the second states purpose and pricing. It is front-loaded with key functionality, and every sentence adds value. No wasted words.

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

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

For a tool with one simple parameter and existing output schema, the description is complete. It covers the audit scope, intended audience, pricing, and annotations cover safety and idempotency. No 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?

Schema description coverage is 100% (the only parameter 'url' is described as 'Public URL of the page to audit'). The description does not add extra meaning beyond schema, but the schema itself is sufficient. 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 clearly states the tool's purpose as an 'Alt-text audit for any page' and lists specific checks (missing alt, filename-as-alt, generic alt, over-long alt, unlabeled SVG, image-map areas, image inputs). It distinguishes from siblings like get_seo_full_audit and get_a11y_check, which cover broader SEO or accessibility.

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 states 'For SEO and accessibility agents' implying the tool's target users. It does not explicitly state when not to use or list alternatives, but the sibling list and tool name make it clear this is for alt-text-specific audits.

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 and destructiveHint, so the description adds value by specifying the return format (0-100 score with itemized deductions and full sub-reports) and pricing. No contradictions with annotations.

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

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

The description is three sentences long, front-loads the main purpose, and includes essential details like the list of audits and cost. It is informative but slightly verbose; slightly more conciseness could improve it.

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 an output schema, the description adequately covers the key return aspects. It mentions the unified score and sub-reports, which is sufficient for an audit tool with rich annotations and schema.

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

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

Schema coverage is 100%, so the schema already documents both parameters (url and level). The description adds no new semantic information beyond restating the WCAG level purpose. 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 performs a full on-page audit bundle with seven specific analyses. It distinguishes from sibling tools that are individual checks (e.g., get_seo_head_check, get_seo_alt_check) by being a comprehensive bundle.

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

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

The description implies using the bundle for a comprehensive audit and mentions cost efficiency, but it lacks explicit guidance on when NOT to use it or when to use sibling tools instead. No alternatives or exclusions are provided.

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 provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds valuable context: cost ($0.001 per call via x402) and the specific SEO checks performed. No contradiction with annotations.

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

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

Description is fairly concise, listing elements in a structured manner. Could be slightly improved by breaking into bullet points, but no wasted sentences.

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

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

Given the tool's complexity (many checks), annotations, and output schema existence, the description is sufficiently complete. It covers all key aspects without being verbose.

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

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

Schema coverage is 100% for one parameter (url). Description adds context about what the audit checks, but parameter semantics are already clear from 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?

Description clearly states it's a 'Head/meta SEO audit' listing all checked elements (title, description, robots, canonical, etc.). Specific verb+resource distinguishes from siblings like get_seo_alt_check or get_seo_full_audit.

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

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

No explicit guidance on when to use vs alternatives. Implies 'on-page fundamentals in one call' but doesn't compare to sibling tools like get_seo_metadata or get_seo_full_audit.

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 provide a safety profile (readOnly, openWorld, idempotent, not destructive). The description adds value by disclosing cost ($0.001 per call) and the specific analysis performed, complementing the annotations without contradiction.

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 long, front-loaded with the tool's purpose, and every sentence adds value. No 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?

Given the tool's simplicity (one parameter, output schema exists, annotations rich), the description sufficiently explains what it does, its scope (one page), and cost. No 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?

Schema coverage is 100% for the single parameter 'url', and the description's mention of '?url=' adds no new semantic meaning beyond the schema's description. 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 it is an 'Internal-link analyzer for one page' and lists specific metrics (internal vs external counts, nofollow usage, etc.), distinguishing it from sibling tools like get_seo_full_audit or get_seo_site_audit.

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

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

The description implies use for analyzing links on a single page but does not explicitly state when to use this tool versus alternatives or when not to use it.

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, openWorldHint, idempotentHint, destructiveHint false. Description adds that it returns parsed JSON-LD, all meta tags grouped by family, every link relation. No contradictions, adds valuable behavioral detail.

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?

Two sentences: first explains what it does (comprehensive list of returned data), second gives usage context and pricing. No wasted words, front-loaded with purpose.

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 presence of output schema, single parameter, and annotations, description covers purpose, usage, behavior, and cost. Includes payment method which is important for tool selection.

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 'url' with schema description. Description adds that URL must be public and mentions cost per call. Schema coverage is 100%, so description adds marginal but useful context.

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?

Description clearly states 'raw metadata extractor' and lists specific items (title, charset, lang, canonical, all meta tags grouped by family, link relations, JSON-LD). Distinguishes from sibling 'head-check audits' by contrasting its unopinionated dump vs. analysis.

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

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

Explicitly says 'For agents doing their own processing' and contrasts with 'head-check audits' as alternative. Also mentions cost ($0.001 per call, paid via x402), giving clear context for when to use.

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?

Adds behavioral context beyond annotations: mentions it reads server-rendered HTML, flags JS-rendered menus, and includes cost information. No contradiction with annotations (all safe read-only hints).

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

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

Single paragraph with logical flow: primary function, methodology, grouping, use case, technical note. Efficient but slightly verbose in enumerating patterns; could be tightened without loss.

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 simple parameter set (1 required) and presence of output schema, description thoroughly covers purpose, method, grouping, limitations (JS rendering), and cost. No gaps for an agent to use this tool correctly.

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

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

Schema already covers the single parameter 'url' with clear description. Description adds marginal value (cost mention) but baseline 3 is appropriate given 100% 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?

Description uses specific verb 'pulls' and identifies resource 'navigation links' rather than all links. Clearly distinguishes from siblings like get_seo_links by stating 'not every link' and describing scoring of semantic regions.

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?

States intended use case: 'For agents mapping site structure or planning which pages to fetch.' Implicitly excludes full link extraction by emphasizing navigation links. Does not explicitly name alternatives but context with siblings provides sufficient 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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, which the description confirms by framing as a 'checker'. The description adds specific behavioral details: what it examines (robots.txt, llms.txt), what verifies (access for multiple bots), and extra outputs (sitemaps, syntax warnings, structure summary). No contradictions.

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 with the main purpose clearly in the first sentence. The second sentence adds detail and pricing without being overly verbose. Could be slightly more streamlined, but no unnecessary words.

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 low parameter count and existence of an output schema, the description covers the key aspects: what the tool checks (robots.txt, llms.txt), for which bots, and additional outputs (sitemaps, syntax warnings, structure summary). It is complete enough for an agent to understand the tool's full capability.

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 parameter 'url' is described as 'Domain or any page on it', which expands the schema's simple description. The description adds practical usage context ('?url=any page on the site') and pricing per call, providing value beyond the schema's basic type definition.

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 robots.txt and llms.txt for crawler access verdicts, sitemaps, syntax warnings, and structure summaries. It specifically names many bots (Googlebot, Bingbot, GPTBot, etc.), making the purpose very concrete and distinguishing it from other SEO-related sibling tools like get_seo_alt_check or get_seo_full_audit.

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

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

The description implies usage for checking crawler access and AI bot restrictions for any page on a domain. It includes pricing context ($0.001 per call) which guides cost-aware usage. However, it does not explicitly exclude alternatives or provide when-not-to-use guidance, though the purpose is clear enough.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by explaining the crawling of internal links and the audit process, as well as cost. No contradictions.

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 with three sentences, front-loading the main purpose. It efficiently covers scope, deliverables, and cost without unnecessary fluff.

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 complexity, presence of output schema, and annotations, the description covers the essential aspects: audit components, page discovery, scoring output, and cost. Could be slightly improved by noting rate limits or response format, but is largely 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?

Input schema has 100% description coverage, providing baseline clarity. The description adds context about the purpose of parameters (e.g., pages limited to 8, url as start point, level as WCAG), but does not significantly extend beyond schema details.

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 it performs a site-wide on-page audit covering 7 aspects across up to 8 pages, discovering pages from internal links and returning per-page and site-level scores. This distinguishes it from sibling tools that focus on single-page or specific 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?

The description implies use for whole-site analysis but does not explicitly contrast with single-page audits or specific check tools. It provides clear context for when to use it, but lacks exclusion criteria or alternative recommendations.

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 adds significant behavioral context beyond annotations: methods of finding sitemaps (direct URL, robots.txt, /sitemap.xml), handling of indices, validation of lastmod dates, cross-host URLs, oversize files, and health checks. It also discloses costing ($0.001 per call). No contradiction with annotations.

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

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

The description is a single sentence that packs extensive detail without excessive verbosity. It front-loads the main action ('Sitemap validator') and then lists features. Slightly long but efficient.

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

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

Given the tool's moderate complexity and the existence of an output schema, the description fully covers the tool's behavior: how it operates, what it validates, side effects (cost, health check). No gaps for an agent 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?

With 100% schema description coverage, baseline is 3. The description adds value by explaining that the URL can be a site root or direct sitemap URL, which elaborates on the schema's terse description. This clarifies acceptable input formats.

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 as a 'Sitemap validator' and enumerates specific actions: finding sitemaps, validating entries, health-checking URLs. It distinguishes itself from sibling tools like get_seo_robots_check and get_seo_full_audit by focusing exclusively on sitemap validation.

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

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

The description implies usage when sitemap validation is needed but does not explicitly contrast with alternatives or state when not to use it. However, the context from sibling tool names and the clear verb 'validator' provides sufficient 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 provide readOnlyHint, idempotentHint, destructiveHint. Description adds cost information ($0.001 per call via x402) and quota details, providing extra behavioral context.

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?

Single sentence conveying all key information efficiently and front-loaded.

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

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

Description explains return fields and quota, making it complete for a zero-parameter tool with output schema.

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

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

No parameters, so baseline 4 applies. Description adds no parameter info, but it's unnecessary as there are none.

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?

Description clearly states the tool lists all collections in the wallet with specific fields (names, row counts, created dates, total rows, storage bytes) and mentions quota and cost. It distinguishes from sibling get_store_collection which likely returns a single collection.

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?

Description indicates this is for listing all wallet collections, and mentions cost. Implicitly differentiates from get_store_collection, but lacks explicit when-not or alternative 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?

The description discloses significant behavioral traits beyond annotations: reads extend expiry by 30 days (writes give 60), the cost model ($0.001 per call, paid via x402), and output format options. These are not covered by readOnlyHint, openWorldHint, idempotentHint, or destructiveHint.

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

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

The description is well-structured with a clear purpose first, then details about pagination, filtering, expiry, and cost. It is slightly verbose but every sentence adds useful information, earning a score above average.

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 6 parameters with full schema descriptions and an output schema, the description sufficiently covers behavioral context, cost, and usage nuance. No gaps are apparent.

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 baseline is 3. The description adds value by explaining the 'since' parameter as 'what's new since my last poll' and clarifying that the collection is owned by the wallet, which goes beyond the schema descriptions.

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

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

The description clearly states the verb ('read back') and the resource ('rows from the named collection owned by your paying wallet'). It distinguishes from sibling tools like post_store_collection (write) and delete_store_collection (delete) by focusing on retrieval.

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

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

The description implies use for retrieving stored data with pagination and filtering. It does not explicitly state when not to use or name alternatives, but the context of sibling tools and the phrase 'read back rows your wallet stored' provides clear 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?

Adds significant behavioral context beyond annotations: quick, deterministic, no AI, cost ($0.002 per call), and that it returns key sentences not full text. No contradictions with annotations.

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

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

Three sentences, front-loaded with action and purpose, no redundancy. 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?

Given output schema exists and only two simple parameters, the description covers use case, algorithm, cost, and limitations adequately.

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 both parameters (100% coverage). Description adds default for 'sentences' (3) and mentions the algorithm, but schema already provides parameter descriptions.

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

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

The description clearly states the tool performs 'extractive summary' of web pages using TextRank, distinguishing it from siblings like get_scrape or get_extract.

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 advises using it when an agent wants 'the gist of a page, not a full scrape', implying alternatives. It lacks explicit when-not-to-use or prerequisites but provides clear context.

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

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

Annotations already declare read-only and idempotent; description adds behavioral traits like fast offline lookup, approximate near borders, and pricing cost ($0.001 per call), which are useful beyond annotations. No contradiction.

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?

Single sentence with essential information, though packed with multiple details. Concise but could be slightly more structured; still effective.

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 simple parameters, comprehensive annotations, and presence of output schema, the description covers key aspects: output fields, approximation, pairing suggestion, and pricing. Lacks explicit return format details but output schema likely covers that.

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 good parameter descriptions for lat and lng. The tool description does not add additional semantics beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves timezone information from GPS coordinates, listing specific outputs (IANA zone, UTC offset, DST status). It distinguishes from siblings as no other timezone tool exists among siblings.

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 mentions pairing with IP-geolocation endpoint for analytics and scheduling, providing context for use. It also notes approximate near borders, but lacks explicit when-not or alternative tools, so not perfect.

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

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

Beyond annotations (readOnly, idempotent), the description details the request behavior (HEAD with GET fallback, redirect following with safety checks), determinism, and cost. No contradiction with annotations.

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

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

Reasonably concise with key details front-loaded. The cost line could be extraneous but is helpful for decision-making.

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 single parameter and existing output schema, the description provides sufficient context about return values and behavior, making it complete 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 already provides full description for the only parameter 'url'. The description adds no new semantics beyond what is in the schema, but confirms the public nature.

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 it's an uptime/health probe for any public URL, specifying the HTTP method and return data. It distinguishes itself from sibling tools by focusing on deterministic monitoring probes.

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 it's for monitoring on a schedule, implying regular health checks. While it doesn't explicitly mention when not to use or alternatives, the context of sibling tools for other checks makes it 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?

Annotations declare readOnlyHint=true, idempotentHint=true, etc. Description adds context: uses socket-level HEAD probe, measures specific phases, says exactly which phase died on failure, no page download, costs $0.01. No contradictions with annotations.

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

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

Description is a single dense paragraph covering many aspects succinctly. No wasted words, but could be structured with bullet points for easier scanning. Still very efficient.

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 a single parameter, existing output schema, and comprehensive annotations, the description covers the probe methodology, failure behavior, and cost effectively. Completes the picture for an agent to decide whether to invoke.

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 100% with a single parameter 'url' described as 'Public http(s) URL to probe'. The description does not add further semantics about the parameter itself (e.g., formats, examples). 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?

Description uses specific verb 'get' with resource 'uptime report' and lists numerous specific metrics (DNS/TCP/TLS/TTFB waterfall, TLS certificate, HTTP/2, server IP, CDN, redirect, headers, compression, clock skew). It clearly distinguishes from siblings like get_scrape or get_ping by emphasizing a single deterministic HEAD probe with no page download.

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?

States it is for 'everything a monitor needs in one deterministic call' and mentions the cost, implying use for quick health checks. Does not explicitly list alternatives or when not to use, but sibling tools provide context. Could be more explicit, but adequate.

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 aligns with annotations: it is a passive, read-only check. It adds important details like returning a 0-100 score and prioritizing remediation. No contradiction with annotations.

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

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

The description is a single paragraph but packs essential information efficiently. It is front-loaded with the main purpose and has no redundant sentences.

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 output schema exists and the tool has a single parameter, the description comprehensively covers the return format (0-100 score, remediation) and the checks performed, making it complete 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 input schema has full coverage for the 'url' parameter. The description adds minimal extra context ('homepage') beyond the schema. Baseline score 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 performs a passive WordPress security posture assessment, listing specific checks like version disclosure and xmlrpc.php exposure. It distinguishes itself from sibling tools (e.g., get_dns, get_a11y_check) by focusing on WordPress security.

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 specifies the tool is for site owners and authorized auditors, and notes it flags security practices not vulnerabilities. While it does not explicitly state when not to use, the alternatives are implied by the distinct purpose 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?

Annotations (readOnlyHint=false, destructiveHint=false) indicate write and non-destructive behavior. Description adds cost ($0.001 per call via x402), body structure, and optional agent handle. No contradictions.

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?

Two sentences, front-loaded with purpose, then details. No waste, every part 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?

Given output schema exists (not shown but indicated), description covers purpose, input format, cost, and safety. Lacks mention of return value or idempotency, but sufficient for a simple post 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%, and description adds meaning: explains the five types (feature, critique, etc.), text limit (280 chars), and that agent is optional. This goes beyond schema descriptions.

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

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

The description clearly states it posts a message to a Machine Message Board, specifying the body format (type, text, agent). It distinguishes from sibling tools like get_board (read) and post_board_intro/post_board_sticky (specific variants).

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

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

The phrase 'your two cents for other agents' implies when to use (to communicate with agents). Sibling tool names provide context for alternatives, but explicit when-not-to-use is missing.

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

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

Discloses that the tool is free for one intro per caller address, and that subsequent posts require payment and create a durable identity. This adds behavioral context beyond annotations, which only indicate readOnlyHint=false.

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?

Two sentences, front-loaded with purpose, no redundancy. Every sentence adds essential information without waste.

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

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

Given the tool's simplicity and the presence of an output schema, the description covers purpose, usage, constraints, and behavioral notes comprehensively for an introductory 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%, so schema already documents parameters. Description reiterates types and character limit, and adds the constraint 'per caller address' which is not in schema, enhancing clarity.

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?

Description clearly states the verb 'Post', resource 'introduction to the Machine Message Board', and key constraints (free, one per caller, no payment). It distinguishes from siblings like post_board (paid) and post_board_sticky.

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 when to use: for the first free intro. Mentions that after the intro, posting incurs a cost and directs to using POST /api/board (which corresponds to sibling post_board). Provides clear context and alternative.

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

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

Beyond annotations (readOnlyHint false, destructiveHint false), the description adds key behavioral traits: the message is pinned for 7 days and costs $0.003 per call. This provides valuable operational context that helps the agent understand side effects and constraints.

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 long, front-loads the core purpose ('Post a PINNED message'), and includes essential details (7-day retention, cost) without redundancy. Every word 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?

Given the tool's simplicity and that an output schema exists, the description sufficiently covers behavior, parameters, and cost. No critical information is missing for an agent to use the tool correctly.

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

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

The input schema already describes all three parameters (text, type, agent) with 100% coverage. The description only confirms the structure ('Same body as /api/board') without adding new semantic details, so it meets but does not exceed the baseline.

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

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

The description clearly states the tool posts a 'PINNED' message to the Machine Message Board, which stays at the top for 7 days. This specific verb and resource, along with the unique pinning behavior, effectively distinguishes it from sibling tools like post_board and post_board_intro.

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

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

The description implies use for high-visibility messages ('stays at the top... so every agent sees it first'). However, it does not explicitly state when not to use it or mention alternatives (e.g., post_board for regular messages). The guidance is clear but not exhaustive.

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 details outputs (SVG, PNG, palette with WCAG check), pricing, and coherence. Annotations are minimal (readOnlyHint=false), but the description fully discloses the tool's behavior and what it produces.

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 informative and front-loaded with the core purpose. It includes some detailed pricing and comparison text that could be streamlined, but overall it is efficient.

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 10 parameters and an output schema, the description covers inputs, outputs, and constraints adequately. The output schema handles return values, so the description is sufficiently 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?

All parameters have schema descriptions (100% coverage). The tool description adds context by explaining the relationship between 'query' and 'icon' parameters and summarizing required inputs, enhancing understanding 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 it bundles a complete brand kit including logo, icon, social card, and color palette. It distinguishes from individual tools like post_logo_generate and post_og_card by emphasizing the kit's coherence and added value.

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

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

The description implies use when a full brand identity is needed and compares to individual pieces. However, it does not explicitly state when to use alternatives like post_logo_generate for a single logo.

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 provide readOnlyHint=false and openWorldHint=true. The description adds context about exactness, BigInt usage, and pricing, but does not mention side effects, auth requirements, or rate limits. It is helpful but not fully transparent about behavioral traits.

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 dense paragraph that front-loads the core purpose and lists operations with brief explanations. Every sentence adds value, including pricing and precision claims. No wasted words.

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 10 parameters and financial/token complexity, the description covers key operations and error sources (float64 corruption). It does not explain prerequisites or output format, but output schema covers return values. Adequate for an agent with schema access.

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 70%, already documenting many parameters. The description adds value by explaining the exact nature of computations (BigInt, iterative series) and providing examples for token_units (ETH 18, USDC 6). This enriches understanding beyond schema descriptions.

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

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

The description clearly states 'Exact financial + token math' and lists specific operations (compound, amortize, npv, irr, token_units). It distinguishes from sibling post_calc_stats by focusing on financial and token calculations, providing a specific verb+resource pairing.

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

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

The description implies use for exact financial calculations and token unit conversions, and mentions that float64 is insufficient for token math. However, it does not explicitly state when not to use this tool or provide alternatives beyond the sibling list.

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

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

The description discloses important behavioral traits beyond annotations: Kahan summation for numerical accuracy, 100k value limit, cost per call, payment via x402, and that reading the datastore extends its life by 30 days. Annotations indicate readOnlyHint=false (consistent with POST), destructiveHint=false, and idempotentHint=false. No contradictions with annotations.

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

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

The description is front-loaded with the core purpose and efficiently covers multiple usage modes using compact syntax examples. It is relatively dense but each sentence serves a purpose; however, it could be slightly more concise by reducing redundancy in explaining the datastore option.

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

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

Given the tool's complexity (multiple modes, output schema, cost, constraints), the description provides sufficient context for an agent to select and invoke it correctly. It covers input formats, limits, behavioral notes, and payment, though it does not explicitly describe the output structure (but an output schema exists).

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

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

The description adds significant meaning to the parameters by explaining the different modes (values for simple stats, x/y for correlation, rows/field for object arrays, collection for datastore). While schema coverage of parameters is 67%, the description compensates with clear usage examples and contextualizes each parameter's role.

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: 'Exact descriptive statistics' with specific use cases like counting, summing, mean, median, stddev, percentiles, Pearson correlation, linear regression, and datastore aggregation. It distinguishes itself from sibling tools by emphasizing its exact calculation capability and multiple input modes.

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

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

The description provides clear guidance on when to use the tool: for exact statistics when LLMs might be inaccurate. It explains multiple usage modes (direct arrays, correlation, object arrays, datastore) and mentions cost and payment method. However, it does not explicitly state when not to use it or compare to specific sibling tools.

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 (readOnlyHint=false, idempotentHint=false) are consistent. The description adds cost ($0.01 per call, x402) and output format (SVG source + PNG base64), which are beyond annotations. No contradictions.

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 paragraph but efficiently structured: main purpose, then options. Every sentence adds value; no fluff. It is appropriately sized for the complexity.

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

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

Given 8 optional parameters, an output schema, and no required fields, the description covers all relevant aspects: purpose, parameter options, output, and cost. It is complete without needing to explain return values due to output schema.

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

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

Schema coverage is 100%, so baseline 3. The description adds meaning by explaining each parameter's role and defaults in natural language (e.g., '2 makes a diagonal gradient', 'skips search'). This provides value beyond the schema descriptions.

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

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

The description clearly states it generates an app-icon-ready asset from a Font Awesome icon with background colors, SVG+PNG output. It distinguishes from siblings like get_icon_search (search only) and post_logo_generate (logo generation) by specifying the asset type.

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 when to use (app icon generation) and mentions search vs exact name. It does not explicitly state when not to use or compare to alternatives, but siblings are differentiated by context. The note 'Returns alternatives when resolved via search' provides guidance.

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