x402 Checker (AI Nock)

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

Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds significant behavioral context: a required $0.01 USDC payment on Base, the exact payTo address, use of the public arXiv Atom API, and the metadata-only/no-PDF restriction. These are non-obvious operationally critical details beyond what annotations or schema 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 dense and efficiently front-loaded: payment and core purpose first, then parameter usage, then limitations and relational context. Every clause carries essential information and there is no filler.

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

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

For a read-only search tool with five documented parameters and full schema coverage, the description covers the payment requirement, API source, parameter usage, output limitation, and a sibling relationship. No critical operational detail appears missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description reinforces the q/id relationship and gives an example ID and category, but does not add substantial new semantics. 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 states a specific verb and resource: 'academic paper search via public arXiv Atom API.' It also distinguishes itself from siblings by noting it complements /hn and is limited to metadata. The agent can clearly understand what the tool does and how it differs from similarly broad 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 gives clear context for use: search arXiv academic papers with q or id, optional category and sorting, and 1..8 hits. It also provides an explicit exclusion: 'Metadata only; no PDF fetch.' It does not name alternative paper-search tools, but 'Complements /hn' gives some relational context and no close sibling exists in the list.

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

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

It discloses that this is a paid operation ($0.05 USDC exact on Base), provides the payTo address, and details the side effect of adding to the origin's 24h total. These details go far beyond the annotations, which only signal non-read-only and open-world behavior. 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 compact and front-loaded with the core purpose and cost, then moves to constraints and payment details. Every sentence adds value, though the single dense paragraph could benefit from light structuring.

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

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

For a paid, blockchain-backed write operation with no output schema, the description should explain how payment is executed and what a successful result looks like. It covers cost, destination, and URL eligibility but omits confirmation/response semantics, leaving an agent uncertain about post-conditions.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaningful semantics to the optional parameters; for 'url' it only restates the schema's HTTP 402/origin constraint. It does not compensate with new information about the optional fields.

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

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

The description states a specific action ('bid on the pay-to-rank board') and gives precise scope: the bid costs $0.05 USDC on Base and each verified bid adds to that origin's 24h total. This makes the tool's purpose unmistakable and clearly distinguishes it from sibling 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 eligibility criteria for the URL parameter (must return HTTP 402 or be this origin, http(s) only, no telegram/discord/whatsapp) and notes the REST POST /bid equivalence. It does not explicitly name sibling alternatives, but the constraints define when the tool can be used.

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

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

The description discloses the paid nature ($0.01 USDC on Base) and the payTo address, as well as the 366-day cap and holiday coverage. It does not explicitly state read-only behavior, but the annotations provide readOnlyHint. Payment details are transparent, but side effects like the payment process are not fully explained.

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 structured as a single statement with key details embedded. It avoids unnecessary verbosity but is somewhat dense, packing multiple facts into one sentence.

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

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

The description covers payment, calendar scope, and parameter constraints, but lacks explicit information about the output format or how the payment is executed. Given the tool's complexity (paid and blockchain-related), the description is not fully complete but covers essential operational aspects.

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

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

The description explains the usage of date, start, and end parameters, including defaults and caps. It does not mention the tz parameter, but the schema provides its description. Overall, parameter semantics are well-covered.

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 indicates this tool provides US federal business-day calendar information, mentioning holidays and weekday rules. However, it does not explicitly state the exact output (e.g., count, boolean, or list), so the purpose is clear but not fully specified.

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 no guidance on when to use this tool versus the sibling tools. There is no mention of alternative use cases or comparative advantages, leaving the user without 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 only say readOnlyHint and openWorldHint, but the description adds substantial behavioral detail: the exact cost and payTo address, accepted input formats, rejection of pending, the paid 200 with found:false behavior for unknown ids, and scope limitations. This goes well beyond what annotations convey.

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

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

Every sentence carries load-bearing information: cost, resource, input formats, returned fields, error behavior, exclusions, and payTo address. The description is tightly packed and front-loaded with the most important facts.

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

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

Given there is no output schema, the description usefully lists the returned fields and covers edge behavior such as unknown ids and rejected pending values. The only meaningful gap is the ambiguous 'hash=' construction and the lack of a concrete example, which leaves minor room for misinterpretation.

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 basic descriptions, and the description adds valuable parameter semantics by enumerating accepted n formats (latest|earliest|safe|finalized, decimal, 0x number, hash=) and noting 'Rejects pending.' The phrase 'hash=' is slightly ambiguous relative to the separate hash parameter, which prevents a perfect score.

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 resource as 'block header via public RPC' and lists the returned fields, so an agent knows what the tool provides. However, it lacks an explicit verb like 'fetch' or 'get', and while 'No full txs' and 'Not a mempool tip' help distinguish it from siblings, no alternative tool is named.

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 gives clear context for when the tool is appropriate: it fetches block headers, accepts specific block tags, and explicitly states exclusions: 'Rejects pending', 'No full txs', and 'Not a mempool tip'. It stops short of explicitly naming sibling tools to use instead, which keeps it from a 5.

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

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

The readOnlyHint and 'Does not spend money' and 'No self-pay' are consistent, and the description adds useful behavioral context about pay-to-rank mechanics and listing ranking. The cryptic phrase 'Empty JSON still sells' slightly undermines clarity, so it is not a 5.

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

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

The description is short, but it mixes pricing details, brand attribution, and cryptic fragments like 'how/next point at unpaid' and 'Empty JSON still sells' without clear structure. The core behavior appears only in the second sentence and the wording is dense rather than clean.

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?

There is no output schema, and the description only hints at response shape through 'Rank listings...' and 'payTo on the JSON.' It gives enough for a simple zero-parameter read operation, but leaves the exact response structure and empty-result behavior ambiguous.

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 there is no parameter semantics to document. Schema description coverage is 100%, and the description correctly avoids inventing parameter details; baseline 4 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 identifies the resource as a board that ranks listings by USDC bid total in the last 24 hours, which tells an agent what the tool provides. It stops short of being fully direct because it never states an explicit action like 'returns the board' and starts with a branded, jargony phrase.

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 references related endpoints such as GET /check as a listing gate and GET /find at $0.01, and says REST GET /board is the same SKU. However, it does not explicitly say when to prefer this tool over those alternatives or when not to use it.

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

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

Annotations already mark readOnlyHint and openWorldHint; the description adds useful behavior: it sends no payment headers, makes an external fetch, returns a risk note, and does not spend money. It does not elaborate on timeouts, non-402 responses, or rate limits, but for a read-only probe these are not critical.

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?

Most of the content is task-relevant, including the output field list and next-action pricing, so it is richer than a bare stub. However, it is a dense run-on with branding ('by AI Nock') and unexplained jargon ('x402 wash/honesty probe', 'has402') that could be tightened.

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

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

With no output schema, the description enumerates the returned values and the always-present next options, which an agent needs to interpret the result. It remains slightly incomplete about non-402 responses and what 'has402' means, but the one-parameter tool is otherwise well 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?

The sole parameter url is fully documented in the schema with 100% coverage, and the description mostly restates the same 'no payment headers' constraint. It adds no new semantics about URL format or behavior 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?

