webbersites-x402-data-api

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

The description says 'delete' which is destructive, but annotations have destructiveHint=false, creating a contradiction. This is a serious inconsistency.

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 concise sentences, first states purpose, second adds usage and cost. 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?

Covers purpose, cost, quota. However, the contradiction with annotations reduces completeness. An output schema exists but the description doesn't need to explain return values.

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%, baseline 3. The description adds clarity with 'Pad name in the URL path' for the name parameter, providing 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?

The description states 'Delete one of your wallet's scratchpads' which is a clear verb+resource. It is distinct from sibling tools by the verb 'delete', though it does not explicitly differentiate.

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 'clean up after yourself and stay under the 50-pad quota' which implies when to use it, but no explicit alternatives or when-not-to-use 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 states the tool drops a collection and all its rows, which is destructive, but the annotation destructiveHint=false indicates the tool is not destructive. This is a clear contradiction, leading to a score of 1.

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 core purpose. Every word is meaningful, with no redundancy or wasted space.

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

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

The tool has one parameter and an output schema (not shown). The description provides cost and usage context. However, the contradiction between description and annotations undermines completeness. It adequately covers the tool's purpose but fails to align with behavioral signals.

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% description coverage for the single parameter 'collection'. The description in the schema is sufficient ('Collection name in the URL path'), and the tool description does not add additional semantic meaning beyond that.

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

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

The description clearly states the verb 'drop' and the resource 'collections in your wallet's datastore'. It distinguishes from siblings like get_store_collection and post_store_collection, as there is no other delete tool for store collections.

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 for when to use the tool: 'clean up after yourself and stay under quota'. It mentions the cost, implying use for cleanup tasks, but does not explicitly state when not to use it or name alternatives. However, no alternative delete tool exists 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?

Discloses static analysis nature, limitations (contrast, focus, keyboard), and pricing ($0.01 per call) beyond annotations which already indicate readonly and idempotent.

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?

Concise and efficient; main purpose front-loaded, list of checks in compact form, 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 complexity and presence of output schema, description adequately covers scope, limitations, filtering, and pricing.

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 mentions filtering by level, but schema already covers both parameters with clear descriptions; schema coverage is 100%, so minimal added value.

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 WCAG accessibility check for static analysis, listing specific checks (alt text, page title, etc.) and distinguishing from siblings like get_a11y_contrast.

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 (WCAG compliance) and filtering by level, but no explicit when-not or alternatives; however, sibling tools cover contrast, so implication 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?

Adds details beyond annotations: returns exact ratio, AA/AAA pass/fail for different text sizes and UI components, plus plain-English verdict, and cost. 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?

Concise (three sentences), front-loaded with purpose, but wording 'the check the URL-based a11y endpoint can't do' is slightly awkward. Still efficient and informative.

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?

Describes outputs sufficiently (ratio, pass/fail, verdict) and mentions cost. Does not cover error handling or color validation, but for a simple tool with output schema, it is adequate.

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 coverage, baseline is 3. The description clarifies which parameter is foreground vs background and suggests hex/rgb format, adding minimal value beyond the schema.

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

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

The description clearly states it computes WCAG contrast ratios, specifies the inputs (foreground and background colors), and explicitly differentiates itself from the URL-based a11y endpoint (likely get_a11y_check), which distinguishes it from 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?

It explains when to use (for color contrast, not URL-based check), gives input format guidance, and mentions cost. It does not explicitly state when not to use, but the differentiation is sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false. The description adds 'Deterministic, no network' and notes paid pricing, which are useful beyond annotations. It does not contradict any annotation.

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: the first states purpose and output, the second lists types and behavioral notes, the third clarifies QR separation and pricing. Front-loaded and 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 complexity (7 params, output schema exists), the description covers purpose, output format, supported types, validation behavior, and pricing. It omits parameter usage details, but schema covers those. Adequate for selection and 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% with each parameter described. The description summarizes the query pattern and lists types, but does not add significant detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool is a barcode generator for product, shipping, and inventory labels, with specific verb 'generate' and resource 'barcode'. It lists supported symbologies and distinguishes from QR codes via 'QR codes live at /api/qr', differentiating it from sibling get_qr.

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 (labels, shipping, inventory) and implies not to use for QR codes, but does not explicitly state when to avoid using this tool or mention alternatives like get_qr directly. It does note pricing, which is a condition for 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context: the board is public, shows newest first with pinned posts, and includes filter and pricing info. 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 single paragraph (~80 words), efficient, and front-loaded with the purpose. Each sentence adds value, though it could be slightly more 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 simplicity (2 optional params, no required), full annotations covering safety, and existing output schema, the description is complete. It explains the board's nature, ordering, filtering, 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%, so the schema already documents type and limit. The description mentions filtering but does not add significant meaning beyond the schema descriptions. 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 verb 'Read' and the resource 'Agent Helpdesk — a public machine message board', specifying the content (feature requests, critiques, etc.). It distinguishes from sibling post tools implicitly by focusing on reading.

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 the tool (to read the board) and provides filtering options (type, limit) and ordering (newest first, pinned on top). It mentions cost, but does not explicitly state when not to use or contrast with 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 cover readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable details: 50-significant-digit precision (BigNumber), deterministic behavior, no AI or code execution, cost per call ($0.001 per x402), and that the result is an exact string. 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?

The description is four sentences, each adding significant value. It starts with a clear, engaging hook ('Exact math for agents'), then lists capabilities, usage example, and key traits. No extraneous 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 has one parameter, a clear schema, and an output schema (implied by 'result returned as an exact string'), the description fully covers what an agent needs: purpose, capabilities, precision, constraints, pricing, and deterministic nature. 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?

