Anyway Possible Paid Agent Utilities

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

Annotations already mark readOnlyHint and destructiveHint false, but the description adds useful behavioral context: it reads three data points (ETH, USDC, and block height, indicating it fetches a snapshot of current on-chain state). This enriches the definition without contradicting 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?

A single sentence with zero fluff. It front-loads the core verb (Read) and lists resources directly. Every word contributes to clarifying what part and what data is involved.

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

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

Given that the tool presumably has an output schema (present) and safety-related annotations, the description sufficiently covers selection and invocation context. It does not mention a possible usage fee hinted by the title, but it is not a functional block for a light read filter. The coverage of block height indicates awareness of the important state context.

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

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

The only parameter, address, has 100% schema coverage including pattern and description, so the tool description adds no new semantics beyond what is already in the schema. Baseline 3 applies because the schema already fully documents the input.

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

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

Clearly identifies the operation with specific verb 'Read' and states exact resources: native ETH, Circle USDC balances, and current block height for a Base wallet. This is unambiguously distinct from its siblings, which all stay in URL/merchant/payment domains.

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

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

The description implies use when you need Base wallet balances, but it does not explicitly say when-to-use or provide when-not-to-use guidance. There are no obvious alternatives among siblings, so the absence of exclusions is acceptable, but the lack of explicit guidance leaves it at baseline.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the call is paid ($0.01 USDC), it handles partial failures with isolated results, and it is limited to public URLs. This goes beyond the schema and annotations, though it doesn't detail the exact response format for failures.

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, front-loaded sentence that conveys the core function, the limit, the paid nature, and the failure-handling behavior. No wasted words; every element earns its place.

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

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

Given the output schema exists and annotations cover safety, the description is largely complete. It could explicitly mention the sibling 'check_url' for single-URL use cases, but the batch context and paid-call warning are sufficient for an agent to invoke it correctly. The 'public URLs' constraint is a useful prerequisite.

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 both parameters well. The description adds the 'public' constraint and 'isolated results' context, but doesn't add significant meaning 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 the tool checks up to ten public URLs in one paid call, with a specific verb ('check'), resource ('URLs'), and scope ('up to ten', 'public'). It also distinguishes itself from a single-URL check by emphasizing the batch nature and isolated results for partial failures.

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

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

The description implies when to use this tool: when you need to check multiple URLs in one call, and it notes the paid nature. It doesn't explicitly name the sibling 'check_url' as the alternative for single-URL checks, but the batch context and 'isolated results' provide clear usage context. No explicit exclusions, but the guidance is adequate.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral value by disclosing that it checks reachability, latency, redirects, and content type—behavior not required by the schema. It does not mention that a fee applies, though the title signals '$0.001 USDC', which is a cost behavior not disclosed in the description body.

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?

One sentence, front-loaded with the verb and resource, and contains only the essential facts: what is checked (reachability, status, latency, redirects, content type) and when to use it ('before using it'). No filler, no redundancy with the schema. The title adds cost information separately, which is acceptable.

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 is simple (2 params, 1 required), has full schema coverage, and an output schema exists, so the description doesn't need to explain return values. The only notable gap is cost transparency: the title carries the '$0.001 USDC' fee, but the description itself omits any mention of the cost or any rate-limit implications. For a single-URL check with these annotations, 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?

Schema coverage is 100%, so the baseline is 3. The description adds minimal parameter-level meaning beyond the schema, but the 'before using it' framing implies the tool is a validation step and that the result matters for downstream decisions. It does not describe the format of expectedStatus matching beyond what the schema already states, so it only slightly exceeds the baseline.

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

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

Description uses a specific verb ('Check') with a clear resource ('one public URL') and enumerates concrete outputs (reachability, HTTP status, latency, redirects, content type). It also distinguishes itself from siblings like batch_check_urls by explicitly saying 'one public URL', which differentiates it from the batch variant.

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 'before using it' implies the intended use case is pre-flight validation of a URL. It does not explicitly name alternatives like batch_check_urls or verify_web_evidence, nor does it state when NOT to use it. However, the contextual phrasing and the sibling batch tool provide sufficient implied guidance for an agent to pick this for single-URL checks.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, but the description adds meaningful behavioral context: repeated runs produce score history and change alerts, and results are 'privacy-safe'. It also implies the tool accumulates historical data without contradicting the readOnly 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 two clear sentences, front-loading the core audit capabilities and then adding the historical behavior. Every word earns its place, with no redundant phrasing or unnecessary detail.

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

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