States a concrete operation — fetches an http(s) 402 URL without payment headers — and lists the returned fields, so an agent understands what check does. It does not explicitly distinguish itself from sibling check_batch or related paid actions, so it doesn't fully earn a 5.

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

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

Explicitly says 'Use before paying any x402 resource,' giving a clear condition for selection. It doesn't discuss exclusions or compare with alternatives, but the single directive is sufficient for most routing decisions.

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

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

The description discloses exact cost ($0.01 USDC on Base), the payTo address, output-shape parity with check, and even the pricing of subsequent result fields. This goes well beyond the readOnlyHint and openWorldHint annotations and leaves little hidden about the paid batch behavior.

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

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

The description is front-loaded with the most important facts: paid, batch, max 10 URLs. The parenthetical list of next.* prices adds detail useful for understanding responses but is somewhat noisy for selecting or invoking the tool.

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?

There is no output schema, but the description at least references the free check result shape and the has402 conditional field. It is largely complete for a one-parameter paid batch tool, though it does not define what an 'x402 honesty probe' actually returns beyond that shape.

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

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

Schema coverage is 100% and already documents the 1-10 URL array, SSRF-safe rules, and that payment headers are not sent to targets. The description adds pricing context but no additional per-parameter meaning beyond what the schema provides.

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 identifies the resource as a batch operation over up to 10 URLs and ties it to the free 'check' tool by saying each result has the same shape. It never explicitly states 'checks multiple URLs', relying somewhat on the tool name and sibling context, but it clearly distinguishes check_batch from the single-URL free check.

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

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

The phrase 'GET /check stays free for one URL' provides a clear singleton-vs-batch heuristic, and the paid amount plus max-10 limit signal when this batch path is appropriate. It does not explicitly say 'use check for one URL and check_batch for multiple', but the implication is strong.

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

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

Annotations already mark the tool read-only; the description adds meaningful context by disclosing a $0.01 USDC cost on Base, stating 'No API keys,' and specifying that results are returned in UTC and America/Denver. There is no contradiction with 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 compact and information-dense, covering pricing, function, required and optional parameters, output time zones, auth requirements, and the payTo address in roughly fifty words. The payment detail is front-loaded and every clause contributes useful information, though the phrasing is slightly run-on.

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 output schema, the description explains what will be returned ('next fire times in UTC and America/Denver') and covers cost, input requirements, and defaults. It is slightly vague about the exact return format and how payment is settled, but the core information an agent needs to invoke the tool is 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?

Schema coverage is 100%, so the baseline is 3. The description mostly restates schema facts such as expr being required, tz defaulting to UTC, and n defaulting to 5. It adds the overall cron-parsing context but does not materially deepen per-parameter meaning beyond what the schema already provides.

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 'unix cron parser' and states that it 'Returns next fire times,' which is a specific function tied to a concrete resource. It is readily distinguishable by name and domain from siblings like tz or check, though it does not explicitly contrast itself with them.

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 the tool by identifying it as a cron parser and listing the required expr parameter along with optional tz and n. However, it never explicitly states when to use this tool versus alternatives, nor gives any exclusions or when-not-to-use conditions.

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 readOnlyHint and openWorldHint annotations, the description discloses the exact payment requirement ($0.001 USDC exact on Base), the payTo address, ~15-minute caching, and the absence of API keys. This is significant operational context that affects whether and how an agent can invoke the tool.

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

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

The description is compact and every clause provides useful information, but it is a single dense sentence that leads with the payment detail rather than the core purpose. This slightly weakens front-loading while still keeping the content 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?

For a simple tool with one optional parameter and no output schema, the description adequately covers cost, payment address, cache behavior, and sources. However, it does not describe the return format or how the payment is executed, which may matter to an agent since no output schema is available.

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 documents the single parameter fully: optional, case-insensitive, max 80 characters, filtering title/summary/source. The description only says 'optional topic filter,' adding no new semantic meaning, so the baseline score of 3 applies.

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

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

The description clearly states the tool's function: a 'public crypto RSS recap' from named sources (CoinDesk, The Block, Decrypt, Base blog) with an optional topic filter. This is specific and distinct from all listed sibling tools, none of which appear to provide crypto news.

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 the tool (for public crypto news) and mentions optional topic filtering, caching, and the lack of API keys. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, though no obvious sibling overlap exists.

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

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

Discloses that the tool requires payment ('Paid $0.01 USDC exact on Base' with a payTo address), which is significant behavioral context beyond the readOnlyHint annotation. Also sets expectations by noting 'NVD-only metadata; no exploit/PoC'. No contradiction with annotations was found.

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

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

The description is compact and packs essential details: payment, purpose, parameter examples, constraints, limitation, and complementary tools. Payment info is front-loaded ahead of the core purpose, but the overall structure remains efficient and scannable.

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 the payment mechanism, mandatory id/q variant, optional parameters, and the NVD-only output limitation. There is no output schema, so a fuller return-shape description would help, but for a 4-parameter read-only lookup with 100% schema coverage, this is nearly 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?

The schema already describes all four parameters, so the bar is a baseline of 3. The description adds concrete examples such as 'CVE-2021-44228' and 'q=log4j' and restates allowed severity and hits ranges, making the parameter usage clearer without introducing deep new 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?

States 'CVE / NVD vulnerability lookup via public NIST NVD 2.0', giving a clear verb and resource. 'Complements /sanctions /tsec' hints at its role among security tools, but it does not explicitly contrast with a sibling.

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

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

Provides usage examples ('id=CVE-2021-44228' or 'q=log4j') and says 'Complements /sanctions /tsec', implying it should be used alongside those tools. The limitation 'NVD-only metadata; no exploit/PoC' is useful but does not clearly state when to choose this tool over 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?

Beyond the readOnly and openWorld annotations, the description usefully discloses a financial side effect (exact $0.01 USDC payment on Base), the payTo recipient, and the liquidityUsd ranking with a max of 5 results. It does not contradict the annotations, though it omits error/pagination behavior.

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

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

The description is compact, front-loading the unusual payment/network constraint and staying telegraphic. Only the 'Not investment advice' disclaimer is extraneous to tool invocation, keeping it from a 5.

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

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

For a paid, mode-switching tool the description covers payment amount, chain, recipient, filter, and result ranking, but it leaves the output payload and the payment execution mechanism unspecified. With no output schema, more clarity on return shape would make it complete.

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

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

Schema description coverage is 100%, so the baseline is 3; the description largely restates the schema's q/chain/address meanings. It adds shorthand ('address=0x', 'q=') but does not clarify whether address and q are mutually exclusive or what happens if both are supplied.

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

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

The description names DexScreener pairs as the resource and distinguishes two lookup modes (token address vs search query), so an agent can tell what operation is being offered. It lacks an explicit verb like 'retrieves' or 'returns' and does not contrast with sibling lookup tools, so not a 5.

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

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

It gives clear invocation context: use a 0x address or a search q, with chain as an optional filter, and the schema adds that base is the default in address mode. It names no alternatives or when-not conditions, so it stops short of 5.

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

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