The input schema has 100% coverage with a description. The description reinforces the format with examples and adds the constraint of max 400 characters. This goes slightly beyond the schema, earning a 4.

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 that the tool performs exact math, and lists specific operations (multiplication, division, roots, logs, etc.) and the use case (arithmetic LLMs get wrong). It differentiates itself from sibling math tools (like get_calc_dates, get_convert) by focusing on high-precision arithmetic.

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: for arithmetic that LLMs are likely to get wrong. It doesn't explicitly exclude alternatives, but the context (50-digit precision, deterministic, no AI) strongly suggests using it for high-stakes math. A brief note on when not to use it would improve clarity.

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 the tool is read-only, idempotent, and non-destructive. The description adds valuable behavioral context: all dates are UTC, business days are Mon-Fri, invalid dates like Feb 30 are rejected, and there is a $0.001 cost 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?

The description is dense but efficient, using concise examples (e.g., ?from=&to= ) to convey multiple use cases in a compact format. Every sentence adds unique information, with no filler.

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

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

Given the tool has an output schema and the description covers all input combinations and behaviors (including edge cases and cost), the description is fully sufficient for an AI 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?

The schema covers 3 of 4 parameters with descriptions (75% coverage). The tool description greatly enhances understanding by showing exact result types for each parameter combination (e.g., from+to yields days, business days, weeks, hours; date+add yields resulting date; date alone yields weekday, ISO week, etc.). This adds significant semantic value beyond the schema.

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

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

The description clearly states the tool performs exact date arithmetic, listing specific use cases: date differences, date addition/subtraction, and single-date info. This distinguishes it from other tools in the sibling list, none of which focus on date calculations.

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

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

The description provides explicit usage patterns via query examples (from+to, date+add, date alone), making it clear when to use each combination. It does not explicitly mention when not to use the tool or alternatives, but given its unique functionality, the guidance is effective.

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 behavioral traits beyond annotations: caching duration (≤30s), cost per call, and that it returns rate, converted amount, and underlying prices. Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, and description aligns perfectly without 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 plus a note on caching and cost. Every sentence earns its place, providing purpose, example, accepted formats, return payload overview, and performance characteristics. No extraneous 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?

With output schema present, description covers all essential aspects: what the tool does (conversion), how to use it (example), accepted input formats, return values (rate, converted amount, prices), and operational details (caching, cost). Complete for a simple conversion 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 baseline is 3. Description adds value with example (amount=0.5&from=bitcoin&to=ethereum) and clarifies that from/to accept CoinGecko ids, tickers, or fiat codes. This goes beyond the bare schema descriptions and helps agents understand acceptable inputs.

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

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

Description clearly states it performs live crypto conversion between any coin/fiat at CoinGecko prices. Includes specific example and mentions common tickers. Distinguishes from sibling get_price_coin by explicitly covering fiat-to-coin and coin-to-fiat, and by noting it returns rate and converted amount, not just 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?

Provides clear context: prices cached ≤30s, cheap enough to call in a loop, and cost per call ($0.001). Implies frequent use is acceptable. Does not give explicit when-not-to-use or alternative tools, but the guidance 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?

Annotations already declare readOnly, idempotent, non-destructive. Description adds details on which records are returned and cost, but doesn't mention any potential rate limits or side effects. Adds useful 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 plus a brief cost example. Front-loaded with most important information (record types). Every sentence serves a purpose 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 output schema exists, return values are covered. Description fully explains what records are returned, use case, and cost. Completely adequate for a simple 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 covers the single parameter 'domain' with description. Description reinforces with an example ('?domain=example.com') but doesn't add new meaning beyond what schema provides. Schema coverage is 100%.

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 specifies exact record types (A/AAAA/CNAME, MX, NS, TXT, SOA, SPF, DMARC, DKIM) making it clear what the tool does. This distinguishes it from sibling tools like get_ping or get_seo_* which serve different purposes.

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 the tool is for 'deliverability, security, and research agents,' providing context. Does not mention when not to use it, but given its narrow focus, alternatives are implied by other 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 already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavioral details such as the list of checks performed and pricing ($0.002 per call), which enrich understanding 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 highly concise, using one sentence with a comma-separated list. It front-loads the purpose and packs essential detail 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?

For a single-parameter tool with clear purpose and available output schema, the description covers all necessary aspects: what it does, what checks it performs, pricing, and self-contained nature. It is 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 a clear parameter description. The description does not add extra semantics for the 'email' parameter beyond what the schema provides, so the baseline 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 performs email verification with specific checks (syntax, MX, disposable domain, etc.). It uses a specific verb ('get email verify') and resource, and distinguishes from many sibling tools that serve different purposes.

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 indicates the tool is intended 'for outreach and CRM agents', providing clear context. It does not explicitly mention when not to use or alternatives, but the use case is clearly implied.

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 nature. The description adds valuable behavioral context: cost ($0.02 per call via x402), handling of scanned PDFs requiring OCR, and the type of output (Markdown per page with metadata for PDF, real Markdown for DOCX, typed columns and rows for CSV). 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 coherent paragraph that front-loads the purpose, then details per format, and ends with usage hint and cost. Every sentence adds value, no 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 that an output schema exists, the description does not need to detail return values. It covers all necessary context: input formats, output structure, error flags (scanned PDFs), cost, and usage scenario. It is fully complete for an agent to use 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 descriptions for all parameters. The description adds meaning beyond schema by specifying default and max for max_rows (1000/5000), and clarifying auto-detect logic for type. This extra detail aids usage, raising it above baseline 3.

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

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

The description clearly states the tool extracts documents and returns Markdown plus structured JSON, with specific formats (PDF, DOCX, CSV) and mention of OCR for scanned PDFs. It distinguishes from sibling tools like get_scrape by focusing on document contents rather than bytes.

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

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