Given that an output schema exists and the input schema provides complete parameter descriptions, the description covers the essential operational aspects: what is audited and the repeatability behavior. The only notable gap is the lack of differentiation from merchant_snapshot, but that is more of a usage guideline concern, and the presence of the output schema completes the picture for calling correctly.

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

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

The schema description coverage is 100%, meaning all parameters (payTo, queries, excludePayers) are already described in the schema. The description only hints at the role of wallet and queries ('same wallet and queries') but adds no additional parameter semantics beyond what the schema provides, so the 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 'Audit' and enumerates the resources being audited: listings, semantic rank, competitor prices, payment reliability, buyer reach, and Base USDC activity. However, it does not differentiate itself from the sibling tool 'merchant_snapshot', which likely serves a similar purpose, so it falls 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?

The description implies usage for repeated audits by mentioning 'Repeated runs... return privacy-safe score history and change alerts', but it does not explicitly state when to use this tool versus alternatives like merchant_snapshot, nor does it list exclusions. The guidance is implicit rather than direct.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds context about the evaluation dimensions and output, but does not mention the $0.05 USDC cost (present in the title but not the description) or any computational/API side effects. It does not contradict annotations, so a 3 is acceptable given the low bar set by existing annotations.

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

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

The description is a single, well-structured sentence that front-loads the core action and outcome. It is concise with zero fluff, efficiently conveying the tool's scope and purpose.

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

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

Given an output schema exists (so return value details are covered), the description captures the essential scope: what is evaluated and what the tool produces. It omits the transactional cost (present in the title) but otherwise covers necessary context for calling the tool. Complexity is moderate, and the description is complete enough for an agent to know what to expect.

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

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

Schema description coverage is 100%, so all parameters (payTo, queries, excludePayers) are already well-documented in the schema. The description adds no extra semantic meaning beyond the schema, such as explaining how queries are used or the role of exclusion. This falls at the baseline 3, where the schema carries the burden.

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

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

The description clearly states the tool's purpose: scoring an x402 merchant across discovery, reliability, buyer signals, and Base USDC activity, then identifying the largest revenue issue. It uses specific verbs and a clear resource, and differentiates from siblings like merchant_audit and base_balance by focusing on a revenue-issue diagnosis.

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 no explicit guidance on when to use this tool versus alternatives. It implies a quick 'snapshot' but does not mention when to prefer merchant_audit or other siblings. Without stated exclusions or conditions, the agent must infer usage from the name and sole sentence.

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 that validation is live and covers the full set of checks, aligning with readOnlyHint and openWorldHint. It goes beyond the annotations by specifying what gets validated (challenge, price, network, asset, recipient, funding, gas, destination) and the intended moment of use. 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?

One tightly worded sentence front-loads the purpose and follows it with a compact list of validated dimensions. There is no filler or repetition; every clause earns its place.

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

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

With full schema coverage, a rich output schema, and annotations indicating a read-only open-world check, the description supplies the missing contextual essentials: when to call it and what it verifies. It could be slightly more explicit about the tool not performing the signing itself, but the readOnlyHint already covers that.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description's enumeration of checks reinforces how parameters map to safety concerns but adds little 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 names a specific action ('validate') applied to a live x402 payment challenge and enumerates the exact safety dimensions verified (price, Base network, USDC asset, recipient, funding, gas reserve, destination). It clearly identifies the tool as a pre-signing payment-safety guard, though it does not explicitly contrast itself with sibling tools such as treasury_preflight.

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 states a clear use condition: use 'immediately before signing' an agent payment, and scopes it to payment-safety validation. It does not name exclusions or alternative tools, but the timing and purpose provide enough context to select this tool for pre-signing checks.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a behavioral guarantee beyond these: 'never triggers payment or calls an external service', which is valuable for an agent deciding whether to invoke it in a constrained environment. It does not contradict annotations and enriches the safety profile.

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

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

