UseTested — Receipts-Verified Service Reviews

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

Annotations cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), and the description goes well beyond them: it names the payment rail (x402, USDC on Base), that payment is automatic, and the post-settlement effects (status set to paid, tx stored, request queued). That is exactly the behavioral context an agent needs before invoking a paid mutation.

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 tight sentences: the action and payment path lead, the outcome follows, and the required inputs are called out last. No filler and nothing is buried.

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 tool with full annotation coverage, complete parameter docs and an output schema, the description supplies the one thing structured data cannot: the payment flow and settlement side effects. Nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3; the description only restates that the inputs are the exact service_name and quote_total_usd from the quote, adding the minor nuance that they must match the quote exactly. It does not add format or validation 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?

States a specific verb+resource (accept the re-test quote) plus the payment mechanism (x402/USDC on Base) and the resulting state change. It is clearly distinguishable from the sibling request_retest that produces the quote it consumes.

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 establishes the precondition clearly: the service_name and quote_total_usd must come from a prior request_retest quote, and payment happens automatically via the caller's x402 MCP client. It does not state when-not to use it (e.g., expired quote handling or insufficient balance), so no explicit exclusions.

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

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

Beyond the readOnly/idempotent annotations, it discloses the paid x402 flow ($0.05 USDC on Base, auto-charged by the client), the absence of paging, the inclusion/exclusion rule (AVOID/UNTESTED/DEAD never included) and the evidence-depth threshold of 20 settled calls. That is a lot of decision-relevant behavior the annotations alone don't 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?

Front-loaded with the result shape, then constraints, then cost — good ordering with no filler sentences. The scoring formula is dense but it explains how to interpret the ranking, so it earns its space, though it could be trimmed slightly.

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

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

Output schema covers return values, and the description covers cost, ranking, inclusion criteria and the no-paging constraint. Nothing an agent needs to call this correctly or anticipate charges is missing.

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

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

Schema coverage is 100% with an enum and its own description, so the single parameter is fully documented in the schema. The description repeats the enum values, adding emphasis rather than meaning, so the baseline of 3 applies.

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

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

A specific verb and resource ('top 10 ... services in a category') identifies both what is returned and the exact result set size, plus a concrete ranking basis (verdict tier + liveness-weighted reliability). It's clearly distinguishable from the catalogue-wide siblings like get_catalog and search_services.

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

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

The description clearly signals when NOT to use it: 'there is no paging' and 'this is a best-of list, not the whole catalogue', which implies the catalogue tools. It stops short of naming get_catalog or search_services as the alternative, so the routing is inferred rather than 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 already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely new behavior: the $2 charge, the x402/USDC-on-Base payment path, automatic payment by the client, and the fact that the snapshot is not historical but current-day only with re-fetch required. It does not mention catalogue size limits or response weight, which matters for a full-corpus call.

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, front-loaded with the scope ('the ENTIRE ... catalogue') before the commercial and freshness details. Every clause carries information: scope, format, freshness, cost, and payment mechanism.

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

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

An output schema exists, so return-value shape need not be described. For a zero-parameter paid read tool, the definition covers cost, payment flow, freshness, and resulting format, which is everything an agent needs before invoking it.

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

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