The description discloses important behavior beyond the readOnlyHint/openWorldHint annotations: it mentions the $0.01 USDC payment on Base and the payTo address. It also enumerates the data sources, but it does not clarify error cases or whether the payment is external to the MCP request.

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

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

The description is compact, front-loads the payment requirement, and uses one dense sentence plus the payTo address. There is no filler, repetition, or unnecessary context.

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, read-only tool with no signed output schema, the description provides enough information to choose the tool and invoke it: what data is covered, that payment is required, and the expected input. A brief statement of the response format would have made it fully complete, but the description 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?

The input schema already fully defines the host parameter as a public DNS hostname, not a URL or IP. The tool description adds no new parameter insight; it mostly repeats the same wording. Baseline 3 is appropriate because schema coverage is high.

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's output: a DNS/RDAP/TLS/SPF/DMARC dossier for a public hostname. It distinguishes the tool's scope from siblings by naming the data sources, but it does not use an explicit verb like 'returns' or explicitly compare it to alternatives.

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

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

Usage is implied: call this tool when you need domain-related data from DNS, RDAP, TLS, SPF/DMARC. There is some payment context and a public-hostname constraint, but no explicit guidance about when to prefer another tool or when not to use it.

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

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

Annotations provide readOnlyHint and openWorldHint, but the description adds substantial behavioral detail: payment requirement and exact payTo address, DNS-over-HTTPS mechanism, no SMTP, disposable-domain and MX-absent invalidity, and fail-closed error handling. This richly exceeds the annotation baseline.

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

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

The description is one dense, front-loaded sentence with no filler. Every clause conveys essential operational or validation 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?

For a single-parameter validation tool with no output schema, the coverage is strong: behavior, failure mode, and payment requirement are all stated. The only gap is the absence of any hint about the return value or response format, which the lack of an output schema makes somewhat relevant.

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

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

Schema coverage is 100% for the single 'addr' parameter, and the description adds meaning by defining what makes an address invalid (disposable domain, missing MX). This directly informs which parameter values the tool will accept or reject.

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 communicates the tool's function: validating email syntax and MX records via DNS-over-HTTPS, with no SMTP. It is specific enough to distinguish from sibling tools like 'domain' or 'check', though it lacks an explicit verb like 'validate'.

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 specifying constraints: email only, no SMTP, paid $0.01 USDC, and fail-closed behavior. However, it does not explicitly state when to prefer this tool over alternatives or name any sibling tools for comparison.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses the $0.01 USDC payment on Base, the payTo address, the reliance on public HTTP resolvers, and the behavior for unresolved names (resolved:false after payment). This gives an agent important operational context beyond the annotations, though the exact payment mechanism is not fully specified.

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 carry all critical information without fluff: payment, purpose, resolver type, unresolved behavior, and the exclusion of the registrar. The ordering is slightly unconventional (payment before purpose), but each 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?

The description covers payment, chain, resolver, unresolved behavior, and an alternative endpoint, which is substantial. However, it does not describe the return format for a successful resolution (e.g., what resolved:true includes) or the exact steps to complete payment, and there is no output schema to fill that gap.

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

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

Schema coverage is 100% and the schema description already documents the name parameter. The tool description reinforces the requirement to end in .eth and clarifies that Basenames like foo.base.eth are also valid, adding a small but useful nuance 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 names a specific action ('resolve an ENS or Basename') and a concrete resource (the name), with the required format. It also distinguishes itself from the registrar endpoint ('Not POST /name'), so an agent can tell it apart from sibling tools without ambiguity.

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 gives clear context: it is a paid lookup using public HTTP resolvers, and it explicitly says it is NOT the registrar endpoint, which is a direct when-not case. It does not compare itself to sibling lookup tools like name_lookup or who, but the registrar exclusion is a strong usage signal.

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=true, so the safety profile is covered. The description goes well beyond this by disclosing the $0.01 USDC cost, the Base network, the exact payTo address, and the free+paid catalog scope. 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?

Every clause earns its place: payment cost, search scope, parameter hints, entity coverage, and the global-index caveat. The most operationally critical fact (paid) is front-loaded.

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

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

Covers scope, cost, payment address, required and optional parameters, and entity targets. The main gap is that it does not explain how payment must be made (e.g., pre-funding vs. attached transaction) or what the result payload looks like, which is more consequential for a paid tool without an 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 description coverage is 100%, so the baseline is 3. The description mostly restates q= and limit=1..20, though 'House discovery (board/bid/name + SKUs)' adds useful semantic context for what kinds of queries are meaningful.

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

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

States a specific verb+resource: 'search this origin's free + paid catalog by keyword q='. The 'House discovery (board/bid/name + SKUs)' qualifier gives concrete scope, and 'Not a global index' actively distinguishes it from broader search 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?

Gives clear positive context (search local catalog, `q` keyword, optional limit) and an explicit negative boundary ('Not a global index'). It does not name sibling alternatives such as arxiv, cve, or wiki, so the alternatives requirement for a 5 is missing.

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

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

Annotation Contradiction: readOnlyHint is true, but the description explicitly states 'Paid $0.01 USDC exact on Base' and provides a payTo address, indicating a financial side effect. This directly contradicts the read-only annotation, and the added cost/source details cannot compensate for the 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?

The description is short and dense, but poorly front-loaded: payment details precede the actual purpose. 'Not investment advice' is boilerplate, and the ordering makes it harder for an agent to quickly identify what the tool does.

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

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

The description covers cost, payee, data source, and parameter limits, which is useful for a simple tool. However, there is no output schema and no description of the response shape, so the agent cannot know what the tool returns beyond the vague 'Crypto Fear & Greed Index'.

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

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

The schema already documents the limit parameter with 100% coverage, including range and default. The description's 'Optional limit=1..30 (default 1)' adds no meaningful semantics beyond repeating 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 identifies the resource as the 'Crypto Fear & Greed Index via public alternative.me', which is specific and distinct from the sibling tools. It lacks an explicit retrieval verb and the opening 'Paid $0.01 USDC...' clause initially obscures the core 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?

There is no guidance on when to choose this tool over siblings like price, quote, or crypto_news. The description implies it is for fetching the Fear & Greed Index, but it provides no exclusions, alternatives, or situational 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 only provide readOnlyHint and openWorldHint; the description adds the important paid nature of the call—$0.01 USDC on Base—and the payTo address, which is behavior an agent would not know from structured data. The 'Not investment advice' disclaimer is extra context. The payment is an external side effect rather than a data mutation, so it does not contradict readOnlyHint.

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-loads the key fact that the tool is paid, then gives parameters, scope, and payment address. Only the 'Not investment advice' phrase is arguably non-operational, but it does not significantly bloat the description.

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

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

For a tool with three optional parameters and no output schema, the description covers payment mechanics, defaults, fiat-only scope, and the alternative for crypto. It does not describe the response format, but that is not essential for invoking the tool correctly.

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

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