The description includes 'For agents that need document contents, not bytes' which gives context on when to use this tool. However, it lacks explicit exclusions or alternatives (e.g., post_extract_custom) to guide 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 readOnly, openWorld, idempotent, and non-destructive. The description adds performance characteristics ('Fast in-memory lookup'), cost ($0.001 per call), and the optional behavior of omitting the ip parameter to geolocate the caller, providing useful 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. The first sentence immediately defines the core purpose, and the second adds valuable context (use cases and pricing). Extremely 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?

With low complexity, existing output schema, and comprehensive annotations, the description covers use cases, optional behavior, and cost. It lacks mention of rate limits or error handling, but these are minor for a simple 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 for the single 'ip' parameter. The description adds the default behavior ('Omit to geolocate the caller'), adding meaning beyond the schema description.

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

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

The description clearly states the tool performs IP geolocation, listing specific data fields (country, region, city, coordinates, timezone) and supporting both IPv4 and IPv6. It distinguishes itself from sibling 'get_*' tools by its unique 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 mentions use cases (analytics, fraud, personalization agents) and pricing, giving implicit guidance on when to use. However, it does not explicitly state when not to use or name alternative 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 already declare readOnlyHint=true and destructiveHint=false, so the description adds value by mentioning the cost ($0.002 per call), ranking behavior, and that results include icon names and styles. 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 concise sentences. The first explains the action, the second describes the output, and the third provides follow-up and cost. 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 (search with keyword and optional filter), the description covers the search behavior, output fields, and next step. The presence of an output schema means return values don't need elaboration, and the description appropriately complements it.

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 explaining that matching is against names, labels, and official search terms (beyond the schema examples) and that available styles are returned. This enriches the 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 it searches Font Awesome Free icons by keyword, with specific details on matching names, labels, and official search terms. It distinguishes itself from sibling tools by mentioning the subsequent POST /api/icon/generate usage, which is unique among the many get_* tools.

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

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

The description provides clear context for use: search by keyword and optionally filter by style, then use the result in another endpoint. It does not explicitly exclude scenarios or list alternatives, but the context is sufficient for typical use cases.

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, so the agent knows this is a safe read operation. The description adds important behavioral info: the cost ($0.01 per call, paid via x402) and that it returns 'canonical album data'. No contradictions noted.

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: first defines purpose and search methods, second lists returned data, third gives target users and cost. It is front-loaded with the core purpose and avoids unnecessary words. Every sentence 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 moderate complexity (5 optional parameters, output schema exists), the description covers search methods, data returned, target users, and cost. It does not explain error handling or empty results, but with annotations covering read-only and idempotent behavior, and an output schema for structure, this is sufficient for a 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?

The schema has 100% coverage with descriptions for all 5 parameters, so the baseline is 3. The description adds value by explaining the relationship between parameters (e.g., artist+title, or free-text q, or id with optional kind) and that id lookups can specify 'master' or 'release'. This provides useful grouping and usage 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?

The description clearly states 'Album metadata lookup via the Discogs database' and specifies three search methods (artist+title, free-text q, Discogs id). It distinguishes from the sibling tool 'get_music_cover' which is focused solely on cover art, as this tool returns full album data including a cover-art URL.

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

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

The description identifies target users as 'for music, playlist, and cataloging agents', providing clear context for when to use the tool. It does not explicitly state when not to use or list alternatives, but the sibling tools are largely unrelated except for get_music_cover, which is a different function.

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 readOnly, idempotent, not destructive. Description adds return format (base64 + data URI with dimensions, content type) and cost, which are useful 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, front-loaded with purpose and selectors, concise with no wasted words. Includes critical details like output format and cost efficiently.

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 annotations are rich, description fully explains tool purpose, parameter usage (via selector patterns), return value format, and cost. No gaps identified.

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% (baseline 3). Description adds grouping of selectors (artist+title, q, or id) and mentions kind defaults, enhancing understanding of parameter usage.

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

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

Description clearly states it returns album cover art via Discogs with specific output format. It mentions selectors and pairs with get_music_album, but does not explicitly differentiate from siblings beyond that.

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?

Implies usage context by stating same selectors as /api/music/album and that it pairs with that endpoint, but lacks explicit when-to-use vs alternatives or 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 read-only and idempotent behavior. The description adds valuable context: the tool costs $0.001 per call (paid via x402), and it verifies image loads and raster format. There is 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, front-loaded with the core functionality, and efficient. Every sentence adds value: the first details what the tool does, the second specifies use cases and pricing.

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 indicated as present), the description does not need to explain return values. It covers the essential behavioral and contextual aspects for a single-parameter tool, making it complete for agent use.

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

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

There is only one parameter (url), and the schema includes a description ('Public URL of the page to check'). The tool description adds no additional parameter details beyond what the schema provides. Since schema coverage is 100%, a 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 specifies the tool checks OpenGraph and Twitter meta tags, verifies og:image loading and format, and returns a verdict. It explicitly targets publishing and SEO agents, and the tool name 'get_og_check' distinctively sets it apart from sibling SEO tools like 'get_seo_head_check' or 'get_seo_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?

