SiteCheck Shop & Social

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

With readOnlyHint and openWorldHint already covering the safety profile, the description adds genuinely non-redundant context: the upstream source is acehardware.com via a residential proxy, and billing is $0.02 USDC per successful call via x402 with failed calls not charged. It stops short of stating rate limits or per-page result caps relative to the 1-20 page range, which keeps it at 4 rather than 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?

Two sentences, front-loaded with what the tool does and followed by cost/access terms. The return-field enumeration is dense but each field is a distinct, useful signal; nothing is filler, though the list is long enough to be slightly scannability-heavy.

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 the field list is surplus rather than required, and all remaining agent needs (source, proxy, pagination size, cost model, failure billing) are covered. Only a note on rate limits or result freshness would add more.

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 both parameters are already documented, making 3 the baseline. The description earns one extra point by quantifying 'up to 30 products per page', which clarifies what a page step actually yields — information absent from 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 and resource ('Ace Hardware (US) product search') and pins the retailer domain, which is exactly what distinguishes it among dozens of ecommerce_* siblings. An agent can tell this is the Ace Hardware-specific search rather than a generic or other-retailer search without opening the 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?

Usage is implied by naming the retailer and the payload ('search words, e.g. cordless drill, paint roller' in the schema), so an agent can infer when this tool is the right one. However, it never states when NOT to use it, nor routes to a sibling (e.g. price comparison or other hardware retailers) for alternative needs.

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/openWorldHint annotations, the description discloses the pricing model ($0.002 USDC per successful call via x402 on Base/Solana/Arc), that failed calls are not charged, the pagination size (60 per page) plus total count, the region-driven language/currency behavior, and that the data is unofficial scraped page data subject to change. This is exactly the supplemental context annotations cannot 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?

Single dense paragraph, front-loaded with the resource and returned fields, followed by behavior and cost. Efficient overall, though the long enumeration of return fields partially duplicates the output schema and could be trimmed.

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 agent has everything needed to call it correctly: required search words, paging model with per-page size and total count, region/currency behavior, cost and payment rail, and a caveat about data reliability. The output schema handles return-value detail, so the description is complete for this tool's complexity.

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

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

Schema description coverage is 100% and the schema already documents both q (2-80 chars) and page (1-60, default 1). The description adds the region-follows-caller behavior and the guarantee that a currency code is always returned, but contributes little about the two parameters themselves. 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?

States a specific verb and resource — 'AliExpress product search from the public search page' — and enumerates what is returned (product ID, title, sale/original price, discount, rating, units sold, image, URL). The platform qualifier makes it reasonably distinguishable from the dozens of other ecommerce search siblings, though it does not explicitly name any of 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?

Usage is implied by the description (search AliExpress for products) but there is no explicit when-to-use vs when-not, no guidance on choosing it over sibling sources like Lazada or Trendyol, and no prerequisites mentioned. The 'unofficial page data, may change' note is a useful caveat but not routing 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?

Goes well past the readOnlyHint/openWorldHint annotations: discloses the data source (public HTML scraping), a known data-quality quirk (names derived from URLs can be shortened), what is absent from the page, and the full cost model (x402 metering, per-successful-call charge, no charge on failure).

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?

Dense but purposeful: fields first, then caveats, then billing. Slightly compressed with parentheticals, but every sentence carries information an agent needs.

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

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

With an output schema present, the description needn't document return shape; it still covers scope, known limitations, scraping source, and payment terms. Nothing an agent needs to invoke 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 coverage is 100% and the single 'limit' param is fully documented (range 1-30, default 10) in the schema itself. The description adds nothing about the parameter, so the 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?