The input schema already documents all three parameters with coverage at 100%, including defaults and comma-separated format. The description restates this shorthand without adding substantial new parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as a fiat FX converter using Frankfurter/ECB, and it explicitly separates this from crypto pricing by directing to '/price'. The verb and resource are specific, and the fiat-only note makes the tool's scope unambiguous.

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

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

The description states 'Fiat only — use /price for crypto', giving an explicit when-not-to-use condition and naming the alternative tool. It also provides defaults for from, to, and amount, so an agent knows how the tool behaves when parameters are omitted.

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 reinforces the readOnlyHint and openWorldHint annotations by stating 'Read-only' and 'No API keys.' It adds meaningful context beyond the annotations: the public RPC source, cost of $0.01 USDC, and the payTo address, which are material to invoking the tool correctly.

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

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

The description packs several useful facts into one compact set of sentences: purpose, payment, parameters, return values, read-only nature, and payTo address. It is dense but each clause earns its place, though some details are squeezed together.

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

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

With no output schema, the description helpfully mentions return fields and units (gwei fields + suggestedMaxFee). It also covers cost, payment destination, optional chain, and access method. It does not show a full response shape, but it gives enough for an agent to know what to expect and how to 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?

The only parameter, chain, is already fully described in the schema as optional and currently limited to base. The description adds 'Optional chain=base,' which aligns with the schema but does not meaningfully extend it, 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 this is a live Base gas oracle returning gasPrice, maxPriorityFee, feeHistory, gwei fields, and suggestedMaxFee. The verb and resource are specific, and the tool is readily distinguishable from the listed siblings, none of which offer gas data.

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

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

It gives clear context for invocation: chain is optional and only 'base' is supported, no API keys are needed, and the call is read-only. It also signals the cost requirement upfront. No explicit alternative tool is named, but no sibling appears to provide equivalent functionality.

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 readOnlyHint and openWorldHint annotations, the description discloses essential behavioral traits: the tool is paid ($0.01 USDC exact on Base), requires attribution, uses public Nominatim, and specifies the payTo address. Nothing in the description contradicts 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 dense sentence that packs operation modes, service, payment, attribution, and payment destination without wasted words. Critical information is front-loaded.

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

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

The description covers the essential operational details: how to invoke each mode, the fee, the payment address, the network, and attribution. It is slightly incomplete in that it does not describe the output shape or behavior when both q and lat/lon are provided or when none are provided, but geocoding semantics are largely implicit.

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

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

The schema already documents all three parameters at 100% coverage, so the baseline is 3. The description adds useful mapping between parameter groups and operation modes: `q` for forward, `lat=`/`lon=` together for reverse, and implies that lat/lon must be used as a pair.

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

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

The description states a specific verb and resource: forward geocoding via `q=` and reverse geocoding via `lat=`/`lon=`, using public Nominatim/OpenStreetMap. This clearly identifies what the tool does and distinguishes it from the broader 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 gives explicit usage context: use `q` for forward geocoding and `lat`/`lon` for reverse geocoding. It also warns that attribution is required. It does not explicitly state when not to use the tool or name alternative geocoding tools, but no close sibling exists in the provided list.

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

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

The description discloses meaningful behavioral context beyond the readOnlyHint and openWorldHint annotations: the tool is keyless, works only against public GitHub metadata, never accesses private repos, incurs a specific $0.01 USDC payment on Base, and provides a payTo address. This is genuinely useful operational transparency about auth, data scope, and cost.

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 and front-loaded, packing the tool's purpose, modes, parameter rules, auth constraints, cost, and payment address into a compact block. Every clause earns its place, though the telegraphic run-on style could be better structured for readability.

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

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

With no output schema, the description covers the main invocation details: modes, required parameter combinations, keyless public access, and payment information. It does not describe the response shape or clarify how the $0.01 USDC payment is handled or verified, which leaves a small but real operational ambiguity.

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

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

Although the schema covers all parameters, the description adds critical cross-parameter semantics that the schema does not explicitly provide: which parameters belong to which mode, the mode combinations (e.g., owner=&repo= vs full=owner/repo), and the default mode. This goes well beyond the individual field 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 identifies the tool as a GitHub public REST lookup via api.github.com, with explicit modes (search, repo, user) and a default. It is specific about the resource and verb, and the GitHub domain distinguishes it from all listed sibling tools, none of which are GitHub-focused.

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 gives explicit mode-to-parameter mappings: search uses q, repo uses owner=&repo= or full=owner/repo, and user uses user= or login=. It also states the public-only scope and that no private repos or token are supported. It lacks an explicit statement about when to prefer an alternative, but no sibling tool provides overlapping GitHub functionality.

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 openWorldHint=true, and the description adds context about the payment (Paid $0.01 USDC exact on Base) and that it's a raw dump, not markdown. This adds value beyond annotations, though it doesn't detail rate limits or auth needs.

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

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

The description is concise, with two sentences that front-load the purpose and add key context. It earns its place without unnecessary fluff.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is mostly complete. It covers the purpose, payment, and a key behavioral note, but could benefit from mentioning what the output looks like or any limitations.

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% for the single 'url' parameter, and the description adds that no payment headers are sent to the target, which is useful. However, the description doesn't elaborate on URL format or edge cases 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 a raw HTTP header dump of a public URL, which is a specific verb+resource. It also distinguishes itself from siblings by explicitly noting it is not an honesty probe or markdown, though it doesn't name specific sibling 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 implies usage for inspecting HTTP headers of a public URL, and the schema notes no payment headers are sent. However, it doesn't explicitly state when to use this over alternatives or when not to use it, leaving some ambiguity.

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

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

The description discloses a real-world side effect: paying $0.01 USDC on Base and sending funds to a payTo address. This directly contradicts the readOnlyHint=true annotation, which signals the tool does not make state-changing modifications. Because the description contradicts an annotation, this dimension must be scored 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 compact and packs a lot of information into one sentence, but it is not well structured: payment details are front-loaded ahead of the tool's core purpose, and the parameter list is compressed into a dense middle section. There is no wasted wording, but the ordering and readability are only average.

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

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

The description covers payment, API source, and required parameters, but it omits return format, failure behavior, and any note about how the readOnlyHint should be reconciled with the payment requirement. For a tool with no output schema and a significant monetary side effect, an agent needs more context to invoke it correctly and predict consequences.

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

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

Schema description coverage is 100%, and the schema already documents each parameter's meaning, defaults, and allowed values. The description repeats that information in abbreviated form without adding substantial new semantics, so it stays at the baseline score of 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 identifies the tool as a Hacker News search via the public Algolia HN API, giving a specific resource and operation. It also notes that it complements /crypto-news, which helps distinguish it from the sibling crypto_news tool. It lacks a strong imperative form like 'Search Hacker News', but the intent is unambiguous.

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

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

The description states required and optional parameters, but gives no explicit guidance about when to use this tool versus alternatives. The only comparison is a vague 'Complements /crypto-news', which hints at a boundary but does not explain trade-offs, exclusions, or when another tool would be more appropriate.

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

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

Annotations declare readOnlyHint=true, indicating a read-only operation, and the description does not contradict this. The description adds context about the tool's limitations (tiny subset, no $ref) and payment requirement, but does not clarify what the tool actually outputs or whether errors are returned for invalid data.

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, concise and front-loaded with the action and payment. It conveys key information, though the payment address inclusion may be seen as unnecessary detail, but it does not harm conciseness much.

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

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