The description mentions the tool is 'for publishing and SEO agents shipping pages that get shared', providing a clear use case. It does not explicitly state when not to use it or name alternatives, but the context of siblings makes the differentiation obvious.

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 readOnly, idempotent, openWorld, and non-destructive. The description adds significant behavioral traits: deterministic, no keys required, ~1.5s cache, per-call cost ($0.05 via x402), and auto-fallback mechanism. This goes well 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 a single, well-structured paragraph that front-loads the purpose, then lists key features, behavioral properties, and an example. Every sentence adds value, and there is no redundancy or 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 low complexity (3 parameters, simple output), the description covers all essential aspects: purpose, return values (bids/asks, mid, spread, liquidity, slippage), caching, cost, auth, and source behavior. The output schema exists, so return value details are not required.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds further meaning by explaining the source auto-fallback, normalizing across exchanges, and providing an example usage string. It clarifies the depth range (1-200) and default (50) implicitly.

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 L2 order-book depth for crypto pairs, including bid/ask ladder and analytics. It specifies the verb 'get' and the resource 'orderbook', distinguishing it from sibling tools that perform other data retrieval or actions.

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: it's for crypto pairs, normalizes across exchanges, and offers auto-fallback or specific source selection. It does not explicitly state when not to use it or mention alternatives, but the context is sufficient for appropriate selection among 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?

Beyond the idempotent, read-only, and open-world annotations, the description reveals that any HTTP response below 500 is considered up, and redirects are reported but not followed. 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 front-loaded with the core purpose and returns, followed by behavioral details, sibling guidance, and cost. Slightly verbose due to the cost note, but well-organized and informative.

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, clear annotations, and an output schema), the description fully covers what the tool does, what it returns, its behavior, and when to use it. Cost note adds extra context.

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

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

The single parameter 'url' is already well-described in the schema (100% coverage). The description adds little new information beyond the schema, but confirms it expects a public HTTP(S) URL. 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 identifies it as a liveness ping tool for any public URL, specifying the return values (up/down, HTTP status, latency) and distinguishing itself from siblings like get_uptime and get_uptime_report.

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

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

Explicitly states when to use this tool (high-frequency monitoring loops) and when to use alternatives (for redirect following, headers, full timing/TLS/CDN reports). Also mentions cost per call.

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 (deterministic, no AI, works even when meta tags stripped, pricing) 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?

Three sentences, each adding value: main question, mechanism, detection scope, and pricing. 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 single parameter, rich annotations, and presence of an output schema, the description is complete, covering purpose, behavior, and practical details.

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 single 'url' parameter described. The description adds example and context ('public http(s) URL') but does not significantly extend schema meaning.

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

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

The description uses a specific verb ('detect') and resource ('website platform'), lists numerous detectable platforms, and clearly distinguishes from siblings like get_wp_assess or get_scrape.

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 states the use case: detecting platform from a single fetch. It lacks explicit 'when not to use' or alternatives, but the context is 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 declare readOnlyHint=true and idempotentHint=true, so the description adds value by specifying the data returned (current price and 24h change) and cost. No contradictions; the description reinforces the read-only nature and adds performance/cost 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?

The description is two short sentences: the first states the core purpose and data, the second adds cost and use case context. Every sentence 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?

For a simple read tool with one parameter, good annotations, and an output schema, the description provides sufficient context: data returned, cost, and use case. It lacks mention of error handling or rate limits, but these are low priority given the tool's simplicity.

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

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

The input schema covers the single parameter 'coin' with a clear description and examples. Schema description coverage is 100%, so the description does not need to add parameter semantics. 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 returns 'Current USD spot price and 24-hour percent change for any crypto asset by CoinGecko id,' which is a specific verb-resource combo. It distinguishes itself from sibling tools like get_report_coin by focusing on a simple price lookup.

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 for when to use this tool: 'cheap, high-volume price lookups for trading and analytics agents' and mentions a cost of $0.001 per call. However, it does not explicitly state when not to use it or compare with alternatives like 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 readOnly, openWorld, idempotent, non-destructive. The description adds value by explaining data source (payment log), pricing model (free per call, paid via x402), and emphasizing shape over scale, which complements 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?

Three sentences, front-loaded with key output elements, no wordiness. 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?

For a zero-parameter read-only tool, the description provides complete information about the return value and pricing. No gaps identified despite not having output schema accessible.

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, so schema coverage is 100%. The description does not need to explain parameters; it fully describes what the tool returns.

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 returns a public traffic pulse with specific components: daily paid-call activity index, most-called endpoints share, and recent-activity ticker. It clearly distinguishes from sibling tools which cover different domains.

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 context by noting it's free and provides a shape-not-scale view, but does not explicitly compare to alternatives or state when not to use. Among many siblings, no similar tool exists, making usage 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 read-only, idempotent, and non-destructive behavior. The description adds valuable details: deterministic, no network/tracking, output format, and cost. This goes beyond the annotations to inform the agent.

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 (single paragraph), front-loads the core purpose, and efficiently lists options and constraints. Every sentence adds value with no 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 tool's complexity (6 params, cost, output format), the description covers all key aspects: what it does, how to use it, parameters, constraints, and side effects. The presence of an output schema reduces the need to describe return values.

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 some extra context (e.g., 'quiet-zone modules', example data types) but largely repeats schema info. Minimal added value beyond the schema.

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

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

The description clearly identifies the tool as a QR code generator with a specific verb ('GET'), resource ('QR code'), and output format ('SVG plus PNG base64 and data URI'). It distinguishes from sibling tools like get_barcode by specifying QR codes.

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 the tool (e.g., encode URLs, wifi, vCards, payment URIs) and provides constraints (max 2,000 chars, cost $0.01). It lacks explicit alternatives but covers context adequately.

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 cost ($0.02 per call via x402) and output nature (written summary), adding value beyond annotations which already indicate read-only, idempotent behavior.

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

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

Single concise sentence with additional cost note. Front-loaded with key details, though lacks bullet points or structured formatting.

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, the description sufficiently covers input, output type, use case, and cost. No missing critical information 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?

Schema fully describes the parameter as a CoinGecko asset id with examples. Description adds 'for one asset' but this is already implicit. Minimal incremental value for the parameter.

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 specifies 'Enriched crypto market report for one asset' and lists concrete data fields (rank, price changes, ATH context, signals, summary), clearly differentiating from sibling get_price_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?