States a specific verb and resource ('Top items on Amazon.com's Best Sellers page') and enumerates returned fields (rank, ASIN, product link). An agent can tell this apart from the other marketplace siblings by the site, though no sibling is named 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 'No prices or stock (not on this page)' caveat implicitly routes agents elsewhere for pricing/inventory, but there is no explicit when-to-use or when-not-to-use guidance and no named alternative 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 only declare readOnlyHint and openWorldHint, so the description adds genuine value beyond them: the x402 payment model ($0.002 USDC per successful call, on Base/Solana/Arc) and the important fact that failed calls are not charged. It also discloses the anonymous-vs-contract price limitation. It doesn't cover rate limits or result-volatility, keeping it at 4.

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 and scope are front-loaded in the first clause, and the pricing caveat follows logically. The mid-sentence field enumeration is long but each item is informative. Minor trimming of the returned-field list would make it tighter, but nothing is 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?

With an output schema present, the description needn't restate return structure, yet it helpfully summarizes it; annotations cover the safety profile and the description covers cost and access limits. The only gap is pagination/navigation behavior and whether results are cached or live, which is minor for this tool.

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

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

Schema coverage is 100% and each of the four parameters (q, page, site, limit) is already documented in the schema with defaults and ranges. The description only lightly reinforces this by tying 'USD or CAD' and per-unit-of-measure pricing to the site/price output, which is marginal added meaning. 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?

States a specific verb+resource ('Avantor / VWR catalog search') with scope (US or Canada site) and enumerates exactly what is returned (product code, name, VWR catalog/article number, per-unit list prices, stock status, flags, URL, total matches). This is enough to distinguish it from the many other vendor-specific ecommerce search siblings without opening a 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?

Gives clear operating context: it hits the API behind avantorsciences.com and returns anonymous list prices, while contract prices require an account — a real usage constraint an agent needs. It stops short of explicitly naming alternatives (e.g. ecommerce_fisher_scientific) or stating when not to use it, so it lands at 4 rather than 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds substantial behavioral context beyond them: it discloses the residential proxy source, the per-call cost ($0.02 USDC), the payment mechanism (x402 on Base, Solana or Arc), and the fact that failed calls are not charged. It also clarifies that only the first page of results is returned.

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 front-loads the core action and is packed with useful details, but the long enumeration of return fields is somewhat redundant given the presence of an output schema, making it slightly over-stuffed. It remains efficient overall, with no filler sentences.

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

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

Given the presence of a full output schema, complete parameter descriptions, and annotations, the description supplies all the extra context an agent needs: source, proxy, pricing model, and result scope. Nothing critical is missing 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description mentions the locale concept and gives a few examples, but the schema provides a fuller list and the description adds no additional semantics (e.g., no guidance on default behavior or fallback). Baseline 3 is appropriate when the schema does the heavy lifting.

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: 'Back Market refurbished-product search on a country site', and the mention of Back Market distinguishes it from sibling ecommerce tools that target other marketplaces. An agent can immediately tell what this tool does and on which source.

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 to use the tool (searching refurbished products on a specific Back Market country site) and lists the supported locales. However, it does not name alternatives or when-not-to-use conditions, so it falls short of the explicit routing guidance that would earn 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?

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses the ~20-item cap, that data comes through a rendering residential proxy (hinting at latency/failure modes), and precise cost terms — $0.02 USDC per successful call via x402 on Base, Solana or Arc, with failed calls not charged. That payment and billing behavior is information an agent cannot get anywhere else.

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 dense paragraph, front-loaded with what is returned, then the category format, then source/proxy and pricing. No filler sentences; every clause carries actionable 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 scraping tool with an output schema already covering return shape, the description supplies the remaining essentials: the result cap, the exact category identifier format, the data source, and the payment model. Nothing an agent needs before calling 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% and the single parameter is already documented with the same id/slug format, so the schema carries most of the load. The description nonetheless reinforces the semantics by supplying three varied category examples (81/vitamins-supplements, 1093/cold-flu, 109/foot-care), making the id/slug pattern unambiguous.

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 resource (Chemist Warehouse Australia category products) and enumerates exactly what is returned: id, name, AUD price, saving off RRP, rating/review count, image, link. Scope is pinned down as 'first page, about 20'. It does not explicitly contrast itself with sibling site-scrapers, but the site-specific naming makes the distinction obvious.

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 rather than stated: the 'first page, about 20' note tells the agent this cannot paginate, and the category examples show the accepted input shape. There is no explicit when-to-use or when-not rule, and no guidance on what to do if more than 20 products are needed.

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/openWorldHint annotations, it discloses the data source (chewy.com's product-page GraphQL API), the per-call cost ($0.002 USDC), the payment rails (x402 on Base, Solana or Arc), and that failed calls are not charged — precisely the facts an agent needs before invoking a paid open-world 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?

Front-loaded with purpose, then the return payload, then sourcing and pricing — a sensible order with no filler. The opening sentence is long and field-heavy, but each clause carries information an agent would otherwise have to infer.

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

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

With an output schema present, the return-value list is a bonus rather than a requirement, and the description still covers input format, source system, cost, payment mechanics, and failure charging. Nothing material is missing for a single-parameter, read-only paid 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%, so baseline would be 3; the description adds real interpretation by defining an item ID operationally as 'the number after /dp/ in a chewy.com URL' and restating the 1-10 bound. It does not add detail on delimiter edge cases (spaces, mixed IDs and URLs) beyond what the schema says.

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 (Chewy US item data by ID) with an explicit scope (1-10 IDs) and enumerates the returned fields, so an agent knows exactly what comes back. The clause 'no keyword search' further separates it from search-style siblings without needing to inspect the 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?

Gives concrete usage context — supply 1-10 item IDs or product URLs, IDs taken from the segment after /dp/ — and explicitly excludes keyword search as a use case. It stops short of naming an alternative tool for keyword or cross-retailer lookups, so routing is implied rather than stated.

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/openWorldHint annotations, the description discloses two unusual traits: only the first page of results is available, and calls cost $0.002 USDC via x402 while failed calls are free. The cost/charge-on-success detail is genuinely decision-relevant for an agent, though return shape and result ordering are left to the output schema.

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: the first front-loads what is returned and its scope, the second handles exclusions and billing. Every clause carries information; nothing is restated from the schema or 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?

With an output schema present, the description doesn't need to explain return structure, yet it still summarizes the fields and flags the data gaps and payment model. For a 2-parameter read-only search tool this is close to complete; only the interaction between `limit` and the single-page limitation is unaddressed.

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 `q` and `limit` are already fully documented in the schema. The description adds nothing about parameter behavior (e.g., whether limit interacts with the 'first page only' constraint) and only baseline credit 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 names a specific resource (Chrome Web Store search results) and enumerates exactly what each result contains: name, id, and detail-page link. It also states the source scope (public results page, first page only). It doesn't explicitly contrast with sibling ecommerce tools, but the source specificity makes it distinguishable.

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: search extensions by keyword. The description usefully rules out expecting ratings, user counts or prices, which steers agents away from this tool for enrichment-type queries, but it never states when to prefer a sibling or what prerequisites exist.

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 past annotations by disclosing the billing model ($0.002 USDC per successful call, x402 via Base/Solana/Arc) and that failed calls are not charged, plus the network limitation blocking costco.com and the data source (public page schema.org). Annotations only say readOnly/openWorld; the cost and reachability facts are behavioral context the agent cannot infer elsewhere.

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 purpose, then scope limits, then output fields, then price — a sensible order with no filler. It is one dense paragraph and the payment clause is long enough that it slightly dilutes the operational core, but every sentence carries 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 lookup with an output schema and readOnly annotation, nothing an agent needs is missing: inputs, return fields, geographic/network boundary, cost, and failure-charging behavior are all covered.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the derivation rule for the ID ('the number at the end of a costco.ca product URL') and reiterates the 1-5 limit, which helps an agent map user input to a valid argument. It does not clarify format tolerance for full URLs versus bare IDs beyond what the schema already states.

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?

Opens with a specific verb+resource+scope ('Costco Canada (costco.ca) product tracker') and enumerates exactly what is returned (name, SKU, CAD price, availability, rating, category path, image, URL). It also bounds the input cardinality and names the two things it is not (no keyword search, no costco.com), so an agent can distinguish it from every retail sibling without opening the 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?

Explicit exclusions are stated: no keyword search and US costco.com is unreachable, which are the two most likely misuse paths. It also tells the agent how to obtain the identifiers (the number at the end of a product URL). It stops short of naming which sibling to use instead for keyword-based product search, so it is clear context without a full routing table.

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 declare readOnlyHint and openWorldHint; the description adds materially important behavior an agent cannot get from structured fields: a per-call cost ($0.002 USDC), the x402 payment requirement and chains (Base, Solana, Arc), and that failed calls are free. That is exactly the kind of cost/authorization context an agent needs before invoking.

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 the pricing/payment caveat sits at the end where it belongs. The long enumeration of returned fields consumes a lot of text and duplicates what the output schema already declares, which is the only real waste.

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

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

With an output schema present, the return-field list is redundant rather than necessary, and the description correctly focuses on scope, input modes, and the paid-call model. What remains missing is any routing signal versus sibling pharmacy/price tools, though nothing prevents a 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?

Schema description coverage is 100%, so each parameter is already documented, and the description largely restates it ('search by drug name (optionally strength) or NDC'). The one extra nuance — the term-or-ndc mutual requirement — is also present in the schema, so 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?

States a specific verb and resource: searches Cost Plus Drugs mail-order cash prices from its official pricing API, by drug name (+ optional strength) or NDC. It also scopes the data ('Only drugs sold on the CPD mail-order channel'), which distinguishes it from general pharmacy/retail siblings like ecommerce_singlecare or ecommerce_chewy_com.

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 the search-mode enumeration ('search by drug name (optionally strength) or NDC') and by the constraint that either term or ndc is required. However, it never says when to prefer this over a sibling pharmacy-price tool (e.g. ecommerce_singlecare) or when-not to use it beyond the mail-order-channel limitation.

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 description adds meaningful context: title-only search scope, returned fields, cost per successful call, x402 payment chains, and that failed calls are not charged. It does not cover rate limits or data freshness, but the payment and failure behavior are 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 compact and front-loaded: source, search scope, return fields, then pricing. Every sentence carries useful information with no waste.

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

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

For a simple two-parameter read-only search with a full input schema, output schema, and safety annotations, the description supplies the key missing context: source, title-only scope, return fields, and payment behavior. Nothing essential for correct invocation is absent.

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 q and limit are already documented in structured form. The description reinforces the title-only search scope, which is relevant to q, but adds little beyond the schema for limit or parameter behavior.

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: search CPSC product recalls from SaferProducts.gov, restricted to recall titles. It clearly identifies the jurisdiction and source, though it does not explicitly distinguish this from the EU safety-gate 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?

It explains that only recall titles are searched, but it gives no explicit when-to-use guidance, exclusions, or comparison to alternatives such as EU Safety Gate RAPEX. The agent must infer usage from the source name.

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 readOnlyHint/openWorldHint: discloses the data source and residential-proxy route, the 25-per-page and newest-first ordering, that financial details beyond asking price require opening the listing page, and a full cost model ($0.002 USDC per successful call via x402 on Base/Solana/Arc, failures free). Cost and payment-scheme disclosure is exactly the kind of behavior an agent cannot infer from annotations.

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

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

Two dense sentences, front-loaded with the resource and returned fields before pagination/geography and then commercial terms. Every clause carries information; the field enumeration is long but directly useful for relevance judgements.

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 shape need not be explained, and the description still covers source, coverage limits, data gaps and pricing. The one material omission is differentiation from ecommerce_dealstream_listings, which leaves ambiguity for an agent choosing between two same-domain tools.

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 semantics the schema lacks: page size of 25, a hard cap at page 50, and newest-first ordering. State is only restated as whole-US vs. one-state, which the schema already covers.

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 ('DealStream businesses for sale') and enumerates exactly what a listing contains (title, asking price USD, description, industry, city/state, id, link). It does not, however, distinguish itself from the near-identically named sibling ecommerce_dealstream_listings, which is the main thing an agent would need to disambiguate.

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 rather than stated: 'for the whole US or one state' signals when to pass a state, and 'page 1 to 50' signals the crawl ceiling, but there is no explicit when-to-use, no exclusion, and no pointer to the competing dealstream sibling.

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 past the readOnlyHint/openWorldHint annotations: discloses the 25-per-page unit, the 50-page ceiling, sort order, the source (dealstream.com public pages scraped via residential proxy), a real data limitation (financial details beyond asking price live on the listing page, not in the response), and a full cost model — $0.002 USDC per successful call via x402 on Base/Solana/Arc, with failures not charged.

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 what is returned, then constraints, then provenance and pricing — no filler. The long field list makes the first sentence dense, but each clause carries information an agent needs, and the payment caveat is properly separated.

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, return shapes need no explanation, and the description still covers provenance, pagination limits, sort order, geography, data gaps and the paid-call mechanics. Nothing material an agent needs to invoke this 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 coverage is 100%, so the baseline is 3, but the description adds semantics the schema lacks: page size is 25 results, ordering is newest-first, and state scopes to exactly one state with the default spanning all states. That extra detail legitimately lifts it above 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 — DealStream business-for-sale listings — and enumerates exactly which fields come back (title, asking price in USD, industry, city/state, id, link). That is unambiguous, but it never distinguishes itself from the sibling ecommerce_dealstream tool, so an agent cannot tell from this text alone which DealStream endpoint to pick.

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?

Geography (whole US or a single state), page bounds (1-50) and ordering (newest first) imply the intended use case. There is no explicit when-to-use / when-not-to-use statement and no named alternative for the obvious question of how this differs from ecommerce_dealstream.

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 important behavioral context: the $0.002 per successful call cost, x402 payment rails, and that failed calls are not charged. It does not cover rate limits or result-count behavior, but the payment details are substantive.

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 purpose, then concisely lists return fields, sorting, and payment behavior. Every sentence earns its place, with no wasted 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?

Given an output schema and full parameter documentation, the description is nearly complete for a simple search tool. It covers pricing and payment behavior, though it could mention pagination limits or result-count semantics more explicitly.

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 all three parameters are already documented in the input schema. The description repeats sort options but adds little semantic detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: product search on Digikala Iran. It clearly identifies the retailer and country, which distinguishes it from most generic ecommerce siblings, though it does not explicitly name or contrast 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?

It explains available sort orders but gives no when-to-use guidance, no conditions for choosing this over other ecommerce search tools, and no exclusions. Usage is only implied by the purpose statement.

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 safety profile is covered. The description adds genuinely useful behavior beyond annotations: an explicit pricing model ($0.002 USDC per successful call via x402 across Base/Solana/Arc) and the note that failed calls are not charged. It does not detail pagination or response shape, but the output schema exists for that.

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 compact sentences, each earning its place: identity/scope, the exclusion plus next step, and pricing. The key scoping facts are 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?

With an output schema present, the description needn't explain return format, and it covers source, ordering, field contents, exclusions, and payment terms. Only minor gaps (no mention of rate limits or caching freshness) remain for a single-param read 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?

Single optional parameter with 100% schema description coverage, so the schema already documents the 1-50 range and default of 5. The description adds no further parameter meaning, so 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?

States a specific verb+resource: the EU Safety Gate (RAPEX) weekly product-safety report index sourced from the European Commission's public XML list. It further specifies what each entry returns (reference, publication date, week, alerts link) and ordering (newest first), which no sibling tool covers.

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 the boundary: 'Product-level details are not included; open the returned link for them.' That is clear guidance on when this tool suffices and what to do next. It lacks an in-catalog alternative reference, but none of the siblings are RAPEX equivalents.

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; the description adds substantive behavior the annotations cannot: data comes from faire.com through a residential proxy, wholesale prices are excluded, and each successful call costs $0.02 USDC via x402 (Base/Solana/Arc) with failed calls uncharged. Cost and data-completeness caveats are exactly what an agent needs before committing to a paid 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?

Front-loaded with purpose, then scope limitation, then cost — a sensible order. It is one very dense sentence enumerating returned fields, which partly duplicates the existing output schema, but every clause (login restriction, proxy source, charge model) carries information.

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

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

With an output schema present, the description need not explain return values, and it still covers the two things structured fields cannot: the logged-out data limitation and the x402 billing model with failure handling. For a one-parameter, read-only tool that is complete.

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

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

Schema description coverage is 100% and the single `category` parameter already documents the format (faire.com/category/<name>) with examples; the description adds no syntax or normalization advice beyond that. Baseline 3 is appropriate since the schema does all the parameter 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 (Faire wholesale marketplace category listing) plus the exact scope ('logged-out view') and enumerates the returned fields: product token, brand, suggested retail price, case quantity, stock, ratings, flags, image and link. An agent can immediately tell this is a Faire category browse, not a product search or price-comparison 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?

Usage is only implied: read it as 'fetch listings for a given Faire category'. There are no explicit when-to-use/when-not rules and no sibling alternatives named, though the note that wholesale prices require a retailer login effectively warns an agent not to use it for wholesale pricing. That single exclusion is real value but far from full routing guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds valuable behavioral context: cost per successful call, payment rails (Base, Solana, Arc), and that failed calls are free—critical for agent decision-making. It does not cover rate limits or auth details beyond x402, but this is a strong addition over the annotations 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 a single dense sentence with many comma-separated clauses listing return fields, some of which duplicate the output schema (e.g., prices, rating, flags). It is front-loaded with the store and action, but the field enumeration makes it longer than necessary for an agent that already has the output schema.

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

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

Given the tool's simplicity (2 parameters), the presence of an output schema, and read-only annotations, the description is fairly complete. It covers search scope, pricing, and return highlights. It could be improved with explicit guidance on sibling alternatives, but nothing critical for correct invocation 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 two parameters (q and page) are fully documented in the schema. The description does not add meaning beyond what's already in the schema—e.g., it repeats that search words are in Spanish or English, and doesn't elaborate on pagination behavior beyond the schema's page 1–50 range.

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 (product search) and resource (Falabella Chile products), and enumerates returned fields. It distinguishes itself from sibling ecommerce tools by naming the store, but does not explicitly contrast with alternatives like ecommerce_amazon or ecommerce_lazada.

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 the store name and product search context, but the description never states when to choose this tool over the many other ecommerce search siblings. The pricing model ($0.002 per successful call, x402 payment) is mentioned, which indirectly informs usage decisions, but no explicit alternatives or exclusions are given.

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

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

Annotations only cover readOnly and openWorld; the description adds substantial context beyond them: the data comes from fishersci.com's public search through a residential proxy, prices are list prices as shown to logged-out visitors with account-specific pricing excluded, pages are capped at 10, and billing is $0.002 USDC per successful call via x402 with failures not charged. These are exactly the behavioral facts an agent needs before spending money.

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 and the field list is compact; payment and proxy caveats follow in short clauses with little filler. It is dense — one long enumerative sentence plus two caveat sentences — but nothing is redundant enough to cut outright.

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 two-parameter, output-schema-backed search tool, the description covers everything an agent needs: what is returned, paging limits, data provenance and its pricing limitation, and the paid-call cost model. No material gaps remain.

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

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

Schema coverage is 100%, with both q and page already documented (including examples and the 1–10 range), so the schema carries the parameter burden. The description's only parameter-relevant additions are the page cap and the 15-per-page yield, which the schema largely restates; it adds no query syntax or matching-behavior 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 and resource (Fisher Scientific US lab product search) and enumerates exactly what each result contains: family title, description, leaf category, list price, catalog numbers, specs, link. The vendor is named explicitly, which is how this tool is told apart from the sibling supplier tools like ecommerce_avantor_vwr_international and ecommerce_chemist_warehouse.

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 operating context: US site, public search via residential proxy, logged-out list prices only, 15 families per page, pages 1–10, and a concrete per-call cost so an agent can weigh it against alternatives. It does not, however, name an alternative tool or state when *not* to use this one (e.g. for non-lab categories or account-specific pricing).

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 the critical operational fact that the call costs $0.002 USDC via x402 on Base/Solana/Arc and that failed calls are not charged — payment/auth behavior an agent must know before invoking. It also discloses the upstream source (public search API).

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

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

Two sentences, front-loaded with what the tool returns before the payment terms. The field enumeration is somewhat long given an output schema exists, but every clause carries concrete information (currency, fee split, availability).

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 are covered, and the description still adds the pricing model, source, and trip constraints. Only minor gaps remain — nothing about rate limits or how city-name mismatches are handled.

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

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

With 100% schema coverage, the schema already documents from/to/date and the 180-day date window. The description contributes meaning the schema cannot: the query is fixed to one adult and one-way, so the agent knows not to try to encode passengers or round trips.

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 the exact resource (FlixBus/FlixTrain trips between two cities on a date) and enumerates the returned fields (departure/arrival times, stations, duration, transfers, EUR price with/without fee, seats left, availability). The data source is identified as FlixBus's public search API. No sibling tool in this list covers intercity travel, so there is no ambiguity about which tool to pick.

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?

"One adult, one way" tells the agent the query scope, which is useful framing for when this search applies. However, there is no explicit statement of when NOT to use it or any alternative tool; the guidance is implied rather than stated.

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 readOnlyHint/openWorldHint annotations: discloses that the endpoint is unofficial and may change, that results are capped at 200 with a returned total count, and the exact payment model ($0.002 USDC per successful call via x402, failed calls free). The cost and reliability caveats are exactly the behavior an agent needs before calling.

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-loads source and scope, then the returned fields, then caveats and cost. It is a single dense sentence chain rather than separated clauses, but every clause (fields, cap, unofficial status, price) carries information an agent would otherwise have to discover by calling.

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

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

With an output schema present, the description need not detail return structure, yet it still summarizes fields and the 200-item cap. Combined with the payment and stability caveats, nothing material is missing for a three-parameter, read-only search tool.

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

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

Schema coverage is 100%, with q, limit and available each documented including ranges and defaults, so the schema already carries parameter meaning. The description adds only the 200-result ceiling and mentions condition/availability in the returned fields, which is marginal over the schema; baseline 3 applies.

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

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

States a specific verb and resource: search GameNation.in (India) games, consoles and accessories via the site's JSON API. It enumerates returned fields (name, ID, condition, price/MRP in INR, discounts, trade-in offers, availability, image), which pins down the resource precisely and separates it from the many other regional e-commerce 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?

Implies when to use it (India-focused game/console/accessory pricing and trade-in lookups) and notes the 200-result cap, but gives no explicit exclusions or pointers to alternatives among siblings like ecommerce_aliexpress or ecommerce_mediamarkt_eu. The usage case is inferable but not stated as 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?

Goes well beyond the readOnly/openWorld annotations: discloses the upstream source, that the feed carries no symbols, the 1e30 scaling convention, and a per-call pricing model with confirmation that failed calls are free. Cost/authorization behavior is unusually well surfaced.

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 source and scope, then the non-obvious formatting caveat, then cost. No filler or repetition of 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?

An output schema exists and the safety profile is in annotations, yet the description still supplies the two things that schema cannot convey well: missing symbol data and the 1e30 price scaling. Nothing needed to call it correctly is absent.

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 takes zero parameters, so the schema contributes nothing and the baseline is 4. The description correctly implies the call needs no inputs.

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

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

States a specific verb+resource+scope: GMX token prices on Arbitrum from the public api.gmx.io/prices feed. Clearly distinguishable from all sibling ecommerce/social tools, which cover no crypto price feeds at all.

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

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

Implies usage through 'Use the address to match the token yourself', which tells the agent what to do with the result but not when to prefer this tool or what prerequisites apply. No explicit when-to-use or exclusions, so it is adequate but 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 only cover readOnly/openWorld; the description adds genuinely non-obvious behavior: $0.002 USDC per successful call via x402, failed calls not charged, max 20 results per page, and an upstream US proxy source. That payment/cost model is critical for an agent deciding to invoke a metered 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?

Front-loaded with the core action and location scope, then details, then cost. The long enumeration of return fields is dense but informative; a slightly tighter structure would separate input guidance from output 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?

Covers location inputs, filtering, pagination limits, geographic scope, data source, and pricing. With an output schema present, the description need not explain return values, yet nothing an agent needs to decide and call 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 coverage is 100%, so all six parameters are already documented, including the delivery/pickup enum and the lat/lng-vs-zip grouping. The description adds only marginal param value ('up to 20 per page'); the rest of its detail describes return fields covered by the output 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+scope: Grubhub restaurants delivering to a US ZIP or lat/lng, with optional search text. It also enumerates the returned fields, so an agent knows exactly what it gets versus a generic ecommerce sibling like ecommerce_rappi (LatAm) or product-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?

The description clarifies the two location modes (zip OR lat/lng), the delivery/pickup choice, and that the query is optional with concrete examples ('pizza', 'sushi'). US-only scope is stated, which implicitly excludes other markets, but no sibling alternative is named explicitly.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered, and the description adds the material context an agent cannot get from annotations: the $0.002 USDC cost per call, the x402 payment rails (Base, Solana, Arc), and the fact that failed calls are not charged. Pagination behavior (36 per page plus total result count) is also disclosed. It stops short of describing rate limits or latency.

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?

It front-loads the resource and return fields, then covers sorting and pricing in two short follow-on sentences with no filler. The field enumeration is dense but every element is decision-relevant; a slight trim of the return-field list (already in the output schema) would tighten it further.

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, single-query search tool with one required parameter and full schema coverage, the description covers scope, cost, billing failure semantics, page sizing, and sort options. An output schema exists, so the enumerated return fields are redundant but harmless; nothing needed to invoke the tool 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 coverage is 100%, so the baseline is 3. The description earns the extra point by supplying '36 per page plus the total number of results', which is the only place an agent learns how to interpret the page parameter, and by restating the sort dimensions in human terms rather than just enum-like tokens.

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 ('Hepsiburada (Turkey) product search') and enumerates the exact fields returned, which makes it impossible to confuse with a general search or with another marketplace sibling such as ecommerce_trendyol_turkey. The platform and country scope act as the differentiator even without naming a sibling 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?

Usage is implied by the platform scoping: search this tool when you want Hepsiburada listings. However, there is no explicit statement of when to prefer it over ecommerce_trendyol_turkey or a broader retail aggregator, and no when-not guidance. The sort options are described but not tied to selection advice.

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 and openWorldHint, but the description adds critical context beyond them: bidder identities are not returned, and calls are metered at $0.002 in USDC via x402 across Base, Solana or Arc, with failed calls uncharged. That payment/auth disclosure is exactly the kind of operational detail an agent needs before invoking.

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?

It is a single dense paragraph but front-loads the core purpose and resource before the return fields and pricing. Nothing is filler, though the run-on sentence is a bit compressed for the amount of information carried.

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 four-parameter read-only tool with an output schema and full annotation coverage, the description covers scope, per-lot return fields, total matching lots, exclusions and billing. An agent has enough to select and invoke it correctly without opening the schema.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real meaning for the `status` parameter by explaining that 'upcoming' returns current bid, bid count, estimate range and sale type while 'past' returns hammer price, which the schema only labels 'upcoming (default) or past'.

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: auction lots from Invaluable for a keyword, with an explicit upcoming vs past split. It is clearly distinguishable from the ecommerce product-search siblings because it is a keyword search over auction lots rather than retail catalogs.

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 intended use clear: pass a keyword and choose 'upcoming' for lots with current bid, or 'past' for hammer price results. It does not name an alternative tool or a when-not condition, so it earns 4 rather than 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?

Goes well beyond the readOnlyHint/openWorldHint annotations: discloses that the endpoint is unofficial and may change or rate-limit, that pagination caps at 40 products per page, and gives a precise cost model ($0.002 USDC per successful call via x402, failed calls not charged). The billing and reliability caveats are exactly the kind of context annotations cannot carry.

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 and country scope are front-loaded, followed by the returned-field list, then operational caveats and pricing. The field enumeration is long but each item is a concrete data point; still, the list could be tightened since an output schema already exists.

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 unofficial, paid, rate-limited scraping endpoint, the description covers provenance, coverage, pagination cap, cost and failure billing. With an output schema present, enumerating return fields is redundant but harmless; nothing an agent needs before calling 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%, so q, page and country are already fully documented with examples and defaults. The description only restates the country coverage and adds "up to 40 products per page," which lightly informs the page parameter but adds no syntax or constraint detail 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?

States a specific verb+resource ("Lazada product search") and names the exact geographic scope of six countries, plus the data provenance (the JSON the Lazada catalog page loads). Against a sibling list crowded with other marketplace tools (aliexpress, trendyol, rakuten_japan, shopee-like regional actors), an agent can immediately tell this is the Lazada/Southeast-Asia option.

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 country coverage list implicitly tells an agent when this tool applies (SEA queries), but there is no explicit when-to-use guidance, no exclusions, and no pointers to alternatives for non-Lazada or non-SEA catalog searches. Usage must be inferred from the region list rather than stated.

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 goes beyond them with genuinely useful operational facts: a hard one-page/~20-result cap, a $0.002 USDC per-successful-call x402 fee across Base/Solana/Arc, and the fact that failures are free. It also caveats that prices are USD as given by the page's structured data. It does not describe rate limits or reliability, so it is strong but not exhaustive.

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

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

Two sentences, no padding, and the result fields are front-loaded before the pricing. However, the pricing/payment logistics occupy nearly half the text and are stated in dense parenthetical form, slightly crowding out what an agent most needs (what a call returns and its 20-item ceiling).

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?

A read-only search tool with full schema coverage, existing annotations, and an output schema needs only scope, cost, and result-size disclosure, all of which are present. The remaining gap is matching this tool to the right sibling marketplace, which the description leaves to the site name alone.

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

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

Schema coverage is 100%, so the schema already documents both q and limit with ranges and examples, making the baseline 3. The description adds a little context by confirming the page cap of ~20 that bounds the limit parameter and by framing the output fields, though it adds no syntax detail for q.

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 ('Made-in-China.com wholesale product search') and enumerates what the results contain (product name, supplier, price range, stock state). The site-specific name makes it trivially distinguishable from sibling marketplace tools like ecommerce_1688 or ecommerce_aliexpress.

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 'Only the first page (about 20 products)' note implies a usage boundary and pairs with the limit parameter, but the description never says when to prefer this over the many other ecommerce sources, nor does it name any alternative. Usage must be inferred from the site name.

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, so safety is covered. The description adds meaningful context beyond that: a paid model ($0.002 USDC per successful call via x402, failed calls not charged), the result cap of 12 with a total-matching count, and per-country currency behavior. These are real behavioral traits an agent needs before invoking it.

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 dense paragraph, but it is front-loaded with the core purpose and coverage before the return fields and pricing. The pricing sentence is verbose but earns its place for a cost-sensitive agent. Minor redundancy with the output schema is the only inefficiency.

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-field explanation is optional but the description still usefully adds the top-12 cap and total-match count. With annotations covering read-only openness and params fully documented, the only missing piece is explicit routing against sibling tools. Otherwise complete for a simple two-param search.

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 both q (2-80 chars, shop language) and country (default de, enum of five values) fully documented in the schema. The description only reiterates the currency set implied by country choice, so it adds little beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource (product search) with explicit scope: MediaMarkt/MediaWorld across DE, AT, CH, IT, PL. It also names the data source (schema.org product list on the public search page), which tells an agent exactly what it is retrieving and clearly distinguishes it from the many other ecommerce 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 country coverage implicitly defines when to reach for this tool, and the note that a category/brand match returns that page's top products clarifies expected behavior. But it never names an alternative tool or states when NOT to use it, so guidance 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?

Beyond the readOnly/openWorld annotations, the description discloses the pricing/billing model ($0.002 USDC per successful call via x402 on Base, Solana or Arc; failures not charged) and the data-freshness constraint (end-of-day on the free plan) — exactly the traits an agent needs before spending money.

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 clauses, source and unit front-loaded, then scope disclaimer, then freshness and cost. Every sentence carries information; only the billing detail is slightly dense for a description field.

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 shape needn't be explained, yet the description helpfully clarifies the two reported values (USD/oz and raw ounces-per-USD rate) plus source and staleness. Only minor gap: nothing on behavior for invalid currency codes.

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 comma list, allowed codes and default. The description still adds value by mapping each code to a metal (XAU=gold, XAG=silver, XPD=palladium, XPT=platinum), which the schema does not spell out.

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 (latest precious-metal prices from MetalpriceAPI) and enumerates exactly which metals and unit (USD per troy ounce). The explicit 'Not a retail price list' line separates it from the many retail-price siblings in this namespace.

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 rather than stated: the exclusion ('Not a retail price list') and the free-plan end-of-day caveat tell an agent when the data is appropriate, but there is no explicit when-to-use/alternative routing because no sibling covers spot metals. Adequate context, no exclusions or alternatives named.

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/openWorldHint, the description discloses the critical operational constraints: only the first page of the feed is read, ordering is newest-first, and each successful call costs $0.002 USDC via x402 on Base/Solana/Arc while failed calls are free. The pricing and payment-rail detail is exactly the kind of behavior an agent cannot get from annotations.

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

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

Three tight sentences: what it returns, the page/ordering constraint, then cost and payment terms. Front-loaded with the payload and 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 single-optional-parameter read tool with an output schema, annotations, and an explicit cost model, nothing needed to call it correctly is missing. The output schema already documents return values, so the description does not need to.

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

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

With 100% schema coverage on the single 'limit' parameter, baseline would be 3, but the description adds meaning the schema lacks: results come from the feed's first page in newest-first order, which tells the agent what the limit is actually slicing. It still doesn't restate the 1-30 range, but the schema already covers that.

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

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

The description names a specific source (Mood Fabrics' public product feed) and enumerates exactly what is returned: title, type, variant prices, and per-variant stock. Against 50+ sibling ecommerce_* store tools, naming the store and the record shape is enough for an agent to pick this one without opening the 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?

Usage is only implied: an agent infers it should call this when it needs Mood Fabrics fabric catalog data. There is no explicit when-to-use/when-not statement and no routing to an alternative sibling (e.g., a broader fabric or multi-store search tool), though the narrow single-store scope makes the implied case fairly obvious.

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

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

Beyond readOnlyHint/openWorldHint, the description discloses the data source (newegg.com public search page via residential proxy), the per-page item volume, the 1-20 page ceiling, the billing model ($0.002 USDC per successful call via x402 on Base/Solana/Arc) and that failed calls are not charged. That is exactly the cost/failure context an agent needs before calling a 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?

Purpose and cost are front-loaded, but the long comma-separated enumeration of ~15 returned fields duplicates what the existing output schema already provides and dilutes the sentence. Roughly half the text is restating structured data.

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 2-parameter paid search tool with annotations and an output schema, the agent has everything needed: what it searches, result density, pagination bounds, provenance, and cost/charging semantics. Only the sibling-selection guidance 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 both parameters are already documented with examples and the 1-20 range. The description reinforces the page range and adds 'about 36-42 items per page', which gives density context, but adds no query syntax guidance beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource with scope ('Newegg (US) product search') and enumerates the returned fields, page size and total-count behavior. An agent can immediately tell this apart from the dozens of other regional/marketplace ecommerce search 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 site-specific framing implies when to use it (Newegg US product lookups), but there is no explicit when-to-use/when-not or pointer to alternatives such as ecommerce_amazon_bestsellers or ecommerce_pricerunner for cross-store price comparison. Usage is inferred, not stated.

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 declare readOnlyHint and openWorldHint; the description adds substantive traits the agent could not infer: data is fetched via residential proxy, pagination caps at page 10, ~20 results per page, and a pay-per-call x402 model at $0.002 USDC with failed calls not charged. The last point is operationally important, telling the agent retries are free.

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 and scope come first, followed by return fields, paging, source and pricing — a sensible front-loaded order. The long enumeration of returned fields is dense but each item is substantive, and nothing is truly wasted; it is slightly heavy for a single 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?

For a two-parameter filtered search, everything an agent needs is present: what it searches, where the data comes from, field coverage, paging limits, result count, and the cost/charging model. An output schema exists, so the field enumeration is bonus rather than a gap-filler.

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 both parameters are already documented, including the 'page 1 to 10 (default 1)' constraint. The description restates the page range and adds only the ~20-per-page result size, which is marginal added meaning over 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?

States a specific verb (search) and a precisely scoped resource: Nykaa India beauty products. The parenthetical '(India)' and 'nykaa.com' differentiate it from the many generic beauty/marketplace siblings such as sephora_products or openbeautyfacts_products without opening a 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?

The geographic and vertical scoping ('Nykaa (India) beauty product search', 'from nykaa.com') gives clear context for when this tool applies rather than a regional or global alternative. It stops short of naming a specific sibling to prefer or stating when not to use it, so it falls just below an explicit routing statement.

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 cover the safety profile (readOnlyHint, openWorldHint), and the description adds genuinely non-redundant context: the source is crowd-sourced community data, coverage excludes prices/stock, and each successful call costs $0.002 in USDC via x402 on Base/Solana/Arc with failed calls uncharged. That payment and cost model is critical information an agent cannot get from the schema or annotations.

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

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

Three short sentences, each earning its place: what the tool returns, what it lacks, and what it costs. The resource identity is front-loaded before the constraints and billing details.

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

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

With an output schema present, the description need not explain return shape, yet it covers the essentials: scope of data, missing fields, cost, and payment mechanism. The remaining gap is brand-matching behavior and what happens at the limit boundary, which an agent would still have to discover empirically.

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 both parameters (brand, limit with its 1–20 range and default) are fully documented there. The description adds only the notion of brand-based filtering, without explaining matching semantics (exact vs fuzzy, case sensitivity) or limit behavior. Baseline 3 is appropriate when the schema carries this much weight.

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?

Names the specific resource (beauty and personal-care products by brand from Open Beauty Facts) and what it returns (name, barcode, size, product page). It also draws a clear negative boundary — no prices or stock — which separates it from price-comparison siblings like pricerunner or gmx_arbitrum_prices. It does not explicitly contrast with the other beauty catalogs (sephora_products, nykaa_beauty), so it stops short of 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 'No prices or stock: this source does not have them' line functions as an explicit when-not condition, steering agents away from using it for pricing lookups. Usage is clearly implied for brand-based product lookup. However, it never names an alternative sibling for the cases it excludes, so there is no direct routing 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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses important behavioral traits: the source is public, prices are current at call time, pagination is 48 products per page, and there is a $0.002 USDC charge per successful call via x402 with failed calls not charged.

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 front-loads the purpose and then covers returned fields, pagination, price freshness, and payment model. The long enumeration of return fields is somewhat dense and partially overlaps with the output schema, which keeps it from being maximally 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?

The definition is complete for calling the tool correctly: it covers the public source, required search input, pagination size, freshness of prices, cost and payment mechanism, and has both annotations and an output schema. Nothing important appears missing for an agent to select and invoke it.

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

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

Schema description coverage is 100%, and the schema already describes both q and page with examples and bounds. The description adds the page size (48 products per page) and total result count, but does not add meaning beyond what the schema provides for the parameters themselves, 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 and resource: product search on Petco.com (US), read from the public search page. It also names the exact domain and scope, which separates it from the many other ecommerce siblings, including ecommerce_chewy_com.

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 usage context is implied by 'product search read from the public search page' and the price note, but there is no explicit guidance on when to choose this over alternatives or when not to use it. It does not mention the Chewy sibling or any other ecommerce alternative.

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

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

Annotations already declare readOnlyHint and openWorldHint, but the description adds genuinely new behavioral facts: a $0.002 USDC charge per successful call, x402 payment across Base/Solana/Arc, and that failed calls are free. That cost-and-payment disclosure is exactly the kind of context annotations cannot carry. It omits any note on result limits or pagination, keeping it from 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?

Purpose and market scope are front-loaded in the first clause, and the billing sentence is a compact, self-contained unit. The long enumerated field list (price, shops, category, popularity rank, rating, price-drop, condition, stock, image, URL) is somewhat over-stuffed for a tool that has an output schema, costing it a point on tightness.

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 two parameters, full schema coverage, an output schema, and clear read-only annotations, the definition covers what an agent needs: what it searches, which markets, and what it costs. The return-field enumeration is redundant given the output schema but not harmful, and no critical calling information 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%, with 'q' and 'market' fully documented including the uk/se/dk values, so the schema already does the work. The description restates the three markets but adds no query syntax, matching behavior, or defaulting detail beyond what is structured. 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?

Names a specific verb and resource ('Price comparison from PriceRunner (Klarna)') and pins the exact geography covered (UK, Sweden, Denmark), which cleanly separates it from the fifty-plus single-retailer siblings like ecommerce_amazon_bestsellers or ecommerce_target_reviews. An agent knows immediately this is a cross-shop aggregator for three Nordic/UK markets.

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 contextual signals for selection – multi-shop price comparison, limited to uk/se/dk markets, and priced per call – which lets an agent decide between this and a single-retailer sibling. It stops short of naming an explicit alternative or a when-not condition, so it does not reach the top band.

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 and open-world behavior, and the description adds genuinely non-derivable context: a per-call price of $0.002 in USDC, the x402 payment path (Base, Solana, Arc), and the fact that failed calls are not charged. It omits rate limits and any latency/throughput behavior, which would have pushed it to 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?

Two sentences, front-loaded with what the tool returns, then the cost model — no filler. The field enumeration slightly duplicates the output schema, which is the only wasted space.

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

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

Return values are covered by an output schema and all three parameters are documented, so the only burden left is operational — cost and payment, which the description discharges. Missing rate-limit or quota context keeps it just shy of complete for a paid, open-world API.

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% — q length bounds, sort enum values, and the 1–30 limit with default are all documented in the schema. The description adds only 'price in JPY' as interpretive context and no sort-format or pagination guidance, so it sits at the baseline where 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 ('Rakuten Ichiba (Japan) product search from the official Rakuten Web Service API') and immediately enumerates the fields returned. The vendor/region qualifier lets an agent separate it from the dozens of other ecommerce_* siblings without opening the 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?

'Search results only, no stock history' sets a clear exclusion, and the official-API framing signals this is authoritative Rakuten Japan data rather than a scraper. It stops short of naming an alternative sibling or saying when a different marketplace tool should be preferred, so it is clear context without explicit routing.

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

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

Adds substantial detail beyond readOnlyHint/openWorldHint: the data source (public restaurant page), billing model ($0.002 USDC per successful call via x402 across Base, Solana or Arc) and the key asymmetry that failed calls are not charged. That payment/auth behavior is exactly the kind of operational trait an agent cannot infer from annotations or schema.

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, geo scope and the no-search constraint are front-loaded, which is good. But the long middle clause enumerates every returned field even though an output schema exists, which is largely redundant filler that inflates the 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?

With annotations, full schema coverage and an output schema present, the description covers source, cost, and lookup limitation — enough to call it correctly. Minor gaps (e.g. whether results are cached or how large menus are truncated) are acceptable given 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%, and the schema already explains the country codes, the URL-vs-ID form of storeId, and the maxProducts range. The description adds only the phrase 'for a Rappi store ID', 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?

States a specific resource (Rappi restaurant menu and prices) with explicit geographic scope and enumerates exactly what a call returns (store metadata, ETA, fees, offers, menu by section with per-product pricing). The scope restriction 'no store search' plus the store-ID input makes it trivially distinguishable from siblings like ecommerce_grubhub or ecommerce_falabella_latam.

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 'From the public restaurant page; no store search' clause tells the agent the required precondition (a store ID/URL must already be known) and rules out a lookup workflow. It stops short of naming an alternative tool for store discovery, so it is clear context without explicit 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 only provide readOnlyHint and openWorldHint, so the description carries extra burden and delivers: it enumerates the exact fields returned (brand, UPC, unit/case price, sale flag, etc.), discloses the per-call cost model ($0.002 USDC via x402, no charge for failures), and explicitly states that Restaurant Depot and Sysco prices are unavailable without an account. These are meaningful behavioral details that annotations alone do not 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?

The description is dense but front-loads the crucial source and data-return details, followed by useful cost and limitation notes. It is longer than a single sentence but every clause earns its place; minor deduction because the long enumeration could be slightly better 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?

Even though an output schema exists, the description still gives enough context about return values, payment model, and source limitations to call the tool confidently. Nothing essential for correct invocation 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 schema already documents every parameter (q, page, limit, store) with examples and defaults. The description adds no additional parameter-level meaning 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?

The description names a specific resource (restaurant-supply prices from US Foods CHEF'STORE) and lists the returned data fields. It also distinguishes itself from Restaurant Depot and Sysco by noting those sources publish no public prices, though it never uses a direct verb like 'search' (the schema's parameter descriptions carry that role).

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 stating it covers a cash-and-carry store open to the public and that Restaurant Depot/Sysco require accounts. However, it gives no explicit guidance on when to prefer this tool over any of the many ecommerce siblings, nor any query-shaping advice beyond what the schema says.

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/openWorld annotations, it discloses page size (96), the 20-page ceiling, that data comes from public category pages via a residential proxy, and the exact cost model: $0.002 USDC per successful call via x402 on Base, Solana or Arc, with failed calls uncharged. That payment/precondition detail is exactly what an agent needs before invoking a paid endpoint.

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

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

Two sentences, front-loaded with the resource and its payload, then pricing and provenance. The long field enumeration is dense but each item is a real output attribute; nothing is filler, though the sentence is heavy to parse.

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 2-param, read-only list tool with an output schema, it covers source, pagination limits, currency, category-count inclusion, and the full payment/charging model. An agent has everything needed to decide and invoke correctly; return-value structure is rightfully left 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 coverage is 100%, so the baseline is 3, but the description adds facts absent from the schema: 96 results per page and the 1-20 page cap, plus an extra category slug example (motorcycle-tires) and the USD currency of price. This meaningfully informs parameter choice rather than restating 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?

It names a specific resource (RevZilla motorcycle gear and parts in a category) and enumerates exactly what each record contains (name, brand, price, stock, rating, reviews, badge, shipping, image, link). Against ~50 ecommerce siblings this is unambiguously the RevZilla category-listing tool, not a search or product-detail 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?

It scopes usage to revzilla.com category pages and gives concrete slug examples plus the valid page range (1-20), which tells the agent how to call it and implicitly that free-text search is not supported. It never states when to prefer a sibling (e.g. a search-oriented tool) or a when-not condition, so it stops short of explicit routing 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?

Goes well beyond the readOnly/openWorld annotations: it discloses the exact cost ($0.002 USDC per successful call), the payment mechanism (x402 on Base, Solana, or Arc), and that failed calls are not charged. That billing/auth context is precisely the kind of behavioral detail an agent needs before invoking a 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?

Front-loaded with the core purpose, then return fields, then cost. The field list is long but earns its place by telling the agent what it receives; overall dense but not padded.

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 annotations, a fully documented schema, and an output schema present, the description covers everything an agent needs: what it searches, what it returns, and the payment model. No material gaps remain.

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

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

Schema coverage is 100%, so the schema already documents q, page and limit fully. The description reinforces the keyword input and 60-per-page cap but adds no format or constraint detail beyond the schema, so 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?

States a specific verb+resource+source: 'Sephora (US) product search from Sephora's own catalog search.' The catalog fields it returns are enumerated, so the agent knows exactly what kind of data it gets and can distinguish it from the many other marketplace 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?

Usage is implied by 'for a keyword' and the 60-per-page scope, but there is no explicit when-to-use/when-not or routing to alternatives among the dozens of sibling ecommerce tools (e.g. other beauty sources). The agent must infer the fit.

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 safety profile is partly covered. The description adds meaningful behavior beyond annotations: pricing of $0.002 USDC per successful call, supported payment networks via x402, and that failed calls are not charged. It does not mention rate limits or feed freshness.

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: it states what the tool returns, the public-feed constraint, the domain input example, and the payment terms without redundant filler. Every sentence contributes 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?

With an output schema present and full schema parameter coverage, the description does not need to explain return values or parameter formats. It covers the critical operational constraints: public feed availability, required domain input, payment mechanism, and failed-call charging, making it 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?

Schema description coverage is 100%, so both parameters are already documented in the schema. The description repeats the shop-domain example but adds no additional semantics for the limit parameter or domain format 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 clearly identifies the resource and source: products from a Shopify store's public /products.json feed, including the specific fields returned. It distinguishes itself from general ecommerce scrapers by requiring the public Shopify feed, though it does not explicitly name a sibling alternative or use a direct action verb.

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 prerequisite: the tool works only for stores that keep /products.json public, and the user must supply the store domain. It does not explicitly compare against other ecommerce tools or say when not to use this one beyond the public-feed constraint.

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 past the readOnly/openWorld annotations by disclosing the data source (singlecare.com public pages via a residential proxy), the ZIP-dependent pharmacy coverage limit, and the exact paid-call economics: $0.002 USDC per successful call via x402 on Base/Solana/Arc, with failed calls not charged. The cost and non-charging behavior are exactly the kind of context an agent needs before calling.

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 and returned fields are front-loaded in one dense sentence, with provenance, the ZIP caveat, and pricing in a second. Efficient and well-ordered, though the first sentence is a long comma-chained enumeration.

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 everything needed for a paid, ZIP-scoped price lookup: what is returned, where the data comes from, how coverage varies, and what invocation costs. With an output schema present and full parameter coverage, no material gap remains for an agent deciding whether and how to call it.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning by stating that the pharmacy list (and therefore the result set) depends on the ZIP, which the schema does not say. It also clarifies the drug string maps to singlecare.com drug-page slugs, reinforcing the schema's example.

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-plus-resource ('SingleCare prescription coupon prices for a drug') with the exact payload enumerated: per-pharmacy price, loyalty price, distance, lowest price, form, strength, quantity, retail cash price, generic/brand flag, and history. This is unmistakably distinct from the retail-catalog siblings in the 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?

Usage is implied rather than stated: the description makes clear this is US pharmacy price comparison driven by a ZIP, but it never says when to prefer it over adjacent price tools such as ecommerce_costplusdrugs or ecommerce_chemist_warehouse, nor any exclusions. An agent can infer the use case but must reason about alternatives itself.

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 cover read-only and open-world behavior, and the description adds non-obvious traits: explicit price, payment rails, success-only billing, and the fact that it lists rather than runs actors. These details materially affect invocation 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?

Three compact sentences front-load purpose, then scope limitation, then pricing. Every sentence supplies decision-relevant information without waste.

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

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

With an output schema, annotations, and fully described parameters, the description supplies the remaining essentials: search scope, non-execution limitation, and cost model. Nothing critical is missing for correct selection.

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

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

Schema coverage is 100% for the two parameters, so the schema already documents q and limit. The description mentions keyword search and returned fields but does not add syntax, defaults, or validation 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?

States a specific verb and resource: searches the public Apify Store for scraper actors by keyword and enumerates returned metadata. The added 'Lists actors only; it does not run them or return product data' clearly distinguishes it from sibling ecommerce product/scraper 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?

Clearly frames the context as discovery of scraper actors and explicitly excludes running them or returning product data, reducing misuse. It does not name an alternative tool or give a concrete 'use when' condition, so it is not fully 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?

Goes well beyond the readOnly/openWorld annotations: it discloses that the endpoint is unofficial and may break without notice, the exact price ($0.002 USDC) and payment rails (x402 on Base/Solana/Arc), and that failed calls are free. Those are precisely the operational facts an agent needs before committing to a paid 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?

Front-loads the retailer and operation, then compresses cost/limits/reliability into one short trailing sentence. The long enumeration of return fields is somewhat redundant given an output schema exists, but it reads as a single efficient 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?

Covers cost, payment mechanism, reliability caveat, and result cap — the things an agent can't get from the schema or annotations. Return-field details are already available via the output schema, so repeating them is mildly wasteful but harmless; nothing required for a correct call 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% and both parameters are documented in-schema with examples and sort values, so the description need only clear the baseline. It adds no further meaning about `q` syntax or how `sort` interacts with the results.

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 — product search on Takealot.com South Africa — and names the exact underlying source (the JSON API the site itself uses). The retailer name alone distinguishes it from every sibling in the ecommerce family.

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 domain is implied clearly enough that an agent knows this is the South African Takealot search, but there is no explicit when-to-use/when-not guidance and no mention of sibling alternatives (e.g. other regional retailers). The result cap of 36 per call hints at a practical limit but no pagination strategy is offered.

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 safety profile is covered, but the description adds genuinely new behavioral facts: a $0.002 per-call cost in USDC via x402 across Base/Solana/Arc, and that failed calls are not charged. It also discloses the field-level return shape and sorting behavior; only pagination/rate behavior is left implicit.

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

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

Two sentences, front-loaded with what is fetched and keyed on, followed by a compact pricing/payment sentence. The field enumeration is dense but each item tells the agent what data it will get back, so nothing is 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?

Given a five-parameter schema that is fully documented, an output schema, and annotations covering read-only/open-world, the description covers everything an agent needs: how to identify the product, which knobs exist, what data returns, and the cost/payment model. Nothing material is missing 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?

Schema coverage is 100%, so baseline is 3, but the description adds meaning beyond the schema by explaining where the TCIN comes from in a target.com URL and by spelling out the sort semantics ('most recent, most helpful, highest or lowest') and the verified-only filter. The page and limit parameters remain unelaborated beyond their schema descriptions.

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

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

States a specific verb and resource ('Reviews of a Target product by TCIN') and immediately enumerates the payload (rating statistics plus individual reviews with named fields). No sibling tool covers Target reviews, so the retailer-plus-resource naming is enough to distinguish it.

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

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

The description explains how to obtain the required TCIN ('the number after A- in a target.com product URL') and enumerates sort and verified-only options, which guides invocation. However, it never states when to prefer this tool over an alternative or any prerequisite/exclusion conditions, so usage is implied rather than prescribed.

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/openWorld annotations, the description discloses the data source ('via a Turkish residential proxy'), the exact cost model ($0.01 USDC per successful call), accepted payment rails (x402 on Base, Solana or Arc), and that failed calls are not charged. These are material operational facts an agent cannot infer from structured fields.

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, followed by a dense but relevant field list and a separate payment sentence. The long enumeration of return fields is somewhat redundant given the output schema, but overall it is efficient and wastes little space.

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

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

Given an output schema exists, the description is more than complete for a two-parameter read tool: it covers source, pricing, payment rails, and failure charging. Minor gaps remain around rate limits or proxy-related failures, but nothing critical for correct invocation 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%, so both query and page are already documented, including the '1-50' page range and Turkish query examples. The description adds the page size ('36 products per page') and currency for price, but does not clarify parameter behavior beyond the schema, so 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 opens with a specific verb and resource ('Trendyol (Turkey) product search') and scopes it to a named marketplace and country, which clearly distinguishes it from sibling marketplace tools like ecommerce_hepsiburada or ecommerce_digikala_iran. An agent can identify exactly what this tool retrieves without opening the 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?

Usage is implied by the marketplace scope, and the schema's query description notes Turkish works best, but the description never says when to prefer this over a sibling such as ecommerce_hepsiburada for Turkish e-commerce or when to avoid it. No explicit exclusions or alternatives are given.

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

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

Annotations already declare readOnlyHint/openWorldHint, so the description's added value is meaningful: it names the data source (public product page), the data boundary (no stock or shipping), and a full billing model (USDC per successful call, x402 on Base/Solana/Arc, failed calls uncharged). Cost and failure-charging behavior are exactly the kind of context an agent can't infer from structured fields.

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

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

Two sentences, front-loaded with what the tool returns, followed by scope limits and cost. No filler or repeated fields.

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 tool with an output schema and annotations present, nothing essential is missing: source, return fields, scope limits, and pricing are all covered, so an agent can call it correctly and understand the cost.

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

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

Schema coverage is 100% and the schema already documents the item format ("letter, optional dash, digits") with the same S-4119 example. The description merely restates that example, adding no syntax or edge-case detail beyond the schema, so the 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?

States a specific retrieval verb, the exact resource (Uline product by item number), and enumerates what is returned (description, category, unit price). The example item number and the Uline-specific scope make it trivially distinguishable from the many other retailer 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 item-number lookup context is clear and the example anchors usage. It also gives an implicit exclusion ("no stock or shipping data"), telling the agent not to reach for it for inventory questions, but it does not explicitly route to an alternative or state prerequisites.

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, yet the description adds genuinely new behavior: reads public listing pages (no auth implied), a per-call price of $0.002 USDC via x402 on Base/Solana/Arc, and the fact that failed calls are not charged. The cost model is decisive information an agent can't get from annotations. Only the return format's cadence/pagination is unstated.

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, both dense with content and front-loaded with the resource and inputs before the pricing detail. The long field enumeration is slightly list-heavy and partially redundant given an output schema exists, but nothing is padded rhetoric.

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 enumerating return fields is redundant, but the description covers the essentials an agent needs: input format, per-listing scope, no catalog search, and the payment model. The main missing piece is disambiguation from the similarly named sibling tool.

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

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

Schema coverage is 100% and the single parameter is already documented with format and example. The description adds one useful clarification — that the ID is 'the number before .shtml in a listing URL' — which grounds the notion of a listing ID. Otherwise it repeats the 1-10 constraint already in the schema, so 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?

States a specific verb+resource (listing tracker for Vestiaire Collective) with explicit scope: US site, USD, 1-10 listing IDs. The enumerations of returned fields make the tool's remit unambiguous. It does not, however, differentiate itself from the near-identically named sibling ecommerce_vestiairecollective, which an agent could easily confuse it with.

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 catalog search' is an explicit when-not statement, and 'Reads each public listing page' implies this is per-listing lookup only. But there is no positive guidance on which situations call for this tracker versus other ecommerce tools, and nothing resolves the overlap with the similarly named sibling.

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 substantial behavioral context beyond them: it reads public listing pages, does not provide catalog search, charges $0.002 per successful call via x402, and does not charge failed calls. This is materially useful for an agent deciding whether and how to invoke it.

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

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

The description is dense but front-loaded and every sentence carries relevant information: scope, return fields, source behavior, constraints, and pricing. 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?

Given one required parameter, full schema coverage, annotations, and an output schema, the definition is complete enough for correct invocation. The description adds payment and source-page context while the output schema handles return 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 the single parameter is documented in the schema, so the baseline is 3. The description adds useful detail by specifying that IDs are the number before .shtml in a listing URL and that up to 10 IDs are accepted, improving parameter interpretation 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 verb and resource: a Vestiaire Collective listing tracker that returns detailed listing data for 1-10 listing IDs on the US site in USD. It is very clear, but it does not differentiate itself from the near-identically named sibling ecommerce_vestiaire_collective, leaving a potential 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?

It clearly indicates usage for known listing IDs and explicitly says 'no catalog search,' which tells the agent when not to use this tool. It does not name an alternative for catalog search, but the usage context is otherwise 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?

Goes well beyond the annotations by disclosing a paid, metered model: $0.002 USDC per successful call, x402 payment on Base/Solana/Arc, and — critically — that failed calls are not charged. It also sets expectations that the output is a new generated image rather than a recovered original, which no structured field conveys.

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: capability plus limitations first, then the payment model. No filler, and the most decision-relevant facts (what it does, what it won't do, what it costs) are 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?

For a two-parameter, single-purpose image-generation tool with an output schema and full schema descriptions, all that remains for the description is capability, limits, and billing — and all three are covered. An agent can decide to call it and pay for it without further reading.

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 parameters (image and strength) are already documented in the schema, including the 0.1–0.9 range and 0.4 default. The description only repeats 'send the photo as base64' and says nothing about how the strength knob affects output, so it adds little 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 and resource ('Restores an old, scratched or faded photo') plus the underlying model (Cloudflare Workers AI, img2img), and names what it explicitly does not do (recover lost detail, identify people). No sibling tool covers photo restoration, so the agent can distinguish it at a glance.

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 for use (send a damaged photo as base64) and hard exclusions ('does not recover lost detail or identify people'), which steers the agent away from misusing it for people-search or forensic upscaling. It stops short of explicitly naming an alternative tool for those cases, so it is not a full 5.

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