Given the tool's moderate complexity, the description covers purpose, key constraint (subset, no $ref), and payment requirement. No output schema is needed as the tool is likely to return validation results, but the description is brief; still, it is sufficient for basic 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 description coverage is 100%, so parameters are documented with descriptions like 'JSON instance object or JSON text' and 'JSON Schema object or JSON text'. However, the description does not add further semantic detail beyond what the schema provides, so baseline 3 is appropriate.

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

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

Purpose is clear: validate JSON data against a JSON Schema, specifying it's a tiny built-in subset with no $ref, and mentioning it is paid on Base. This distinguishes it from sibling tools like 'check' and 'domain', which are not about JSON validation.

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

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

The description implies usage for validating JSON data, but does not explicitly state when to use this tool versus alternatives, nor when not to use it. It mentions the paid nature and payment address, which is a contextual usage hint, but lacks direct guidance on choice 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 meaningful context beyond the annotations: it discloses a $0.01 USDC payment requirement, a payTo address, and the 'public URL' constraint. The readOnlyHint and openWorldHint annotations are not contradicted. It does not explain payment mechanics or error behavior, but the added context is valuable.

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 short, but the payment phrase is front-loaded awkwardly before the actual verb, and the payTo address appears as a detached second sentence. It is not verbose, but the structure could better prioritize the core action.

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

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

For a one-parameter tool with annotations and no output schema, the description covers purpose, return type, and payment context. However, the payment requirement is ambiguous ('Paid $0.01 USDC exact on Base' could mean already paid or required), and there is no mention of error handling, redirects, or content limitations.

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

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

Schema coverage is 100% and the url parameter is already described as an 'http(s) URL to inspect' with no payment headers sent. The tool description adds only the word 'public' and the output format, which is marginal beyond the schema. 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 a specific action: 'fetch a public http(s) URL and return simple HTML-to-text markdown.' This distinguishes it from sibling tools like headers, json, and domain. The payment prefix is unusual but does not obscure the core 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?

Usage is implied: use this tool when you need HTML-to-text markdown from a public URL. However, there is no explicit when-not-to-use guidance or mention of alternatives among the sibling tools. The payment requirement is a usage condition but is not framed as a selection criterion.

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 the description reinforces this with 'Does not spend money.' It adds useful behavioral context beyond annotations: the unclaimed vs claimed response shape, payment/HTTP 402 paths, payTo/noSelfPay/TTL, and the free GET endpoints for alternative flows. This goes well beyond a bare read-only hint, though some details remain cryptic.

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 and every clause carries information, but the structure is a run-on telegraphic block with cryptic abbreviations ('payTo + noSelfPay + TTL 30d', 'how/next') and no logical breakdown. It is concise in length but not well-structured for quick agent consumption.

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?

There is no output schema, so the description carries the burden of explaining return values; it does describe the key fields for both unset/unclaimed (taken false, how/next, payment details) and set (origin, ownerHint?, expiresAt) cases. It also covers cost and access alternatives. It leaves some details ambiguous (e.g., exact format of origin, ownerHint?), but for a simple lookup tool it is reasonably complete.

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

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

Schema description coverage is 100%, with both 'n' and 'name' already documented in the input schema. The description repeats the lowercase [a-z0-9-] 3-32 constraint and mentions 'n=' but adds no new semantic meaning beyond what the schema already 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 identifies the tool as a free ENS-style agent name lookup, with a specific verb and resource ('name lookup'). It is clear in function, but it does not explicitly distinguish itself from sibling tools like name_register, ens, or find, instead only noting that REST GET /name is the same SKU.

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 read-only lookups ('FREE', 'Does not spend money') and explains behavior for unset vs set names, but it never explicitly states when to use this tool vs alternatives, nor does it mention exclusion criteria or related tools. There is no guidance about when not to use it or under what circumstances a sibling would be more appropriate.

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 annotations, the description adds substantial behavioral context: exact $0.05 USDC payment on Base, 30-day duration, HTTP 402 origin verification, the payTo address, and the overwrite/extension side effect on re-registration. This is strong disclosure for a mutating paid tool.

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

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

The entry is compact and front-loaded, packing payment, duration, verification, side effects, and payTo into a few short sentences with no filler. The REST POST equivalence at the end is somewhat cryptic, but the overall structure is efficient.

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

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

For a paid mutation with no output schema, the description covers price, destination, duration, verification, and side effects. However, the payment flow is ambiguous: it doesn't clarify whether the tool charges automatically or whether the caller must send USDC separately, and it doesn't mention using name_lookup to check existing names before registering.

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 all parameters. The description adds meaningful semantics for name by explaining that re-registration overwrites or extends, and for origin by requiring https and HTTP 402, though ownerHint receives no extra explanation 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 a specific action and resource: register or extend an ENS-style agent name for 30 days, with an exact price. This clearly distinguishes it from read-only siblings like name_lookup, though it never names that alternative explicitly.

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

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

The description makes the payment and verification requirements clear, and implies use when a paid 30-day name registration or extension is desired. It provides no explicit when-not-to-use guidance or pointer to name_lookup for checking existing names, so sibling routing is left mostly to inference.

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

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

Annotations declare readOnlyHint=true, but the description adds a critical behavioral trait: the operation costs $0.01 USDC and specifies a payment address. It also discloses it's an alias to REST endpoints, providing 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?

Extremely compact yet packed with essential information: cost, formats, alias, alternative tool, and payTo address. The critical cost caveat is front-loaded, and there is no wasted phrasing.

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 tool with no output schema, the description covers every requirement: behavior, timezone, formats, cost, and routing to the correct sibling. Nothing an agent needs is missing.

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

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

With zero parameters, the baseline is 4. The description confirms 'No params' matches the schema, satisfying the requirement without needing extra detail.

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

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

States a specific verb ('UTC clock') and clearly lists output formats (unix, ms, iso). Explicitly differentiates from sibling 'tz' for IANA zones, making its purpose unmistakable.

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 tells the agent when not to use it ('For IANA zones use tool tz') and clarifies it has no parameters. The alias note ('REST GET /now and /time') adds implementation context, giving a complete usage picture.

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 goes well beyond annotations by disclosing the $0.01 USDC cost on Base, the payTo address, the paid 200 response with found:false for unknown entries, and boundaries like no trading/not investment advice. These are important behavioral traits not available from readOnlyHint/openWorldHint alone.

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 information-dense and front-loaded with cost and purpose, with no real wasted words. The run-on punctuation makes it slightly harder to parse than a structured list, but every clause serves a functional role.

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

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

For a tool with no output schema, it covers cost, payment address, parameter selection, unknown-result behavior, and read-only status. The main gap is that it does not describe the success response structure beyond 'market odds', which an agent might need for parsing.

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 q, slug, and limit. The description restates the 'not both' constraint and limit range, which reinforces correct usage but adds little new semantic detail beyond the schema.

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

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