Explicitly states 'For agents needing market context, not just a price' which indicates when to use this tool over alternatives, though it could name the sibling 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 cover readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds the cost per call and clarifies output format (cleaned Markdown with navigation stripped), adding value 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: first describes the core function, second states the use case and cost. No wasted 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 simple tool (single URL input, Markdown output) and presence of an output schema, the description covers purpose, use case, cost, and output format. Missing details like error handling are minor.

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% description coverage for the single 'url' parameter. The tool description does not add specific parameter guidance, but it provides context about the output. Baseline 3 is appropriate as the schema handles parameter semantics.

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 that the tool fetches public web pages and returns clean Markdown with ads/boilerplate stripped. It specifies the use case (article text or documentation) and distinguishes it from other tools in the sibling list.

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

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

The description says 'For agents that need article text or documentation as Markdown,' providing clear context. It does not explicitly list alternatives or when not to use, but the use case is well-defined.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds pricing ($0.001 per call, paid via x402) and the notion of 'cheap' calls, which provides useful behavioral context beyond the 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 two concise sentences. The first sentence immediately states the purpose and output, and the second adds usage context and pricing. No extraneous 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 has no parameters and an output schema exists, the description covers all needed context: what the tool returns and when to use it. The mention of pricing and the 'cheap' nature completes the picture.

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

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

The tool has zero parameters, so the schema fully covers the input. Baseline score is 4 as the description does not need to add parameter 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 that the tool lists wallet's scratchpads and specifies the returned fields: names, sizes, updated and expiry dates. This distinguishes it from siblings like get_scratchpad_name, which likely retrieves a single scratchpad. The verb 'List' and resource 'wallet's scratchpads' are specific and actionable.

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

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

The description advises using this tool 'for the start of a session' to check if memory exists, providing context-sensitive guidance. It does not explicitly state when not to use it or mention alternatives, but the use case is clearly implied.

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 readOnlyHint and idempotentHint. The description adds valuable behavioral details: reading extends the pad's life by 30 days, costs $0.001 per call via x402, and the paying wallet serves as identity. 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 at 4 sentences, front-loading the main purpose and adding specifics about usage (raw parameter), behavioral effects (life extension), and 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 presence of an output schema (context), the description appropriately focuses on input and behavior. It covers reading scratchpads across sessions, the identity mechanism, the raw option, and cost. No critical gaps for a read operation.

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 at 100%. The description adds context: '?raw=1 returns the bare document instead of the JSON envelope', which clarifies the raw parameter's effect. However, it does not explain that the 'name' parameter is optional (required array empty) or what happens if omitted.

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' and the resource 'one of your wallet's scratchpads'. It specifies the scope (any session, any machine) and differentiates from sibling tools like 'post_scratchpad_name' (write) and 'get_scratchpad' (possibly without name).

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

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

The description provides usage guidance on the '?raw=1' parameter and notes cost and life extension. However, it does not explicitly state when not to use the tool or mention alternatives to help differentiate from siblings like 'get_scratchpad'.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds value beyond these by disclosing pricing ($0.001 per call, paid via x402) and detailing the exact checks performed, which informs the agent about cost and scope.

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 with no wasted words. It front-loads the main purpose ('Alt-text audit for any page') and efficiently lists all specific checks. Every sentence 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 complexity (multiple types of alt-text issues), a single parameter, and an existing output schema, the description provides a complete overview of what the tool checks. It covers all relevant aspects without needing to explain return values, which are handled 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% with a single parameter 'url' described as 'Public URL of the page to audit'. The description adds minimal meaning beyond the schema, stating 'any page' which aligns with 'Public URL'. Baseline 3 is appropriate as the schema adequately documents the parameter.

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 alt-text audit and enumerates specific issues detected (missing alt, filename-as-alt, generic alt, over-long alt, unlabeled SVG, image-map areas, image inputs, decorative alt counts). This distinguishes it from sibling SEO tools like get_seo_full_audit or get_seo_head_check, which cover broader aspects.

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 targets 'SEO and accessibility agents', providing clear context for use. While it doesn't state when not to use or mention alternatives, the specific scope of alt-text audit implies it's complementary to other SEO tools. This is sufficient for an agent to select it appropriately.

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 readOnly, openWorld, idempotent, and non-destructive hints. The description adds that it returns a 0-100 score with itemized deductions, full sub-reports, and pricing ($0.02 per call). 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 three sentences long, packing detailed information about the seven analyses and pricing. It is well-structured and front-loaded with the 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 the tool's complexity (seven analyses), the description covers all components, the score, pricing, and output structure. With 100% schema coverage and output schema present, it is fully complete.

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

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

Schema coverage is 100% with descriptions for both 'url' and 'level'. The description adds context about the bundle and the score being free, enhancing 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's a full on-page audit bundle with seven specific analyses against a single URL. It distinguishes itself from sibling tools like get_seo_head_check by being a comprehensive all-in-one call.

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 this tool is for a thorough audit, noting that individual pieces cost separately. It doesn't exclude any scenarios or suggest alternatives, but the context is clear enough 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. The description adds value by disclosing the specific audit checks and cost ($0.001 per call), 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?

Two sentences plus a cost note, front-loaded with the main purpose. Every word adds value, with no repetition or 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?