Zero parameters, so the baseline of 4 applies; there is no argument syntax for the description to explain. The only semantic worth noting, the absence of any filter or date argument, is implicitly conveyed by 'ENTIRE ... today's data only'.

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 resource (the full published UseTested catalogue of receipts-verified reviews) and a specific output form (one JSON snapshot), with 'ENTIRE' signaling it is the whole-corpus counterpart to get_review and search_services. It does not explicitly say how it differs from the closest sibling, get_bundle, leaving that one relationship to inference.

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 implies usage context (want everything in one call, cheaper than scraping) and gives a freshness rule ('today's data only; re-fetch for updates'). It never states when to prefer get_bundle, search_services, or get_review instead, so routing between siblings is left implied rather than instructed.

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 read-only, idempotent, closed-world behavior, so the description earns credit for adding domain semantics: the BUY/CAUTION/AVOID verdict taxonomy, the meaning of INTERIM ('single verified result, pending deep review'), and the zero-cost claim. It doesn't say what happens when a service has no review yet, which is the main unaddressed 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?

One sentence with the core purpose front-loaded, followed by the enumerated contents and a one-word cost note. Every clause carries information and nothing is redundant.

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

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

With an output schema, annotations, and a fully documented parameter, the only real gap is the not-found/no-review-yet case and how this differs from request_review. The INTERIM definition is the kind of context an agent genuinely needs and would otherwise lack.

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 single 'service' parameter is already documented as an exact name from search_services, so the description adds nothing parameter-specific. Baseline 3 applies when the schema does the work.

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

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

States a specific verb and resource ('Full receipts-verified review of one agent-economy service') and enumerates the payload: verdict, scores, latency/error rate, on-chain receipts. It doesn't name a sibling, but 'of one service' implicitly contrasts with the listing tool search_services.

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 only implied: you call this to inspect a specific service's verdict before acting. 'Free' signals cost, but there is no explicit when-to-use-vs-alternatives guidance (e.g. search_services to discover names, request_review to create a review).

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?

Goes well beyond the annotations: discloses a $0.005 x402 payment in USDC on Base, that the settlement receipt becomes the claim's proof, the 24h rate limit, and the decay timeline (ALIVE → LIKELY ALIVE → UNTESTED after 14 days). None of that is derivable from readOnlyHint/idempotentHint 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?

Purpose is front-loaded in the first clause and every sentence carries substantive information (cost, proof, cadence, decay, override, inputs). It is dense but not padded; a slight restructuring into shorter sentences would improve scannability.

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

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

With an output schema present and annotations covering safety and idempotency, the description fills the remaining gaps an agent needs: payment mechanics, rate limit, status lifecycle and precedence rules.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds value by saying 'exact service name (from search_services, free)' and reinforcing that status must be LIVE, which clarifies provenance and the constraint's intent.

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

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

States a specific verb and resource ('self-report your endpoint as LIVE') plus the audience ('for service providers'), which cleanly separates it from siblings like search_services, request_review or accept_retest_quote.

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 context: providers report their own service, one report per 24h, and UseTested's own sweep results override self-reports so the agent knows when this is not authoritative. It also points to search_services for obtaining the exact name. It stops short of explicitly naming competing siblings as alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, and the description reinforces this by stating the call is free and returns only a quote. It adds valuable context beyond the annotations: the exact pricing formula ($1.00 rubric fee + per-call price x 20) and the directory-existence prerequisite. It does not say whether the quote expires or is locked to the current price, which is the only material gap.

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

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

Front-loaded with the purpose and cost model, then the next step and prerequisite. Every sentence carries operational information — the free/paid distinction and the pricing formula in particular prevent costly misuse.

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

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

Output schema exists, so return values need no prose, yet the description still tells the agent the response is an exact total broken into components. Prerequisites, cost, and the follow-up tool are all covered for a two-parameter tool in a priced workflow.

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, but the description adds a real constraint beyond the schema: the service must exist in the directory and the name must be exact, as surfaced by search_services. The reason parameter is left entirely to the schema, which documents it adequately.

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

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

States a specific verb (get an upfront quote) and resource (re-test of an already-reviewed service), and names the sibling it must not be confused with (accept_retest_quote vs. this free quote step). The e.g. clause makes clear it applies only to services already reviewed, distinguishing it from request_review.

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?

Explicit triggers are given (quality changed, review stale, measured numbers no longer match), plus the prerequisite path: find the exact name via search_services, then pay via accept_retest_quote. The agent knows both the entry condition and the next step without inference.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false and openWorldHint=false. The description adds genuinely useful behavior beyond that: the request is queued for consideration, requests influence prioritisation, and there is no SLA or guaranteed verdict — an asymmetric, non-guaranteed outcome an agent should know about.

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?

Four tight sentences, front-loaded with the core action, followed by cost, behavior, and the key caveat. The standalone 'Free.' earns its place and every sentence carries distinct 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?

An output schema exists, so return values need not be explained. The description covers cost, queueing behavior, and the no-guarantee caveat, which is what an agent needs before calling. The only gap is not pointing at request_retest for services that already have a review.

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 four parameters are already documented in the schema, and the description adds no per-parameter syntax or format detail. It does narrow the domain ('x402 endpoint, MCP server, AI API'), which gives some meaning to service_name/service_url, but that is marginal over the schema 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?

States a specific verb and resource ('Request that UseTested buy and test an agent-economy service') plus the scope qualifier 'we haven't reviewed yet', which functionally distinguishes it from request_retest. It stops short of naming the sibling it excludes, so the routing is implied rather than explicit.

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 by 'we haven't reviewed yet', but there is no explicit when-to-use/when-not guidance and no named alternative (e.g. request_retest for already-covered services). 'Free' and 'No SLA or guaranteed verdict' set expectations for the outcome rather than telling the agent when to pick this tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds genuinely useful non-annotation context: it is free (no cost/auth barrier) and returns verdict, scores, price per call, and measured latency. It does not discuss pagination or result caps, but with an output schema present that is minor.

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?

Four short sentences, zero waste, with the core purpose front-loaded. Each sentence adds a distinct piece of information (what, cost, what it returns, where to use it next) rather than restating the title.

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-required-parameter read-only search tool with a full output schema, the description covers everything an agent needs: scope, cost, return shape, and the workflow handoff to get_review. Return-value detail is legitimately delegated to the output schema.

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

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

Schema description coverage is 100% with all three parameters (q, limit, category) documented and an enum on category, so the schema carries parameter meaning fully. The description adds no syntax or format guidance beyond what the schema provides, making the baseline 3 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?

States a specific verb (Search) and resource (independently-tested directory of agent-payable services), and scopes it concretely with the examples x402 endpoints, MCP servers, AI APIs. It also routes clearly away from ambiguity by naming get_review as the downstream sibling, so an agent can place it in the workflow without opening any schema.

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 what it is for: 'find the exact `service` name for get_review,' which gives the agent a clear trigger. It stops short of stating when NOT to use it or naming alternative discovery siblings (e.g. get_bundle), so it is clear context rather than full when/when-not routing.

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