The description clearly identifies a paid Polymarket odds lookup via gamma-api and distinguishes it from generic quote/price siblings. However, it lacks an explicit verb like 'get' or 'return', so the core action is implied rather than directly stated.

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 gives clear invocation context: use q or slug, not both, optional limit, and read-only/no-trading. It does not mention alternatives or conditions for choosing a sibling tool, leaving some usage guidance implicit.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the baseline burden is lower. The description adds substantial extra context: a $0.01 USDC payment requirement, a payTo address, ~45s caching, and a disclaimer. There is no direct contradiction with the read-only annotation, since the payment appears to be a prerequisite rather than a mutation performed by the tool itself.

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 packs many distinct facts—payment, purpose, defaults, aliases, token format, cache, disclaimer, payTo—into a few dense sentences. It is compact and mostly front-loaded, though leading with the payment detail before the actual purpose may misdirect an agent. 'Not investment advice' is boilerplate but not severely wasteful.

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

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

For a paid, two-parameter tool with no output schema, the description covers purpose, default values, aliases, cache behavior, and payTo address. It does not describe the output shape of a quote, how payment is verified or executed, or resolve the 'max 8' ambiguity. Thus it is adequate but leaves meaningful gaps for correct 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?

With 100% schema description coverage, baseline is 3. The description adds value beyond the schema by enumerating accepted alias symbols (ETH, USDC, BTC, SOL, WETH, LINK, AAVE, UNI, DAI) and clarifying that token is a Base 0x address. However, the phrase 'max 8' is ambiguous—it could apply to ids, token, or both—which slightly weakens the clarity.

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

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

The description states 'spot USD quotes via public DeFiLlama,' giving a specific verb and resource scope. Default ids and accepted aliases further clarify what the tool prices. However, the leading 'Paid $0.01 USDC exact on Base' muddies the core purpose by foregrounding a payment prerequisite before the actual function, so it is clear but not maximally sharp.

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 useful parameter-level usage guidance: default ids, allowed aliases, and token address form. It does not explicitly say when to prefer this tool over siblings like quote or fx, nor does it state when-not-to-use it. Usage is implied through 'spot USD quotes via public DeFiLlama' but not made explicit.

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

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

Annotations declare readOnlyHint=true, but the description says the tool is 'Paid' and provides an explicit payTo address, implying a financial/blockchain side effect. This contradicts the read-only annotation. The description adds the cost and payment address but contradicts the safety profile, so it must be flagged.

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

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

The description is compact and front-loads the most operationally important fact, the payment requirement, before listing asset classes and examples. The disclaimer is slightly extraneous and there are minor typos, but the overall structure is efficient.

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

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

Even though the tool has only one parameter, the description leaves crucial operational gaps: it does not explain how the payment is executed, whether payment must happen before the call, or what the return value looks like. Since there is no output schema, the missing return-format information is a significant incompleteness.

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

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

Schema description coverage is 100%, so the schema already documents the symbol parameter fully. The description's examples duplicate the schema examples rather than adding new semantics such as format rules, case sensitivity, or validation constraints. Baseline 3 applies.

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

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

The description states that this tool returns quotes for equity, index, FX, and crypto symbols using Yahoo Finance, with concrete examples (AAPL, ^GSPC, EURUSD=X, BTC-USD). It clearly identifies a resource and a specific action, though the differentiation from the complementary sibling tools /price and /fx is only hinted at rather than spelled out.

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

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

The phrase 'Complements /price /fx' indicates related alternatives but gives no explicit condition for choosing quote over /price or /fx. The asset-class list implies when the tool might be useful, but the description does not provide clear when-to-use 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?

Annotations provide readOnlyHint and openWorldHint, but the description adds critical behavioral context beyond them: it is a paid tool costing $0.01 USDC exact on Base with a payTo address, it follows redirects up to 8 hops, is SSRF-safe, does not handle meta-refresh, and sends no payment headers. This fully discloses side effects and limitations.

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 and front-loaded with the most important operational fact (cost), followed by what it does, constraints, return values, and exclusions. Every sentence conveys necessary information, though the telegraphic style and payment address make it slightly less polished.

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, read-only tool with no output schema, the description is complete: it explains what is returned (chain, finalUrl, hopCount), the cost, the safety properties, and the exclusions. An agent has enough information to call it correctly and interpret the result.

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

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

Schema description coverage is 100%, and the description repeats the schema's 'Public http(s) URL' wording without adding new parameter-level detail. It adds tool-level constraints like SSRF-safe and max hops, but not more about the url parameter itself, so baseline 3 is appropriate.

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

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

The description states a specific verb ('follow Location redirects') and resource ('a public http(s) URL'), and it clearly distinguishes itself from siblings by noting 'Not /headers' and 'No meta-refresh'. An agent can understand exactly what the tool does and that it is not the headers tool.

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

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

The description gives clear usage constraints: manual, max 8 hops, SSRF-safe, public URL, and payment required. It explicitly disambiguates from the headers sibling with 'Not /headers', but it does not proactively say 'use headers tool if you need headers' or list other exclusion conditions. Most needed context is present.

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

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

Annotations declare readOnlyHint=true, but the description starts with 'Paid $0.05 USDC exact on Base', which could be misinterpreted as a cost or payment action by the tool. It does not clarify whether this is a fee, a report detail, or something else, and the schema's 'No payment headers are sent' is helpful but not in the description.

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

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

The description is a single dense, cryptic sentence packed with technicalities ('well-known payTo match', 'header vs body 402', 'bytecode snippet hash') and odd phrases ('REST GET /report is the same SKU'). It is not concise or well-structured for quick comprehension.

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

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

With only one parameter and no output schema, the description must explain what the report contains and how it behaves. It fails to clarify the report's format, the meaning of 'honesty', or what the user should expect, making it incomplete for correct 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?

The schema description for 'url' is clear and covers 100% of the parameter, so the baseline is 3. The tool description adds no additional parameter-level meaning beyond what the schema already provides.

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 suggests the tool produces a 'structured honesty report' about a 402 response, listing specific elements like payTo match and bytecode hash. However, it is cryptic and does not clearly state what the tool does with the URL, relying on jargon and unexplained details.

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

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

There is no explicit guidance on when to use this tool versus alternatives like 'check' or 'headers'. The mention of 'for this 402' implies it is for 402-related inspections, but this is not stated as a clear directive or contrasted with 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?

Exceeds the annotations by disclosing 'Paid $0.01 USDC', 'Fail closed' failure handling, 'Not legal advice' limitation, and the payTo address. The description proactively discloses important behavioral and commercial traits that annotations don't cover, with no contradictions.

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

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

Two compact sentences deliver cost, purpose, address formats, error behavior, and a legal disclaimer without unnecessary words. Every element earns its place, effectively front-loading the most critical information (the fee).

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

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

For a tool with no output schema, the description fails to specify the return value or response format, which is a major gap for an agent to use the result. While 'Fail closed' provides some clue about error behavior, a complete tool contract would state what the success response looks like (e.g., boolean or structured result).

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

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