The description lists all key checks performed, and since an output schema exists, return values need not be detailed. It is sufficiently complete for a focused audit tool, though it could hint at response format.

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 'url' parameter, describing it as 'Public URL of the page to audit.' The description only mentions '?url=' briefly, adding no new semantic 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 the tool performs an SEO audit on head/meta elements, listing specific checks (title, description, robots, canonical, hreflang, etc.). It distinguishes from siblings like get_seo_full_audit by focusing on 'on-page fundamentals in one call.'

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 this tool versus alternatives. The phrase 'on-page fundamentals' implies a basic check, but no comparison to other SEO tools or conditions for use/avoidance.

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 pricing ($0.001 per call) 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?

A single sentence with a bulleted list of capabilities and cost info. Every part is valuable with 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 simple input (one parameter), annotations, and output schema, the description covers the tool's purpose, scope, and cost completely.

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 only one parameter and 100% schema description coverage, the baseline is 3. The description does not add extra meaning beyond the schema's 'Public URL of the page to analyze'.

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 'Internal-link analyzer for one page' and enumerates specific link metrics (internal/external counts, nofollow/sponsored/ugc usage, etc.). This distinguishes it from sibling tools like get_seo_full_audit which are site-wide.

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 specifies 'for one page' and lists the exact analyses performed, giving clear context. However, it does not explicitly mention when not to use it or provide alternatives 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?

The description adds useful behavioral details beyond annotations: it is 'unopinionated', returns parsed objects, and mentions cost. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint; description reinforces these 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 front-loaded with the core purpose ('Raw metadata extractor') and lists what it returns in a structured way. It is concise but adequately detailed, with 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 output schema exists and the tool has only one parameter with good annotations, the description provides a complete overview of what metadata is returned, including grouping of meta tags and JSON-LD. Adequate for an agent to understand the tool's capabilities.

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

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

There is only one parameter 'url' with 100% schema description coverage. The description mentions the URL pattern ('?url=') and cost, but the schema already sufficiently describes the parameter. Baseline of 3 is appropriate as description adds minimal extra semantic value.

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 'raw metadata extractor' listing specific elements (title, charset, lang, canonical, meta tags grouped by family, link relations, JSON-LD). It distinguishes itself from the sibling 'head-check audits' by noting that this tool just dumps the data without processing.

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 indicates the tool is for 'agents doing their own processing' and compares it to head-check audits, providing context for when to use this vs. an alternative. However, it does not explicitly state when not to use it or list other 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 provide safety hints (readOnly, idempotent, non-destructive). The description adds significant detail: it scores candidate regions, groups by source, and flags client-side rendering, plus mentions pricing, going well 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 with no extraneous details. The main purpose is front-loaded, and every clause adds value (method, use case, limitation, pricing).

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 single-parameter tool with an output schema, the description covers purpose, method, use case, limitation (client-side JS), and pricing. No missing information that would hinder proper 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% with a single 'url' parameter described simply as 'Public URL to extract navigation from'. The description does not add meaning beyond the schema for this parameter; the behavioral details are orthogonal.

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 identifies the tool as a 'Navigation extractor' and explains it pulls a site's navigation links by scoring candidate regions, differentiating from siblings like get_seo_links which likely extracts all links.

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 explicitly states it is 'For agents mapping site structure or planning which pages to fetch' and notes it reads server-rendered HTML, providing clear usage context. It does not explicitly state when not to use but implies limitations via client-side rendering flag.

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 valuable behavioral context beyond the annotations, including the pricing ($0.001 per call via x402) and the detailed list of outputs (crawler access verdicts, sitemaps, syntax warnings, llms.txt summary). 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 a single concise sentence that front-loads the key information (robots.txt + llms.txt checker) and efficiently conveys all necessary details 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 the tool's simplicity (one parameter, output schema present), the description covers all necessary aspects: what it checks, the bots, pricing, and expected outputs. 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?

The input schema already describes the 'url' parameter as 'Domain or any page on it', and the description merely repeats this ( '?url=any page on the site' ). With 100% schema coverage, the description adds no extra parameter semantics.

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

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

The description states exactly what the tool does: it checks robots.txt and llms.txt for crawler access verdicts for major search and AI bots, declared sitemaps, syntax warnings, and llms.txt presence. It is specific and distinct from other SEO tools in the sibling list.

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

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

The description clearly indicates the tool's purpose and scope (checking robot access for specific bots), providing context for when to use it. However, it does not explicitly state when not to use it or suggest 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 indicate readOnly and idempotent. The description adds behavioral details like crawling internal links, cost ($0.05 per call), and deliverable (per-page scores, site grade), enhancing transparency 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?

Concise and front-loaded: first sentence states purpose and scope, then details output and pricing. Every sentence contributes meaning 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?

Output schema exists (confirmed). The description fully explains the tool's behavior, inputs, output, and cost, making it complete for an agent to decide usage.

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%, baseline 3. Description adds context: 'usually the homepage' for url, defaults for level (AA), pages (5), and detail (summary), and explains that the tool audits and returns scores, adding value 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 the tool performs a 'SITE-WIDE audit' covering 7 on-page components across up to 8 pages, distinguishing it from sibling tools like per-page SEO 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?

It describes the scope (discovering pages from internal links, returning site-level verdict) and implies use for comprehensive audits, but lacks explicit when-not-to-use or alternative tool 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=true and destructiveHint=false, so safety is communicated. The description adds valuable behavioral detail: it finds sitemaps via multiple methods, handles index sitemaps, validates specific fields, flags cross-host URLs and oversize files, and performs a health check on a sample. Pricing is also disclosed, which is 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?