Two sentences with zero fluff. The critical usage instruction ('free tool before paying') is front-loaded, followed by a compact summary of the output and a safety guarantee. Every sentence earns its place; no redundancy.

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

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

For a simple 2-param tool with a provided output schema and annotations covering safety, the description covers what the agent needs: the invocation context (free, non-payment, non-external), the expected output (best tool, price, inputs, alternatives, next step), and the scope of inputs. Nothing material is missing for an agent to call it effectively.

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 both params (goal and maxPriceUsd) are already documented in the schema. The description's mention of 'Describe the decision you need' aligns with the goal param but adds no new syntax or semantics beyond what the schema provides. Baseline 3 is appropriate when schema carries the descriptive burden.

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 purpose: to recommend the best tool based on a goal, with a clear verb ('receive') and resource (tool). It distinguishes itself from sibling tools by being a free preliminary step ('Use this free tool before paying'), making it clear it is a meta-tool, not a direct operation like checking balances or URLs.

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 advises usage 'before paying', indicating this is the first step in tool selection. It also clarifies that it never triggers payment or calls external services, but does not explicitly state when NOT to use it (e.g., if the user already knows the target tool) or name alternative selection mechanisms. Still, the context is clear enough for an agent to route appropriately.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds value by listing the specific checks performed, but does not disclose any additional behavioral nuances like potential latency or the fact that it makes external RPC calls. Given the annotation coverage, this is adequate but not rich.

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

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

The description is a single sentence that front-loads the action and lists the key checks without any redundancy or fluff. It is appropriately concise and 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?

Given the tool has an output schema (present per context signals), the description doesn't need to detail return values. It covers the purpose and the inputs well enough for an agent to decide when to call it. The absence of details about optional parameters is mitigated by the schema's thorough descriptions.

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 every parameter already has a clear explanation in the schema. The description's list of checks (funding, gas, etc.) roughly maps to the parameters, but it adds no extra semantic detail beyond what the schema already provides. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Check') and the resource ('Base wallet readiness'), and enumerates specific aspects (ETH and USDC funding, gas, chain intent, destination type, payment hazards). It distinguishes itself from simpler tools like base_balance by focusing on a pre-signing readiness assessment, though it doesn't explicitly name 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?

The phrase 'before signing' gives a clear temporal trigger for when to use this tool, but there is no explicit guidance on when not to use it or comparisons to sibling tools like payment_guard or base_balance. The usage context is implied rather than explicitly contrasted with alternatives.

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

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

Annotations already cover readOnlyHint=true and destructiveHint=false, and the description adds useful detail about redirects, content hashing, and a receipt. However, it does not disclose limits, timeouts, authentication needs, or the meaning of the cost/receipt behavior beyond what the title already signals.

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

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

The description is a single sentence that front-loads the core action and enumerates the returned artifacts without padding. Every phrase earns its place, and there is no redundant wording.

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

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

For a low-complexity, three-parameter tool with full schema documentation, an output schema, and read-only/non-destructive annotations, the description is mostly complete. The main missing piece is sibling differentiation, but an agent can still invoke it correctly using the schema and the clear artifact list.

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 each parameter is already documented in the schema, including URL format, expectedText length, and expectedStatus range. The tool description adds no parameter-level semantics beyond saying the URL must be public and singular.

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: verify one public URL and return a defined set of artifacts (timestamped status, redirects, metadata, content hash, receipt). It distinguishes itself from batch_check_urls through the singular 'one', but it does not explicitly differentiate itself from the similarly-named check_url, so it stops short of full sibling distinction.

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 wording 'one public URL' implies single-URL verification and therefore suggests it is not for batch checks, but there is no explicit when-to-use guidance and no mention of alternatives such as check_url or batch_check_urls. Usage context is only implied, not stated.

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