The schema already describes the single parameter with 100% coverage, including the address format. The tool description echoes this information but adds no premium semantic content beyond that, conforming to the baseline-3 expectation.

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 a sanctions screening tool for crypto addresses on OFSD SDN, mentioning specific address formats ('EVM 0x or Solana/base58'). It stands out from sibling tools by explaining the exact service and payment, making the purpose unambiguous.

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

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

Provides clear usage context by stating the cost ($0.01 USDC), the network (Base), and the supported address types. However, it does not explicitly mention when not to use it or name any alternative tools, so it falls short of a 5.

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

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

The description discloses the exact cost ($0.01 USDC on Base), the payTo address, the fallback service, and the behavior for unknown selectors (paid 200 with found:false). These details go far beyond what annotations (readOnlyHint, openWorldHint) convey and are critical for a paid lookup tool. 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 packs payment, purpose, syntax, edge case, sibling relationship, and limitation into one dense but non-redundant run-on. Everything present is useful, though structure could be improved for readability. Appropriate size for a simple tool.

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 no output schema, so the description carries the burden of explaining behavior. It covers cost, failure semantics, and limitations, but does not state what a successful result looks like for a known selector. Good but not fully complete regarding return payload.

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

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

Schema already covers hex with first-4-bytes semantics, so baseline is 3. The description adds that hex= / selector= / data= are accepted key variants, which supplements the schema's single name. This is useful but slightly ambiguous; still, it adds 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?

Description explicitly states '4-byte function selector lookup via public openchain.xyz (4byte.directory fallback)' – a specific verb and resource pair. It also distinguishes itself from a full ABI decoder and positions itself relative to /tx, making it easy to tell apart 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?

The description contrasts with /tx by noting it 'Complements /tx (inputLen only)' and explicitly says 'Not a full ABI decoder', which tells an agent when not to use it. However, it does not enumerate specific use cases or alternative sibling tools beyond these two mentions. Clear enough but slightly implicit.

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

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

Annotations already mark the tool as read-only and open-world, and the description builds on that by disclosing the exact cost ('Paid $0.01 USDC exact on Base'), the payTo address, and that it uses a public API. This adds meaningful operational context beyond the annotations without contradicting them.

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

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

The description is compact and nearly every clause carries useful information, including payment, required mode, parameter options, and scope. It is only slightly dense because payment details appear before the core purpose, but the overall size is appropriate and there is no filler.

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

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

For an agent deciding whether and how to invoke this tool, the description covers the key requirements: query mode, optional parameters, valid sort values, result count limits, scope, and cost. The main gap is that there is no output schema and the description does not indicate what the response object will look like, though that may be inferable from the Stack Exchange API 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?

Although the schema already documents all five parameters, the description enriches them with actionable semantics: q is conditionally required, id is an alternative, sort has explicit allowed values, hits is bounded to 1..8 with a default, and tagged is limited to three comma-separated tags. That is substantial value beyond the raw 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 a specific action and resource: 'Stack Overflow Q&A search via public Stack Exchange API.' It also distinguishes itself from similar tools with 'Stack Overflow only' and 'Complements /hn and /arxiv,' so an agent can tell when this tool, rather than a sibling, is relevant.

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

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

It gives practical invocation guidance: q is required unless id is used, sort and hits have valid ranges, and tagged is limited. The phrase 'Stack Overflow only' provides a boundary, and naming /hn and /arxiv as complements points toward alternatives. However, it does not explicitly state when not to use this tool beyond that boundary.

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

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

The description discloses meaningful behavioral details beyond annotations: it is a paid call ($0.01 USDC), uses public CT logs and a live HTTPS HEAD request, and returns specific fields. It also clarifies this is a read-only fact-gathering operation, consistent with readOnlyHint.

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

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

The description is compact and front-loaded with the most essential facts: cost, purpose, and returned fields. It is slightly dense with the payment address and multiple clauses, but every sentence carries useful 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 a single parameter, no output schema, and read-only annotation, the description covers the core knowledge an agent needs: what it does, what it returns, its scope limits, and its cost. It could be more complete by stating error cases or SLA details, but those are not critical for a simple single-host lookup.

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

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

Schema coverage is 100%, and the host parameter is already described as a public DNS hostname, not a URL or IP. The description reinforces that it applies to a public hostname but does not add new parameter-level detail beyond the schema.

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

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

Description clearly states the tool's function: TLS certificate facts for a public hostname, including a concrete list of returned fields. It differentiates itself from the sibling /domain dossier by explicitly saying it is not the full dossier, making the purpose unmistakable.

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 gives good context: use for lightweight TLS cert facts on a public hostname, not for a full domain dossier. It names the boundary with the domain tool implicitly, though it does not explicitly say 'use domain instead for full details'.

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=true and openWorldHint=true, but the description adds critical behavior: the tool is paid ($0.01 USDC) and returns a 200 with found:false for EOA/empty code. It also discloses the payment address and that it uses public RPC. This goes beyond annotations, providing cost, error handling, and network context 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 a single, dense sentence but every clause serves a purpose: purpose, cost, network, invalid-address behavior, exclusions, and payment. It is front-loaded with the core purpose and avoids redundancy. It could be split for readability, but remains concise and 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 no output schema, the description successfully conveys the return content (name, symbol, decimals, totalSupply) and the invalid-address case. It also covers cost and payment details. Missing are specifics on response format (e.g., JSON structure) and any rate limits, but these are not critical for a simple metadata fetch tool; the description is sufficiently complete for correct 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?

The schema covers the parameter fully with a description of '0x-prefixed 20-byte ERC-20 contract address on Base'. The tool description reinforces that 'address= required' and notes behavioral nuance: EOA/empty code returns found:false. This adds value by explaining how the parameter affects the response, which schema alone does not convey.

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

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

The description clearly states the tool fetches ERC-20 metadata (name, symbol, decimals, totalSupply) for a given address on Base via public RPC. It also explicitly excludes spot price and wallet balance, directly distinguishing from siblings 'price' and 'who'. The verb-resource pairing is unambiguous.

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

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

The description provides explicit exclusions: 'Not a spot price (use /price)' and 'Not a wallet balance (use /who)', which directs agents to appropriate alternatives. It also states the required parameter 'address'. While it doesn't elaborate on when to use this tool positively, the negative guidance is strong and covers the main alternative scenarios.

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

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

Beyond readOnlyHint and openWorldHint, the description discloses a $0.01 USDC cost, the exact payTo address, the external data sources used, and limitations such as 'not a full audit.' The word 'Paid' at the start is slightly ambiguous about whether the tool itself transfers funds, but the payment requirement is still materially transparent.

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

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

The description is compact and front-loads the most unusual fact (the payment), then states purpose, parameters, and limitations. Every sentence carries relevant information with no filler, though the opening phrase could be reordered for clarity.

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 only two parameters, no output schema, and annotations already covering safety, the description provides enough to select and invoke the tool correctly: address, chain options, default, payment details, and source. The exact return shape is not specified, but 'token security snapshot' plus the named data sources gives reasonable expectations.

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

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