The description is a single sentence that lists all major actions efficiently. It front-loads the main purpose ('Sitemap validator') and then details behaviors. Pricing is appended in parentheses. No filler or 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 tool has an output schema, annotations, and only one parameter, the description covers the core functionality well. It explains what the tool does, how to call it (input), and includes cost. It doesn't describe ouptut format (but output schema covers that) or limitations, but overall is sufficient for a read-only validator.

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' has schema coverage 100% with description 'Site root or direct sitemap URL'. The tool description repeats this ("?url=site root or sitemap URL") without adding new semantics. Baseline is 3 as schema covers the parameter adequately.

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 begins with 'Sitemap validator:' and enumerates specific operations: finds sitemap, handles indexes, validates entries, flags issues, health-checks URLs. The verb 'validates' and resource 'sitemap' are precise, and the tool is clearly distinguished from sibling SEO tools like get_seo_robots_check or get_seo_full_audit by its focus on sitemap 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 implies usage for sitemap validation but does not provide explicit guidance on when to use this tool versus alternatives (e.g., get_seo_robots_check for robots.txt or get_seo_full_audit for a broader check). No when-not-to-use or alternative recommendations 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?

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds important behavioral context: the call costs $0.001 (paid via x402) and references the 50MB quota. This enhances transparency 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?

The description is extremely concise: one main sentence plus a parenthetical cost note. It is front-loaded with the 'AGENT DATASTORE' label and contains 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 no input parameters, an existing output schema, and annotations covering safety, the description fully explains what the tool returns (collections list with counts and quota usage) and the cost model. No gaps are present.

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

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

There are no parameters, so parameter semantics are not applicable. Schema description coverage is 100%. Baseline score of 4 is appropriate as the description does not need to add parameter meaning.

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

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

The description clearly states it lists wallet collections with specific fields (names, row counts, created dates, total rows, storage bytes), and mentions the 50MB quota. 'AGENT DATASTORE' labels the context. It distinguishes from siblings like get_store_collection by being the aggregate overview.

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 getting a data store overview but does not explicitly state when to use this versus alternatives like get_store_collection. No when-not or exclusion criteria are provided, leaving the agent to infer usage from 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?

The description adds value beyond annotations by detailing the expiry extension (30 days for reads, 60 for writes), cost per call, and output format options. 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 and front-loaded with the core purpose. It packs useful information into four sentences without unnecessary detail.

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

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

For a read-only tool with 6 parameters, all described in schema, and an output schema present, the description covers all essential behavioral aspects: pagination, ordering, since filter, output format, expiry, 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%, so baseline is 3. The description summarizes query parameters but does not add significant meaning beyond the schema. The cost and expiry details are generic, not per-parameter.

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 reads rows from a named collection owned by the wallet, with pagination and a since filter. It distinguishes from sibling tools by emphasizing read-only access and expiry extension.

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 reading stored data, but does not explicitly compare to sibling POST tools or specify when not to use. The 'AGENT DATASTORE' label provides 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 readOnlyHint, idempotentHint, destructiveHint. The description adds useful context: 'No AI — fast and deterministic,' pricing ($0.002), and payment method (x402). 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, concise and front-loaded. The first sentence conveys the core action and method. The second provides alternatives and pricing. Could be slightly more compact but 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 the tool's simplicity, full schema coverage, and presence of annotations and output schema (not shown but indicated), the description is complete: it explains functionality, method, alternatives, pricing, and constraints.

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% (both parameters described). The description adds the algorithm name (TextRank) and default value for sentences, but does not significantly extend beyond the schema's 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 specifies the tool's purpose: fetch a URL, extract main article, return key sentences via TextRank. It distinguishes from full scraping and AI summarization by explicitly contrasting with POST /api/summarize-text.

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 when to use: 'for agents that want the gist of a page, not a full scrape.' It also provides an explicit alternative for AI summarization or different input types (PDF/DOCX/own text) via a POST endpoint.

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 by disclosing approximate accuracy near borders, fast offline lookup, and cost structure ($0.001 per call, x402 payment). 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 concise sentences covering outputs, accuracy, use case pairing, and cost. No redundant or unnecessary 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?

Complete for a simple lookup tool with output schema present. All relevant aspects (purpose, behavior, cost, pairing) are covered.

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 description adds no additional information about parameters beyond what is already in the input 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 returns timezone data from GPS coordinates with specific fields (IANA zone, UTC offset, abbreviation, DST status, local time). It distinguishes itself from sibling tools by being the only timezone-from-coordinates endpoint.

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?

Describes pairing with IP-geolocation for analytics and scheduling agents, implying appropriate use cases. Lacks explicit when-not-to-use or alternatives, but the context 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?

Beyond readOnlyHint/idempotentHint annotations, description discloses HEAD request with GET fallback, redirect-following with safety checks, determinism, and pricing ($0.002 via x402). 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?

Three sentences: behavior, key attributes (deterministic, no download), and pricing. Front-loaded with essential info, 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 annotations (readOnly, idempotent, non-destructive) and presence of output schema, description sufficiently covers behavior, parameters, and return fields (up/down, status, latency, redirect chain, headers). Complete for purpose.

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

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

Single parameter 'url' with schema description already clear. Description adds example URL but doesn't provide new info. Schema coverage is 100%, 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 clearly states it's an uptime/health probe for public URLs, sending HEAD requests, following redirects, and returning status/latency/headers. It specifies it's a monitoring probe for schedule calls, distinguishing it from scraping or other 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?