Schema description coverage is 100%, so the schema already documents address and chain well. The description mostly restates the format and default chain, adding little beyond what structured parameter descriptions already provide. This meets the baseline but does not add 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 identifies a token security snapshot produced via public honeypot.is and DexScreener, which distinguishes it from generic token/price lookups. However, it lacks an explicit verb like 'returns' and does not directly contrast with sibling tools such as token or dex, so it stops just short of a 5.

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

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

It gives concrete invocation requirements: a 0x address is required, chain can be base/eth/bsc with base as default, and the call is paid. It also sets expectations by saying this is not a full audit and not investment advice. It does not name alternative tools for when a fuller audit is needed, but the context is still 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 and openWorldHint, so the bar is lower. The description adds meaningful behavior: payment amount and payTo address, unknown-hash handling (found:false), response key list, and an explicit exclusion of mempool tips. The phrasing 'paid 200' is ambiguous but does not contradict 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 short and packs many facts, which is good, but it is fragmented and front-loads payment details before the core action. Phrases like 'paid 200' and 'inputLen only' are jarring and would be clearer with minimal restructuring. It is concise but not well structured.

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

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

There is no output schema, so the description compensates by listing expected fields and unknown-hash behavior, which is helpful. However, key details are underspecified: what 'paid 200' means, how the payment is collected, and what 'inputLen only' implies for the result. For a one-parameter tool this is adequate but not complete.

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

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

Schema coverage is 100%: the schema already documents hash as a 0x-prefixed 32-byte Base transaction hash. The description adds little parameter-level meaning beyond restating '0x hash' and mentioning 'inputLen only', which is not clearly tied to the hash parameter. 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 identifies a specific operation: transaction + receipt lookup for a 0x hash on Base, and lists the returned fields. This is distinguishable from siblings like block or token. However, the opening 'Paid $0.01 USDC exact' frames the tool in an unusual way and no sibling is named, so it is not perfectly crisp.

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

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

There is no explicit guidance on when to use this tool versus alternatives. 'Not a mempool tip' is a negative filter but does not direct the agent to another tool, and 'inputLen only' is cryptic. The agent is left to infer selection criteria from the tool name alone.

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

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

The description discloses a critical behavior not in annotations: a $0.01 USDC payment requirement and a payTo address. It also notes the absence of API keys and specifies the return values. This adds substantial context beyond the readOnlyHint 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 short but poorly organized: it leads with the payment, then describes functionality, and ends with a long wallet address. Each sentence contains information, but the fragmented structure and raw address reduce readability.

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?

Without an output schema, the description does mention return values (now, UTC offset, DST), which is helpful. However, it omits error handling, input validation, and the exact payment flow, leaving the paid nature of the tool underspecified.

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

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

The schema already fully documents the 'name' parameter with a description and default. The tool description merely repeats the default (America/Denver) and adds no new semantic information, so it provides no 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 is an 'IANA timezone clock' that 'Returns now, UTC offset, DST', giving a specific verb and output. It is distinct from sibling tools like bizdays or check, though the payment note adds noise.

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 guidance is provided on when to use this tool versus alternatives or any exclusions. The only usage hint is the default timezone, implying the parameter is optional, but no context is given for selecting this over 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 and openWorldHint, and the description adds meaningful behavioral context by mentioning a specific payment requirement and recipient. However, the phrasing 'Paid $0.01 USDC exact on Base' is ambiguous about whether payment is required beforehand, who pays, or how the payment mechanism works.

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, packing the returned fields and a payment recipient into two short sentences. However, the most important functional content is not front-loaded; the payment clause appears first, making the structure slightly awkward for an agent scanning for 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?

For a one-parameter tool with no output schema, the description usefully lists the four returned data points (isContract, ETH balance, USDC balance, tx count). Still, it lacks clarity on the payment prerequisite and invocation flow, and provides no response shape or broader usage context, so it is only minimally complete.

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

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

The schema already provides 100% coverage for the single address parameter, including format and chain details. The description merely repeats 'for an address' and does not add new parameter-level constraints, defaults, or edge cases beyond what the schema documents.

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 the tool returns on-chain metrics for an address (isContract, ETH balance, USDC balance, tx count), which is more specific than the bare name 'who' and distinguishes it from sibling tools like sanctions or domain. It lacks an explicit verb such as 'returns' and buries the core purpose behind a payment clause, but the functional intent is still clear.

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

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

There is no guidance on when to use this tool versus alternatives such as check, email, or sanctions. The description simply says 'for an address' with no conditions, exclusions, prerequisites, or mention of alternative tools, leaving the agent to infer appropriate usage.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses a real cost ('Paid $0.01 USDC exact on Base'), the payment destination, the external source APIs, the output restriction to lead extracts, and the CC BY-SA license. These are meaningful behavioral disclosures that help the agent understand side effects, licensing, and external dependencies.

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 and packs payment, purpose, parameters, output scope, and licensing into one compact block with no filler. It is appropriately front-loaded with the cost constraint, but the telegraphic run-on style makes parsing slightly harder than necessary.

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

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

Given there is no output schema, the description does a good job of characterizing what is returned ('Lead extract only') and covers cost, input modes, URL handling, language options, and result count. It is missing explicit response-shape details and payment mechanics, but an agent has enough context to 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?

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by providing aliases (query=, search=, page=), clarifying the q-or-title relationship, and noting that wikipedia.org URLs are accepted. This is useful extra semantic information, though the schema already documents most 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 names the resource and behavior: 'Wikipedia lead summary via public Wikimedia REST + MediaWiki search.' It also distinguishes the two invocation modes, q= for search and title= for direct pages, so an agent can tell exactly what this tool does among unrelated 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 gives explicit usage context for selecting the right input mode: 'q= search or title= page title (wikipedia.org URLs ok).' It also states a key limitation, 'Lead extract only', which implies when this tool is and is not appropriate. It does not explicitly name alternative tools or provide when-not-to-use guidance, so it falls short of a 5.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses important behavioral facts: the exact payment amount, the network (Base), the payTo address, and the attribution requirement. It also names the underlying public data source (Open-Meteo), giving the agent a clear picture of side effects and obligations.

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 compact and front-loaded: payment, purpose, location syntax, units, attribution, related tools, and payment address all appear in a few short phrases. Every clause adds information; there is 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?

For a simple read-only weather tool, the description covers the essentials: how to pay, where to send payment, how to specify location, and the units. The main gap is that it does not describe the return shape or what happens if neither q nor lat/lon is supplied, though both are inferable.

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 covers all four parameters at 100% coverage. The description adds useful meaning by clarifying the relationship between q, lat, and lon ('and/or') and reiterating the units choices (metric|us). This goes slightly beyond the schema's individual descriptions.

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

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

The description clearly states the resource ('current weather via public Open-Meteo') and the input patterns ('q= place and/or lat=&lon='). 'wx' is uniquely identifiable among the sibling tools as a weather lookup, and the phrase 'Complements /geo /tz' further orients it relative to nearby 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 gives clear invocation context: how to specify a location, the optional units, and the payment/attribution requirements. It names related sibling tools (/geo /tz) but does not explicitly state when to prefer wx over them or when not to use it, so it stops short of a 5.

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