Description explains when to use (uptime checks for public URLs, deterministic, no page download), implying it's not for full page analysis. It doesn't explicitly name alternatives like get_scrape, but the context from siblings 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context beyond annotations: it uses a HEAD probe (no page download), provides timing waterfall, identifies the exact failure phase, and mentions the payment mechanism. 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 but well-structured, front-loading the main functionality in the first sentence. It is not overly verbose, though the cost note could be more prominent. Overall efficient use of space.

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 (as noted in context signals), the description covers the tool's comprehensive output thoroughly, listing many components. It is complete for a health monitoring tool's purpose, and the presence of an output schema offloads detailed return structure.

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 single parameter 'url' having a clear description. The description does not add further input semantics; it focuses on output. Baseline of 3 is appropriate as schema already documents the parameter adequately.

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 produces a 'deep uptime & health report' from a single HEAD probe, listing numerous specific metrics (DNS, TCP, TLS, TTFB, certificate, etc.). It distinguishes itself from siblings like get_dns or get_ping by being a comprehensive, one-call tool that covers multiple layers.

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 detailed health monitoring and notes cost ($0.01 per call). However, it does not explicitly state when to use this tool versus simpler sibling tools (e.g., get_uptime, get_dns) or exclude scenarios where a full page load is required. Guidance on alternatives is absent.

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 indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description expands on this by noting real browser rendering, output as base64 JSON or raw bytes, ad blocking, and pricing ($0.04 per call via x402). It does not contradict annotations and adds behavioral traits beyond what annotations provide.

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 of 4 sentences, front-loaded with the key purpose. It is clear and without waste. However, it could be slightly more structured (e.g., bullet points for options) to improve scanability.

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 (6 parameters, output schema exists, 1 required parameter), the description covers all essential aspects: purpose, output format, options, pricing, and ad blocking. With an output schema, return values are covered; the description is complete for agent decision-making.

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% (all 6 parameters have descriptions). The description restates key options ('width 320-1920 (default 1280), height, full_page=1, format=png|jpeg') but adds no new meaning beyond the schema. The baseline is 3, and the description provides marginal value by summarizing defaults.

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 starts with 'WEBSITE SCREENSHOT' and states 'render any public URL in a real browser and get the pixels.' The verb 'render' and resource 'URL' are specific, and the tool is clearly about capturing a screenshot. It distinguishes from sibling tools like get_scrape (text extraction) by focusing on visual capture.

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 lists explicit use cases: 'visual QA, previews, archiving, design reference.' It also mentions automatic ad/cookie banner blocking. However, it does not provide when-not-to-use or suggest alternatives, though the use cases provide clear context for selection.

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. The description adds valuable context: 'PASSIVE hygiene assessment from public signals', 'no intrusion', 'Flags security practice, not exploitable vulnerabilities', and describes the return value (0-100 score with remediation). 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 (multiple sentences) and front-loaded with the key purpose. Every sentence provides useful information 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 tool's complexity (security assessment), the description covers what it checks, what it detects (user enumeration, dir listing, headers, etc.), that it's passive, who should use it, pricing, and the output format. Output schema exists, but the textual description already explains the return value sufficiently.

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 'WordPress site URL to assess (homepage)'. The description does not add further meaning beyond the schema, but schema coverage is 100%, so 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 'WordPress security posture check' and lists specific checks (version disclosure, xmlrpc.php, user enumeration, etc.). It distinguishes from sibling tools by focusing on WordPress security and clarifying it flags security practices, not vulnerabilities.

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 'For site owners and authorized auditors' and implies use for WordPress sites via passive assessment. It doesn't provide explicit alternatives or when-not-to-use, but the context 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 note non-destructive behavior, and description adds cost, character limit, and message types, though could detail auth or rate limits more.

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 front-loaded with purpose and includes examples, but could be slightly more concise.

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, description fully explains purpose, constraints, and usage, 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?

Schema descriptions cover all parameters; description reiterates types and character limit but adds no new semantic details 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 the verb ('Post') and resource ('Agent Helpdesk / machine message board'), and distinguishes it from sibling tools by specifying it's for posting general messages to a 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?

Provides context on when to use (e.g., to request endpoints) and lists message types, but doesn't explicitly differentiate from sibling like post_board_intro or post_board_sticky.

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 indicate write operation (readOnlyHint=false), non-idempotent, non-destructive. Description adds that it is free per call, paid via x402, and that the wallet becomes durable identity. It also notes the one-free-per-caller limitation. 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, no fluff. Front-loaded with the core action and scope. Structured with clear separation of free vs paid, and body format. 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 and presence of output schema, the description covers all key aspects: cost model, identity implications, allowed types, per-caller limitation, and subsequent paid usage. It is complete for an AI agent to correctly invoke the tool.

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

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

Schema coverage is 100% with all three parameters described. The description adds meaning by listing the allowed types and character limit for text, and explaining the body structure. It goes beyond schema by giving context about the purpose of each type and the optional nature of agent.

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 'Post ONE free introduction to the Agent Helpdesk (machine message board)', specifying the verb 'Post', the resource 'introduction to Agent Helpdesk', and key scope constraints: one per caller, no payment, no wallet needed. It distinguishes from sibling 'post_board' which is paid.

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

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

Explicitly states when to use this tool: for the first free introduction, one per caller address, no payment. It also explains the alternative: after the intro, use POST /api/board for paid posts. The description lists allowed types (feature, critique, praise, bug, tip) and character limit.

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 key behavioral traits: pinned behavior (7 days), cost, and payment via x402. Annotations already indicate non-read-only, non-destructive, non-idempotent. Description adds value 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, front-loaded with purpose and key feature (pinned). Includes cost info without extra fluff. Efficient and focused.

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, rich annotations, and existing output schema, the description covers purpose, behavior, cost, and schema. No gaps for an AI agent to invoke correctly.

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

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

Schema coverage is 100% with descriptions for all 3 parameters. Description mentions character limit for text, but schema already includes it. No additional meaning 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?

Description clearly states it posts a PINNED message to the Agent Helpdesk, distinguishing it from sibling tools like post_board (regular message) and post_board_intro (intro). Uses specific verb 'Post' and resource '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?

Indicates the message stays at top for 7 days, implying use for important announcements. Mentions cost and payment method, but does not explicitly state when not to use or compare to alternatives like post_board.

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