Friday Seller Tools

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

Despite the readOnlyHint annotation, the description adds critical behavioral context not present in structured fields: this is a PAID SKILL ($0.50 USD/call), and 'calling this tool returns payment instructions only.' It also clarifies constraints—'without reading Seller Central or predicting a decision'—and provides explicit payment endpoints. This goes well beyond annotations and fully discloses the payment-gated behavior.

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

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

The description is verbose and contains redundant payment marketing ('this server never runs paid work for free, and calling this tool returns payment instructions only' is repeated conceptually). It includes lengthy URLs and payment instructions that could be truncated. While the function is front-loaded in the first sentence, the overall text is bloated, making it less scannable for an agent.

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

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

The tool has 7 parameters, nested objects, and no output schema, yet the description does not explain the output format or the payment flow after the initial 'payment instructions only' response. It mentions a 'free sample output' URL, which helps, but it still leaves ambiguity about what a successful (paid) call returns and how the payment gate integrates with the actual organizing logic. This is a significant gap for a complex tool.

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

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

The input schema already provides detailed descriptions for every parameter (e.g., claim_status enum, counts_toward_odr boolean, response_due_date). The description adds minimal extra parameter meaning; it references 'counts-toward-ODR observations' and 'deadline queue,' which map to schema fields but add no new semantic detail. Since schema coverage is high, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Turn seller-redacted A-to-z claim summaries into an exact deadline queue, preserve supplied counts-toward-ODR observations, and summarize claim and order exposure.' It distinguishes from sibling tools by noting it works 'without reading Seller Central or predicting a decision.' However, the statement 'calling this tool returns payment instructions only' introduces ambiguity about whether the tool actually performs this organizing work or simply initiates payment, slightly muddying the purpose.

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

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

Usage context is implied: the tool is for when you have 'seller-redacted A-to-z claim summaries' and want to organize them. It also hints at boundaries ('without reading Seller Central or predicting a decision'), but it never explicitly states when to use this tool vs alternatives (e.g., ebay_payment_dispute_organizer or safet_claim_queue), nor does it mention prerequisites or exclusions. No when-not-to-use guidance is provided.

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

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

The description explicitly discloses that this is a paid skill costing $0.50 per call, that calling the tool returns payment instructions only, and includes payment URLs and a sample output link. It also states the tool does not predict Featured Offer outcomes. This adds substantial behavioral context beyond the readOnlyHint annotation, with no contradiction.

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

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

The first sentence is front-loaded with the core purpose and specific audit actions. The remaining sentences cover payment details and sample output, which are necessary for a paid tool. The URLs are long but critical. It's longer than ideal but each sentence earns its place.

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

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

Given the complex nested schema and no output schema, the description covers the essential aspects: what it does, what it doesn't do, payment flow, and where to see a sample output. It doesn't describe the output format in detail, but the sample link compensates. The tool's paid status is also fully explained.

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

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

The description adds high-level meaning by referring to 'one or two exports' (mapping to latest_snapshot and earlier_snapshot) and 'landed costs, fees, and contribution floor' (mapping to economics). However, it does not explain the required confirm_rules_and_economics_are_seller_supplied or report_label fields. With 0% schema description coverage, the description only partially compensates, though the nested object schema descriptions provide some support.

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

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

The description clearly states the tool audits one or two seller-supplied Automate Pricing exports against seller economics, enumerating specific checks (inverted bounds, minimums/current prices below recomputed viable cent, rule/bound drift) and explicitly excludes Featured Offer prediction. This distinguishes it from the many Amazon pricing/margin tools in the sibling list.

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

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

The description provides clear context for when to use it: when you have Amazon Automate Pricing exports and want to audit them against your own costs and margin floor. It also notes what it does not do (predict Featured Offer outcomes), which implies alternatives exist. However, it doesn't explicitly name or contrast specific sibling tools.

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

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

The description discloses critical behavioral traits beyond annotations: it requires payment ($0.50 per call), returns payment instructions on unpaid calls, and does not embed Amazon rates (instead relying on the seller's rate card). These are significant operational details not captured by readOnlyHint/openWorldHint. No contradiction with annotations.

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

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

The description is front-loaded with the core functionality in the first sentence, then adds essential payment and sample-output information. Every sentence carries necessary operational detail, though the payment URLs make it longer than usual. Still, it's efficient and well-structured.

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

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

The description conveys the tool's full workflow (join, recompute, rank), the payment gate, and provides a sample-output link. It does not specify the response format after payment, but given the detailed input schema and the sample link, the context is reasonably complete for an agent to decide whether to use it and what to expect.

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

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

With schema description coverage at 0%, the description partially compensates by referencing key concepts: 'your own rate card' (rate_card), 'billed quantities' (billed_quantity), 'high-exposure lines' (high_exposure_threshold). However, it does not explain all parameters such as report_label, statement_date, amount_tolerance, or reporting_currency, leaving some gaps for the agent.

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

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

The description opens with a precise verb phrase: 'Join seller-redacted Amazon Warehousing & Distribution charge rows to your own rate card, recompute storage, box or pallet processing, and transportation charges from billed quantities, then rank arithmetic differences and high-exposure lines.' This clearly identifies the tool's function and distinguishes it from other fee verifiers (e.g., fba_storage_fee_verifier) by naming AWD and the custom rate card.

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

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

The description provides clear context that this is a paid skill and that calling the tool without payment returns only payment instructions. It also states the tool is for verifying AWD charges against the seller's rate card, implying when to use it. However, it does not explicitly list alternatives or when-not-to-use conditions, so it stops short of a 5.

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

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

The description goes beyond annotations by disclosing the tool is paid, costs $0.50 USD per call, returns payment instructions only, and provides specific payment URLs. This is critical behavioral context not inferable from the readOnlyHint or openWorldHint annotations. No contradiction with annotations is present.

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 lengthy and includes multiple URLs, pricing details, and a dense technical first sentence. While the payment information is essential, the structure is weighed down by long sentences and redundant URLs, making it less efficient than it could be.

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 immediate behavior of returning payment instructions, the description covers the cost, payment methods, and a sample output link. However, it does not explain how the payment flow connects to the actual qualification service or what an agent should do after receiving payment instructions, leaving gaps for a complex paid tool.

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

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

The input schema has 9 parameters with 0% property descriptions, and the description only mentions seller-entered landed cost, fulfillment cost, referral-fee rate, and sourcing status, which map to the nested economics object. It does not explain required top-level parameters like report_label, report_start_date, report_end_date, minimum_unit_contribution, or default_referral_fee_rate, leaving most parameter semantics unaddressed.

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 first sentence clearly describes the underlying qualification service with specific verbs and resources: a deterministic filter for Amazon B2B Product Opportunities report rows. However, the description then states that calling the tool returns payment instructions only, creating ambiguity about whether the tool directly performs the qualification or merely gates payment. The tool title and first sentence suggest a qualifier, but the actual behavior is a payment gate.

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

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

The description explicitly says the tool is a paid skill at $0.50 per call and that calling it returns payment instructions only, giving clear context about payment expectations. It does not explicitly state when to use this tool versus alternatives or enumerate prerequisites beyond payment, so usage guidance is implied rather than fully contextualized.

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

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

The annotations already declare readOnlyHint: true, so the description's mention that the tool 'runs inline' confirms no side effects. It additionally discloses that it is free ($0.00 USD) and that it flags terms 'for human review,' adding behavioral context beyond the annotations. No contradictions.

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

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

The description is two sentences long, front-loaded with the primary action, and contains no extraneous information. Every word adds value.

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

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

The tool has two parameters and no output schema. The description covers the core functionality but does not describe the output format or what fields the response contains. For a tool that flags issues, indicating what the response looks like would enhance completeness.

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 0%, meaning the schema provides no parameter descriptions. The description partially compensates by mentioning 'supplied Amazon backend search-term field' and the byte budget, but it does not explain the 'visible_copy' parameter or its purpose. The meaning of the required 'search_terms' parameter is implied but not detailed.

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

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

The description clearly states that the tool counts UTF-8 bytes of Amazon backend search-term fields against a 250-byte budget and flags issues. It specifies the exact verb ('count'), resource ('backend search-term field'), and distinct behavior ('flag repeated, already-visible, and risky terms'). This differentiates it from sibling tools like 'amazon_backend_search_terms' which likely manage search terms rather than audit byte budgets.

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 the tool's purpose and explicitly states what it does not do ('does not validate marketplace policy or indexing'), but it does not provide explicit when-to-use or when-not-to-use guidance relative to alternatives. While the context is clear, the lack of direct exclusions or sibling differentiation slightly reduces the score.

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

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

The description mentions it is deterministic and enforces byte budget, but it also states 'calling this tool returns payment instructions only', which contradicts the earlier claim of performing optimization. Annotations declare readOnlyHint=true, consistent with returning info, but the description adds confusion about actual behavior.

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

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

The description is cluttered with payment details and URLs, which are not essential for understanding tool functionality. The key purpose is buried among less relevant 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 5 parameters, no output schema, and high complexity, the description fails to explain return format, how parameters interact, or what the user gets after payment. It is incomplete for effective use.

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

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

Schema description coverage is 0%, yet the description does not explain any of the 5 parameters (product, candidate_terms, byte_budget, visible_copy, excluded_terms). Only brief hints about 'candidates' and 'excluded words' are given, which is insufficient.

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

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

The description clearly states it creates a deterministic Amazon US backend search-term draft that ranks candidates, removes repeats and excluded words, and enforces byte budget. The verb+resource is specific, but it does not distinguish from the sibling 'amazon_backend_search_term_byte_checker'.

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 focuses on payment instructions but does not explain when to use this tool versus alternatives like byte_checker. No explicit when/when-not guidance is provided.

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

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

The description prominently discloses the paid nature ($0.50 per call), that the server never runs paid work for free, and that calling the tool returns payment instructions only. This adds substantial behavioral context beyond the readOnlyHint annotation; no contradiction is present.

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 core functionality is front-loaded in the first sentence, and the payment instructions are clearly separated with 'PAID SKILL'. The long URLs are necessary for payment, but the overall length is slightly above average due to multiple payment options.

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

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

For a paid tool with no output schema, the description covers the main computation, payment gate, and provides a sample output URL. It does not describe the post-payment response or top-level parameters, but it is sufficiently complete for initial selection and understanding of the paid call behavior.

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

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

The description adds meaning for row-level fields by explaining the formula (attributed_sales × bonus_rate_percent) and comparison with credited_amount. However, schema description coverage is 0% and the description does not explain top-level parameters like report_label, as_of_date, reporting_currency, or amount_tolerance, leaving clear gaps.

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

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

The description uses a specific verb ('Estimate'), names the resource ('Brand Referral Bonus'), and details the calculation ('attributed sales x your supplied bonus rate'), comparison to recorded credits, and ranking of shortfalls. It differentiates from sibling tools by framing it as an estimate/comparison and explicitly disclaiming any assertion of money owed.

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 states the workflow: estimate from seller-supplied attributed orders, compare with recorded credits, and rank shortfalls or rows missing a rate. It does not explicitly name sibling alternatives or state when not to use, but the 'without asserting Amazon owes anything' boundary helps define scope.

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

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

The description goes well beyond the readOnlyHint annotation by disclosing that the tool is deterministic, security-bounded, and does not touch listings. It also clearly explains the payment behavior: it costs $0.50 per call, returns payment instructions only, and will not run paid work for free. This is crucial non-obvious behavior that an agent must know before invoking the tool.

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

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

The description is long but densely packed with essential information: function, safety properties, payment cost, payment methods, URLs for payment and sample output. Every sentence serves a purpose for a paid tool. It is front-loaded with the core function before payment details. The only minor issue is the length could be truncated for non-payment contexts, but it is acceptable given the need for explicit payment instructions.

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

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

Given the tool's complexity (XML diff, multiple snapshot types, assignments), the description covers the most critical contextual aspects: what it compares, that it does not mutate listings, and the paywall behavior. However, it does not describe what the diff output looks like or what exactly 'ranks taxonomy changes' means, relying on a sample output URL. A more explicit description of the return format would make it complete, but the sample link helps.

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 0% schema description coverage and 5 parameters, the description must compensate by explaining parameter meanings. It only vaguely references 'seller-supplied Amazon Browse Tree reports' (relating to baseline/current) and 'supplied catalog assignments' (relating to assignments). It does not explain report_options, marketplace, or the structure of the snapshots. This leaves the agent guessing about critical inputs like marketplace_id and root_nodes_only.

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

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

The description clearly states the tool's core function with a specific verb ('diff') and resource ('Amazon Browse Tree reports'), and explains its scope: compares by node ID, ranks taxonomy changes, and flags catalog assignments. It distinguishes itself from sibling tools by focusing on drift analysis of browse node reports, which is not mentioned in any sibling description.

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

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

The description provides clear context on when to use the tool: whenever there is a need to compare like-for-like Amazon Browse Tree reports and detect taxonomy changes. It also implies usage constraints by stating it is a paid skill and returns payment instructions only, which tells the agent not to use it unless payment is arranged. However, it does not explicitly mention alternatives or exclusions, so it stops short of a 5.

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

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

The description discloses important behaviors beyond the readOnlyHint: it is deterministic, paid, returns payment instructions only, and does not change prices. It also includes payment URLs and a sample output link. This is significant additional value beyond the annotations.

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

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

The description is front-loaded with the core purpose in the first sentence. The payment instructions are lengthy but necessary for this paid skill, and the free sample output link is useful. No redundant sentences, though the payment URLs could arguably be compressed.

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

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

The description explains the core planning logic and payment behavior, but with no output schema it does not describe the response format after payment. The sample output link helps, but the description itself lacks detail on return values and the complete invocation flow (pay then get results). For a tool with this complexity, this is a clear gap.

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

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

Schema description coverage is 0%, and the description does not explain top-level parameters like as_of_date, rows, marketplace, currency_code, or amount_tolerance. It only vaguely references 'unit costs, contribution floor, and optional volume assumptions', which maps to row subfields but not the request structure. The schema has no descriptions on individual properties, leaving the agent to infer from names alone.

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

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

The description clearly states it is a deterministic Amazon Business offer-economics planner that combines referral fee discount rows and ranks time-limited candidates. It uses specific verbs like 'combines' and 'ranks', and explicitly scopes to Amazon Business referral-fee discounts, distinguishing it from sibling tools.

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

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

The description gives clear context: use it for planning/ranking time-limited referrral-fee discount candidates without promising demand or changing prices. It does not explicitly name alternatives or when-not scenarios, but the context is strong enough to imply appropriate use.

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

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

Beyond the readOnlyHint annotation, the description discloses critical behaviors: it is a paid skill requiring $0.50 per call, calls return payment instructions only, and mismatches are ranked with over/undercharge separated. This level of disclosure is essential for an agent to decide whether invoking the tool will yield immediate results vs. payment instructions.

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 longer than necessary but well-structured: core purpose in the first sentence, output behavior in the second, and payment instructions in the third. Each section carries operational importance, though the multiple URLs could be consolidated.

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

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

The tool has a complex nested-row schema and no output schema, yet the description does not explain how to provide rows, report dates, confirmations, or use amount_tolerance. It does include a sample output URL and describes mismatch ranking, but the input-construction gap prevents an agent from invoking it correctly without relying on 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?

With schema description coverage at 0%, the description must compensate, but it only vaguely references 'basis, percent, and flat terms' and 'recorded deductions.' The 10 parameters, including required confirmations, amount_tolerance, and report dates, are not described, leaving the agent without guidance on how to construct a valid request.

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 'Recompute every redacted Buy with Prime DTC order's service and payment-processing fees...' which names a specific verb, resource, and scope. It clearly distinguishes this tool from sibling fee verifiers by emphasizing seller-supplied terms and comparison of recorded deductions/net proceeds.

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 context is implied through phrases like 'from your own supplied basis, percent, and flat terms' and 'redacted,' but the description never explicitly states when to prefer this tool over other fee verifiers or what prerequisites must hold. No exclusions or alternatives are mentioned.

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

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

The description discloses significant behavioral traits beyond the annotations: it is a paid skill costing $0.50/call, that calling the tool 'returns payment instructions only' (so the agent knows it cannot complete the actual computation without payment), and it details the computation logic (credit capped at fee, no sales prediction). This fully informs the agent of unexpected behavior, and it does not contradict the readOnlyHint.

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

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

The description is longer than average but every part serves a purpose: it starts with the computational behavior, then clearly states the payment requirement and provides a sample output link. The payment section is verbose (multiple URLs and instructions) but necessary for a paid tool. It is well-structured with front-loaded functionality, though it could be streamlined without losing critical info.

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

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

Given the tool's complexity (paid, no output schema, custom computation), the description is remarkably complete. It tells the agent what inputs are used, what the tool computes, what it returns (net cost, break-even, ranking), the payment gating, and even provides a free sample output link. This leaves little ambiguity about expected behavior or invocation.

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

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

The schema description coverage is 0%, so the description must compensate. It explains the role of 'attributable-sales estimate' and 'reservation fee' and 'performance credit rate' in the computation, which adds meaning beyond the raw schema field names. However, it does not explain the top-level parameters (plan_label, currency, rows) or the structure of a scenario, leaving the agent to infer those from the schema. This is adequate but not comprehensive.

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

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

The description starts with a specific verb and resource: 'Recompute the reservation fee for every Capacity Manager scenario...' It clearly states the tool's function (compute net cost, break-even sales, ranking) and explicitly distinguishes it from sales prediction ('without predicting sales'). This goes beyond a generic statement and aligns with the tool's name.

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

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

The description provides clear context for use: it is for estimating net reservation costs and break-even levels, and it explicitly states that it does *not* predict sales, which tells the agent when this tool is not appropriate (if sales prediction is needed). However, it does not explicitly list alternative tools or conditions like 'use only when you have attributable sales estimates,' so it falls short of a full 5.

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

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

The description is exceptionally transparent about the most important behavioral trait: 'calling this tool returns payment instructions only' and 'this server never runs paid work for free.' This goes far beyond the readOnlyHint annotation by informing the agent that a call will not produce the forecast unless payment is completed, and that the tool does not modify coupons.

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 main functional sentence is a dense run-on that packs multiple actions into one sentence. The payment instructions are split into several sentences with two long URLs, which is necessary but somewhat verbose. The structure is logical (function first, then payment), yet not tight enough for a 5.

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

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

The description sufficiently explains that the tool is a payment gate and outlines the high-level calculation it would perform if paid. However, it does not describe the required input structure beyond a few domain terms, and with no output schema, it lacks details on the returned payment instructions or what the forecast results would look like after payment. This is adequate for a payment-gate tool but not fully complete.

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

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

With schema description coverage at 0%, the description carries the full burden of explaining parameters, but it only vaguely references 'discount' and 'clip fee' and 'planning budget.' It does not explain key fields such as forecast_start_date, forecast_days, currency, minimum_unit_contribution, or the many properties inside the rows array, leaving the agent to guess from titles and constraints.

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

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

The description begins with a specific, multi-clause sentence that exactly states the tool's function: combining discount and clip fee, calculating whole redemptions, projecting budget burn and exhaustion date, and ranking contribution risk. It clearly distinguishes this tool from siblings like amazon_business_fee_discount_planner by focusing on coupon budget burn-down.

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

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

The description provides explicit exclusions ('without predicting demand or changing a coupon') and clearly states that this is a paid skill that requires payment before any real work is done. However, it does not name alternative tools for when a seller needs other coupon-related forecasts, so it falls just short of a 5.

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

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

Beyond the readOnlyHint annotation, the description discloses that this is a paid skill ($0.50/call), that calling the tool returns payment instructions only, and that the server never runs paid work for free. It also notes the output ranks differences 'without claiming Amazon owes money,' adding significant behavioral nuance not present in annotations.

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

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

The core purpose is captured in one dense sentence, and the long payment instructions are necessary for a paid skill and well-labeled. The free sample output URL adds value. While long, each sentence earns its place.

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

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

The tool has a complex nested schema and no output schema. The description explains the computation and provides a sample output URL, but it leaves the agent without guidance on confirm flags, tolerance, and threshold semantics. The payment flow is clearly described, but operational parameter details are incomplete.

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 8 parameters and 0% schema description coverage, the description must compensate, but it only vaguely references 'source amount and exchange rate.' It fails to explain the required confirm booleans, amount_tolerance, high_fee_exposure_threshold, report_label, as_of_date, or the structure of the rows array.

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

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

The description specifies a clear verb and resource: recompute converted gross, conversion fee, and post-fee disbursement from supplied source amounts and exchange rates, then rank differences. This distinguishes it from sibling reconcilers by focusing on Amazon currency converter disbursement reconciliation. The title reinforces the niche.

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

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

The description implies usage when you have seller-supplied source amounts and exchange rates to reconcile, but it does not explicitly state when to use this tool versus alternatives like amazon_referral_fee_verifier or etsy_currency_conversion_reconciler. No exclusions or direct comparisons are provided.

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

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

The description adds significant behavioral disclosure beyond the readOnlyHint annotation: it reveals this is a PAID SKILL, that calling it returns payment instructions only, and that this server never runs paid work for free. It also clarifies the no-release-date limitation. This is critical non-obvious behavior not present in annotations.

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

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

The first sentence is dense and informative, front-loading the core purpose. The subsequent payment instructions, while lengthy and repetitive with URLs, are operationally necessary for a paid skill and earn their place. Some redundancy in domain repetition could be trimmed, but overall structure is efficient.

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

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

The description covers purpose, input expectations (seller-supplied rows), computation (component-sum verification), grouping dimensions, and payment behavior. Since there is no output schema, the free sample output URL helps fill the return-format gap. Missing parameter-level details for tolerance/currency prevent a perfect score.

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 schema description coverage at 0%, the description partially compensates by naming grouping fields (SKU, fulfillment channel, store, transaction type, deferral reason) and the row-component-sum verification. However, it does not explain key parameters like amount_tolerance, reporting_currency, or as_of_date beyond vague 'age bucket' and 'held value' references.

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

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

The description clearly states a specific verb and resource: 'Verify each seller-supplied deferred-transaction row's component sum, then rank the held value by age bucket, SKU, fulfillment channel, store, transaction type, and deferral reason.' It also scopes out release-date prediction, making its purpose unambiguous and distinct from any potential sibling tool.

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

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

The first sentence provides clear context for when to use this tool: when you need to verify deferred-transaction row sums and rank held value by specified dimensions. It also gives an explicit exclusion with 'without predicting a release date.' However, it does not name alternative tools or describe when to prefer one sibling over another.

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 annotation, the description discloses critical behavioral details: it is a paid skill costing $0.50 per call, returns payment instructions only, and specifies exact payment methods (x402/card) and endpoints. It also provides a sample output link. This significantly enriches the sparse annotations and contradicts nothing.

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 function in the first sentence, then provides structured payment instructions. While somewhat verbose with redundant phrases like 'this server never runs paid work for free', the payment URLs and details are necessary. The overall length is justified by the payment complexity.

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

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

The description covers the payment flow, immediate output (payment instructions), and provides a sample output URL. However, it does not describe the format of the analysis output or instruct how to configure the required input parameters. Given the absence of an output schema and the nested structure of some parameters, this leaves notable gaps.

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

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

With schema description coverage at 0%, the description fails to explain key parameters like snapshots, country_rules, and imbalance_review_threshold_units. The first sentence vaguely references 'snapshots' and 'seller floors' but does not map to the actual schema parameters. The agent is left to infer semantics solely from schema names and types.

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

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

The description uses a specific verb ('compare', 'rank') and clearly identifies the resource (FBA Multi-Country Inventory snapshots by SKU and country). It outlines distinct gap conditions (zero quantity, below floors, disappearing, imbalance), which differentiates it from sibling inventory tools. The additional payment-gating behavior is disclosed without obscuring the core purpose.

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

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

The description implies usage for monitoring EU inventory gaps and clearly states the paid nature, but it does not explicitly say when to use this tool versus alternatives or provide exclusions. The context of 'paid skill' and 'payment instructions only' gives some guidance, but there is no direct comparison to sibling tools.

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

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

The description discloses critical behavioral traits beyond the readOnlyHint annotation: it is a paid skill ($0.50/call), calling the tool returns payment instructions only, and it explicitly states it does not claim Amazon will reclassify the item. This is significant context for an agent deciding to invoke the tool.

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

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

The description is lengthy due to payment instructions and URLs, which are necessary but add verbosity. The core function is stated upfront, but the payment section is extended and could be streamlined without losing essential 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?

The description covers the tool's purpose, payment prerequisite, and a caveat about reclassification, but lacks details on output format, input constraints (e.g., row limits, unit enums), and alternative tool comparisons. The schema provides some of this, but the description does not fully contextualize the tool's role among many FBA-related siblings.

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

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

The description references key input concepts ('ordered package measurements', 'comparison weight', 'next-smaller boundaries') but does not explain specific parameters like units, confirmation flag, or how to supply the seller-supplied boundaries. Given schema description coverage is 0%, this partial guidance is helpful but not fully compensating.

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

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

The description clearly states the tool's function: compare package measurements and weight against next-smaller FBA boundaries, return exact reductions, and model fee savings. It uses specific verbs and identifies the resource (FBA size-tier boundaries), distinguishing it from sibling FBA tools like fee verifiers.

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

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

The description implies usage context ('your own next-smaller FBA boundaries', 'model per-unit and annual fee savings') but does not explicitly state when to use this tool versus alternatives or provide exclusions. It mentions the seller-supplied nature indirectly via the confirmation field but no explicit guidance.

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

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

The description fully discloses key behaviors: it returns payment instructions only, never runs paid work for free, and does not read or quote reviews. This goes far beyond the readOnlyHint and openWorldHint annotations, providing essential context about paywall behavior and data handling.

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 core sentence is well-crafted and front-loaded, but the description is dense and includes three additional sentences of payment instructions and URLs, which makes it longer than necessary. A more structured layout would improve scannability without losing essential 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?

The description covers the essential context: the paywall behavior (returns payment instructions only), the core functionality, and the constraint of not reading/qu0ting reviews. It also provides links for payment and a sample output. Given the absence of an output schema, this is reasonably complete, though it could mention potential error cases or the actual output format after payment.

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 0% schema description coverage, the description partially compensates by explaining the ranking criteria (latest occurrence, acceleration, star-rating impact) and mentions 'supplied' rows and 'positive themes' which relate to the rows and sentiment parameters. However, it does not explain parameters like report_label, as_of_month, or marketplace, leaving some param intent unclear.

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

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

The description clearly states what the tool does: 'Rank seller-supplied Amazon Customer Feedback topics by latest occurrence, month-over-month acceleration, and supplied star-rating impact, while keeping positive themes in a separate evidence-preservation list — without reading or quoting a review.' This provides a specific verb and resource and distinguishes it from other tools by emphasizing that it does not read or quote reviews.

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

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

The description implies when to use the tool (for prioritizing topic trends without exposing review content) and includes payment conditions, but it does not explicitly mention alternatives or when not to use it. The 'PAID SKILL' and 'returns payment instructions only' statements are useful for invocation decisions, but there is no comparative guidance against sibling tools.

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

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

The description goes far beyond annotations by disclosing the paid nature, the $0.50 per-call cost, the fact that calling the tool 'returns payment instructions only' unless paid, and the exact payment/API URLs. This is critical non-obvious behavior that an agent must know before invoking the tool.

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

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

The first sentence is dense and informative, and the payment details are necessary for safe invocation. The structure is front-loaded with the functional purpose, followed by payment instructions. It is slightly long but every sentence contributes essential 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?

Despite lacking an output schema, the description explains what the planner computes and displays (placement-fee saving, added freight, net saving) and provides a free sample output URL. The payment instructions and access behavior are fully covered. Minor gaps remain around exact output format and some parameter details.

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

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

Schema description coverage is 0%, but the tool description alludes to core inputs: per-unit placement fee, inbound freight, prep cost, total units, and baseline option. However, it never maps these to actual parameter names, and report_label and reporting_currency are not explained at all. Partial compensation only.

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

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

The description opens with a specific, actionable statement: total the per-unit placement fee, add freight and prep cost, rank by total landed cost, and show savings versus baseline. It clearly distinguishes itself from siblings like fba_placement_fee_reconciler by focusing on split-option planning rather than reconciling actual fees.

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

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

The phrase 'For each seller-supplied placement split option' provides a clear usage context: compare your own split options by landed cost. It does not explicitly mention alternatives or exclusions, but the intended scenario is evident and distinct from sibling tools.

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

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

The description clearly discloses the pay-per-call nature, the exact cost ($0.50 USD), and the critical behavior that 'calling this tool returns payment instructions only.' It also adds a methodological limitation ('without pretending to know Amazon's score weights') and provides payment URLs and a sample output link. These go well beyond the sparse annotations (readOnlyHint, openWorldHint) and give an agent a clear picture of side effects and constraints.

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 overly long and packed with repeated payment instructions, URLs, and explanatory asides like 'without pretending to know Amazon's score weights.' The essential behavioral disclosure ('returns payment instructions only') appears deep in the text, after a detailed service description, making it harder for an agent to quickly identify the tool's immediate purpose.

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

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

There is no output schema, and the description does not explain what a successful call returns beyond 'payment instructions,' nor does it describe the post-payment flow or the expected diagnosis output format. With 13 parameters and a conflicting dual-purpose narrative, the description is insufficient for an agent to understand the full invocation context, despite the free sample output link.

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

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

The schema has 13 parameters with 0% individual description coverage, and the tool description only names four component areas (excess inventory, sell-through, stranded inventory, in-stock rate) without mapping them to the actual parameter fields. It fails to explain the meaning or relationships of all required inputs, and the 'returns payment instructions only' statement makes it even less clear how these parameters are used by the tool itself.

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 first presents a detailed functional purpose ('Compare one seller-supplied IPI snapshot...') but then explicitly states 'calling this tool returns payment instructions only,' creating a direct conflict about what the tool actually does. The title and initial verb suggest a diagnosis tool, while the later disclosure reveals it is a payment-gating step. This muddles the tool's real purpose and could lead an agent to invoke it expecting diagnostic output.

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 a use case (comparing an IPI snapshot to thresholds) but does not explain when to use this tool versus alternatives, nor does it mention exclusions or the fact that the tool only facilitates payment rather than running analysis. No sibling comparisons or when-not-to-use guidance is provided.

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

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

The description goes well beyond the readOnlyHint and openWorldHint annotations. It explicitly discloses that the tool is a paid skill ($0.50/call), that calling it returns payment instructions only, and provides payment URLs. It also clarifies that it does not assert eligibility or mischarges, and describes the output as ranked signed differences. This is rich behavioral context.

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

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

The description is structured with the core algorithm first, then payment details and a sample link. It is somewhat long due to payment URLs, but each section serves a purpose. It is not overly verbose, and the key information is front-loaded.

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

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

The description explains the main verification process and payment requirements but does not detail the output format (beyond 'rank signed differences'), nor does it mention the seller_confirms_* flags or amount_tolerance. Given the tool's complexity (9 parameters, no output schema), the description could be more complete, but the payment and core algorithm are well covered.

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

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

With 0% schema description coverage, the description must compensate for parameter meanings. It does explain the core concepts: 'seller-supplied fulfillment-fee row' (rows), 'supplied size-tier and weight band' (rate_card), 'low-price or standard rate from your price threshold' (low_price_threshold), and 'recompute the total'. However, it does not explain other parameters such as seller_confirms_*, amount_tolerance, reporting_currency, as_of_date, or report_label, so the compensation is partial.

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

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

The description clearly states the specific algorithm: matching rows to size-tier/weight bands, selecting low-price or standard rates based on a threshold, recomputing totals, and ranking differences. It also explicitly distinguishes itself by saying 'without asserting eligibility or a mischarge', which separates it from other fee verifiers.

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 its scope through 'without asserting eligibility or a mischarge' and the paid-skill note, but it does not explicitly state when to use this tool versus alternatives like amazon_awd_fee_verifier or amazon_mcf_order_fee_verifier. There are no clear exclusions or alternative references, so usage guidance is only implied.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses key behaviors: deterministic, never claims causal lift, costs $0.50 per call, and critically that calling the tool returns payment instructions only. This provides essential context about the tool's actual execution model 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 front-loads the purpose in the first sentence, which is good. However, the payment details are verbose, with multiple URLs and instructions that could be condensed, making the description longer than necessary.

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

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

Without an output schema, the description must explain what will be returned, but it only states that calling returns payment instructions. The post-payment workflow (how results are delivered) and the meaning of 'separation into queues' are left unclear, leaving significant gaps for a complex 6-parameter 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 description coverage is 0%, and the tool description does not compensate by explaining the meaning of parameters like 'rows', 'report_period', 'report_label', or 'catalog_context'. It only vaguely references 'supplied periods' without mapping to schema fields, leaving the agent to infer usage from types and titles alone.

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

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

The description identifies the tool as a deterministic Amazon Brand Analytics Market Basket transform that preserves co-purchase ranks/frequencies and separates attachment candidates, which clearly states its function. It is specific about the resource and action, but does not explicitly differentiate from sibling tools by name; the purpose is still clear.

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

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

The description gives no explicit 'when to use this vs alternatives' guidance. It does warn that the tool is a paid skill and returns payment instructions only, which is a usage caveat, but it does not compare to other tools or specify conditions for use.

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

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

The description goes beyond the readOnlyHint annotation by disclosing a critical behavioral trait: it is a PAID SKILL and calling the tool 'returns payment instructions only' rather than directly executing the verification. This is a major operational detail that the annotation does not convey. It also clarifies that the tool does not claim Amazon billed incorrectly, adding behavioral nuance.

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 first sentence is dense and focused, but the description then expands into a lengthy payment section with multiple URLs and payment methods. While this information is essential, it could be condensed to a single line. The structure is acceptable but not as tight as the high-caliber example, which had zero 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?

The description gives a solid overview of the tool's core function and even hints at outputs (ranked arithmetic differences, positive/negative exposure). However, with no output schema and 8 parameters, it omits key details such as the meaning of amount_tolerance and high_exposure_threshold, and the exact format of results after payment. The sample output link partially compensates, but the overall description is not complete for an agent to fully understand the tool's behavior without additional inference.

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

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

The input schema has 0% description coverage for parameters, and the description only references a few of them: 'size-tier, weight-band, and delivery-speed rates' (corresponding to fee_rates) and 'order rows' (orders). It does not explain amount_tolerance, high_exposure_threshold, reporting_currency, or report_label, leaving significant parameter semantics unexplained. The description adds minimal value beyond the schema's field names.

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

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

The description uses specific verbs ('Join', 'recompute', 'rank') and clearly identifies the resource ('seller-redacted MCF order rows' and 'supplied size-tier, weight-band, and delivery-speed rates'). It distinguishes itself from sibling tools like amazon_referral_fee_verifier by explicitly stating it does not look up a fee and does not claim Amazon billed incorrectly, making its scope unambiguous.

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

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

The description provides clear context for when the tool applies: when you have seller-redacted MCF order rows and a rate table to verify fulfillment fees. It does not explicitly name alternatives or exclusions, but the phrase 'without looking up a fee or claiming Amazon billed incorrectly' implies the tool is for analysis rather than fee lookup or formal disputes. This is solid guidance, though not as explicit as naming a sibling 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?

It discloses that this is a PAID SKILL ($0.50 per call), that 'this server never runs paid work for free,' and that 'calling this tool returns payment instructions only.' This goes beyond annotations by revealing that the tool doesn't immediately execute analysis and requires payment first.

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 first sentence delivers the core purpose concisely. The rest is dedicated to payment instructions, which are necessary but lengthy, including multiple URLs and methods. It is structured and front-loaded, but less succinct than ideal.

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

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

The description covers the tool's purpose, input requirements, and the crucial paid-only behavior, with a link to sample output. It lacks details about the output format, but no output schema exists, and the behavior is well disclosed.

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

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

The description explains that snapshots are diffed and that sales/contribution value are used for weighting, mapping to the nested snapshot and row properties. However, it doesn't add meaning for top-level parameters like report_label, marketplace, or currency_code, which have 0% schema coverage.

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

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

Description clearly states the tool's function: 'Diff two to twelve seller-supplied Remote Fulfillment eligibility snapshots and rank offers whose cross-border eligibility or offer status was lost, gained, or flapped...' This specific verb+resource distinguishes it from sibling tools like amazon_browse_node_drift.

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

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

The description implies usage context by specifying the required input range (two to twelve snapshots) and that it is a PAID SKILL. However, it doesn't explicitly name alternatives or exclusions, so it provides clear context but not explicit when-not-to-use guidance.

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

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

The description discloses a critical behavioral trait not captured in annotations: this is a PAID SKILL ($0.50/call) and 'calling this tool returns payment instructions only,' with URLs for payment. It also clarifies that the audit does not 'decide a carrier cause or claim a charge is wrong,' adding context beyond the readOnlyHint=true annotation. There is no contradiction with the annotations.

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

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

The purpose is front-loaded in the first sentence, but the description then expands into a lengthy payment explanation with two URLs and a sample output link. While the paid behavior is essential to disclose, it could be condensed. The overall structure is logical but not optimally 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?

Despite a clear purpose, the description lacks essential context for an 11-parameter input with no output schema. It does not explain how rows should be structured, what the confirm flags mean, or what a successful audit response looks like beyond a sample URL. The sample output URL provides some context, but the description is still incomplete for an agent to correctly invoke the tool.

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

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

Schema description coverage is 0%, so the description carries the burden to explain parameters. It only vaguely references 'per-pound, per-box, or per-pallet quantities and rates' and 'your own supplied,' which maps to rate_basis and some quantity fields, but fails to explain required parameters like report_label, confirm_* booleans, settlement_date, or the meaning of amount_tolerance and large_adjustment_threshold. The description adds minimal value beyond parameter titles.

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

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

The description clearly states the tool's function: 'Recompute each seller-redacted Partnered Carrier estimate and final charge from your own supplied per-pound, per-box, or per-pallet quantities and rates.' This is a specific verb+resource+scope that distinguishes it from sibling fee verifiers such as amazon_awd_fee_verifier or amazon_fba_fee_verifier. The additional detail about ranking row types and not deciding carrier cause further clarifies its impartial audit 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—when you have your own rates and quantities to audit—via 'from your own supplied...' but does not explicitly state when not to use it or name alternatives among the many sibling verifier tools. Usage context is present but not made explicit with exclusions or alternative recommendations.

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 annotation, the description discloses critical behavioral traits: it never runs paid work for free, calling the tool returns payment instructions only, and it does not claim actual Amazon eligibility. This is valuable context that prevents the agent from expecting free execution or a real eligibility check.

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

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

The description is front-loaded with the core purpose, then moves to payment instructions and sample output link. It is longer than average but every sentence carries necessary information for a paid tool, including the paywall and URLs. It could be tightened but remains well-structured.

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

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

The tool has a complex nested input schema and no output schema, but the description provides the essential purpose, the paid behavior, and a sample output URL. It does not mention row limits (max 2000) or the confirmation flag, but the schema itself encodes those constraints, so the description is reasonably complete for an agent to invoke it correctly.

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

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

With 0% schema description coverage, the description partially compensates by referencing 'minimum discount and reference-price rules' and 'seller and contribution floors,' which map to the rules, seller_price_floor, and minimum_unit_contribution fields. However, it does not explain key parameters like report_label, snapshot_date, currency, or the confirmation flag, leaving the agent to infer them from schema titles and constraints.

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

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

The description states a specific action: 'Check planned Prime-exclusive prices against your own current copies of the minimum discount and reference-price rules, then compare the resulting rule ceiling with your seller and contribution floors.' It clearly identifies the resource (planned Prime-exclusive prices), the comparison logic, and the non-claim boundary ('without claiming Amazon eligibility'), which distinguishes it from a generic fee or discount tool.

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

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

The description clearly provides usage context: it is a paid preflight check that returns payment instructions only, so the agent knows it must handle the paywall. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a full when/when-not guideline.

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

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

Annotations already provide readOnlyHint and openWorldHint, but the description adds significant behavioral detail beyond them: the tool is paid ($0.50/call), never runs for free, the first call returns payment instructions only, and it deliberately avoids asserting Amazon charged incorrectly. These are valuable operational traits not visible in annotations.

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

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

The description is front-loaded with the core function followed by payment details. Payment URLs and warning about not working for free are necessary for a paid skill, but the wording is a bit redundant ('PAID SKILL' + 'this server never runs paid work for free'). Still, each sentence earns its place.

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

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

The tool has a complex computation and a paid workflow, but the description is ambiguous about the interaction model: it says calling the tool returns payment instructions only, leaving unclear when the actual verification is performed. It does not describe the output format, though a sample output link is provided. This omission prevents full completeness.

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 0%, so description must compensate. It explains the core computation parameters (units, unit_price, referral_fee_percent, per_unit_minimum_fee, amount_charged) and mentions high-dollar exposure (high_exposure_threshold). It does not clarify report_label, reporting_currency, or amount_tolerance, but those are straightforward and the formula provides key meaning.

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

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

The description states an exact formula (units x max(unit price x referral percentage, per-unit minimum)) and explicitly compares with amount charged, ranking discrepancies and exposure. This is a specific verb+resource description that distinguishes the tool from sibling fee verifiers like fba_fee_discrepancy_audit or fba_storage_fee_verifier, and even clarifies it does not claim Amazon charged incorrectly.

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 function is clear enough to imply use for referral-fee verification, but there is no explicit guidance on when to use this tool versus alternatives or when-not-to-use. The payment requirement is highlighted, but it does not mention exclusions or sibling tools, so guidance is only implied.

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

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

The description discloses a crucial behavioral trait beyond annotations: 'calling this tool returns payment instructions only' and 'this server never runs paid work for free'. This tells the agent that no actual verification will occur in the first call, only payment instructions. The readOnlyHint annotation is consistent with this behavior, and the detailed payment workflow (x402, card, free sample) adds transparency.

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, logically ordered sentence that front-loads the core computation before payment details. While the payment sentence is dense with URLs, the information is necessary for a paid tool. Overall, it is structured and all elements earn their place, though it could be slightly tightened.

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

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

Given the tool's paid nature, the description adequately covers input shape (rows of seller-supplied terms), core logic, and output behavior ('payment instructions only'). It lacks explicit mention of the amount_tolerance parameter and confirmation requirements, but the schema covers those. The absence of an output schema is mitigated by the statement that only payment instructions are returned.

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 0%, so the description must compensate. It mentions only 'refunded share, retained-fee percent, and cap' and 'redacted original referral fee' but omits other parameters like report_label, report_start_date, reporting_currency, confirm flags, amount_tolerance, and rows. The description does not guide parameter values or how to assemble the request beyond the core fee terms.

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 precisely states the function: verifying refund administration fees and referral-fee credits by applying seller-supplied terms to redacted original referral fees. It distinguishes itself from siblings like amazon_referral_fee_verifier by specifying the refund-specific computation and explicitly excluding term lookup or credit claiming.

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

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

The description clearly implies the use case: when a seller needs to verify refund-related fees against recorded amounts, including handling partial refunds and missing-source rows. It does not explicitly name alternatives or exclusions, but the boundary 'without looking up a term or claiming a credit is owed' provides guidance on when not to use it.

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

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

Discloses important behaviors beyond annotations: it is deterministic, does not handle customer data, uses transparent math, and crucially, calling the tool returns payment instructions only. The exact cost and payment flow are specified, leaving no ambiguity about side effects or requirements.

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

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

The description is front-loaded with the core purpose and cost, then follows with payment details and a sample URL. While somewhat dense, each sentence carries necessary information, and the structure is logical. The URLs add necessary length without being redundant.

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

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

Given the tool's paid-skill nature, the description fully covers the payment workflow, cost, alternatives, and sample output. It does not describe the exact structure of the returned payment instructions, but the 'Free sample output' link compensates. The lack of an output schema is mitigated by the explicit statement that only payment instructions are returned.

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

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

The description adds meaning by referencing report period values (WEEK/MONTH/QUARTER) and the nature of 'aggregate ... rows,' which helps understand the `report_period` and `rows` parameters. However, it does not clarify `report_label`, `marketplace`, or `currency_code` beyond the schema's own constraints, so the description only partially compensates for the 0% schema coverage.

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

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

The description states a specific action ('A deterministic Amazon Brand Analytics Repeat Purchase comparison') and outcome ('turns aggregate WEEK, MONTH, or QUARTER rows into strengthened, weakened, mixed, and insufficient-history queues'). It also explicitly clarifies the immediate behavior: 'calling this tool returns payment instructions only,' distinguishing it as a paid skill entry point from other 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?

Clearly marks the tool as 'PAID SKILL: $0.50 USD per call' and warns 'this server never runs paid work for free,' setting expectations that it should only be used if the user is willing to pay. It also provides alternative payment methods and a sample output link, giving practical usage context, though it doesn't explicitly state 'do not use if you don't want to pay.'

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

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

The description discloses critical behavioral traits: it is a paid skill, the server never runs paid work for free, calling returns payment instructions only, and it does not look up external thresholds. These go well beyond the readOnlyHint annotation, which only says it's non-mutating.

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

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

The description is front-loaded with the functional purpose, then payment instructions, then sample URL. It's somewhat long but every sentence carries information necessary for selection/invocation; the payment details are crucial for correct use.

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

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

The tool lacks an output schema, and the description only says calling returns payment instructions; it does not describe the audit output structure, but references a free sample output URL. The exact calculation logic for 'chargeable units above allowance' is unspecified, leaving some ambiguity.

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

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

The description surfaces the core input concept (per-product returns export) and references threshold and fee, but does not explain individual parameters like high_exposure_threshold or near_threshold_margin_percent. Schema coverage is 0%, so this partial compensation earns a baseline 3.

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

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

The description opens with a specific verb-resource pair ('Estimate Amazon returns-processing-fee exposure') and enumerates concrete sub-actions (flag rows, estimate chargeable units, total exposure by category). It also states a negative scope ('without looking up a threshold or asserting a fee was charged'), distinguishing it from fee-verifier siblings like fba_fee_discrepancy_audit.

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 the input (seller-supplied returns export) and clearly states why you'd use it (estimate exposure, flag high-return rows), but offers no explicit comparison to alternative tools or when-not-to-use conditions. The payment warning implicitly discourages casual calls, but no alternative tool is 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?

Annotations declare readOnlyHint=true, which the description reinforces with 'deterministic' (no state change). The description adds genuinely useful behavioral context beyond annotations: it's deterministic, it ranks candidates without causal claims, and it returns payment instructions only until paid. The paid-work behavior is the most important behavioral disclosure and is clearly present. It doesn't describe pagination or output truncation, but with no output schema the core deterministic+paid behavior is well covered.

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 dense single block that front-loads the core function in the first sentence, then covers the critical payment behavior. Every sentence earns its place; there is no filler. The payment details occupy about half the description, which is justified given their importance. Slightly long due to URLs, but the length is warranted for a paid tool.

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

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

The tool has a two-level nested schema (periods containing ASIN row arrays) and no output schema, plus a unique payment model. The description adequately covers the inputs (seller-supplied ASIN rows, two periods), the computation (all sales/funnel deltas), and the behavioral contract (paid, returns payment instructions). It omits the specific return format, but for a paid tool where the primary prerequisite is payment, the description is reasonably complete. A dedicated sentence on what the ranker output contains would push it higher.

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 0%, meaning the description must compensate for parameter meaning. The description mentions 'seller-supplied ASIN rows' and 'two-period' comparison, which maps to the baseline/current period params. However, it doesn't define the date formats, row constraints (min/max items, required fields), or how deltas are computed per field. The schema itself carries meaningful structure (required fields, patterns), so the description adds moderate context but doesn't fully compensate for zero coverage.

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

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

The description states a clear purpose: a deterministic two-period Business Report comparison that calculates sales/funnel deltas and ranks review candidates. The verb 'ranks' plus the resource 'Amazon sales+traffic ASIN trend' is specific. It distinguishes itself by the two-period comparison approach, though sibling differentiation is moderate given the many Amazon analytics tools present.

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

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

The description explicitly states what the tool does NOT do ('without inventing a cause or recovery forecast'), which is strong negative guidance. Critically, it discloses this is a PAID SKILL at $0.50/call and that 'calling this tool returns payment instructions only' - this is essential usage guidance an agent must know before invocation to avoid surprising paid calls. Payment methods are fully specified.

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

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

The description prominently discloses that this is a paid skill, that calls return payment instructions only, and provides the payment endpoints, challenge settlement method, and free sample link. This goes far beyond the readOnlyHint annotation and is critical behavioral context an agent needs to avoid unexpected 402 responses.

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 opening functional sentence is concise and informative, but the payment boilerplate is lengthy and repetitive—'PAID SKILL', payment URLs, and card purchase are all over-explained. While the information is necessary, it could be condensed into a cleaner structure with the functional part front-loaded.

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

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

The tool takes a complex nested request (up to 5000 row objects with 15+ fields) and has no output schema. The description does not explain how to structure the rows, what each field means, or what the output report will look like. The free sample link helps but is not referenced as a format guide, and payment instructions dominate the description.

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 0% and the description only vaguely references a few row fields (order/refund amounts, label payer/cost, policy flag, resolution, SAFE-T, status). It fails to explain report metadata parameters (report_label, dates), row_reference, return_reference, or other required fields. The description adds minimal value over the bare schema titles and does not compensate for the missing descriptions.

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

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

The description uses a specific verb ('reconcile') and resource ('seller-redacted MFN and Prime return rows') and details the key operations: ranking source-review mismatches and summarizing outflow by reason and SKU. This clearly distinguishes it from generic return-analysis tools and most sibling tools, which focus on other marketplaces or FBA-specific reconciliation.

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

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

The description establishes a clear context for use (Amazon seller-fulfilled return reconciliation) and even notes the paid-only behavior. However, it does not explicitly state when not to use this tool or mention alternatives (e.g., FBA reimbursement tools), so it falls short of the explicit when/when-not guidance required for a 5.

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

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

The description discloses significant behavioral traits beyond the annotations: it explicitly states 'calling this tool returns payment instructions only' and 'this server never runs paid work for free,' which is critical for the agent to set expectations. It also mentions 'no account-health prediction' as a limitation. These details add context not available in the readOnlyHint annotation.

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

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

The description is verbose, with a large portion devoted to payment URLs and instructions, which could be moved to a separate metadata field. While the first sentence is functional, the overall structure is not concise or front-loaded, and it reads more like a marketing/payment page than a focused tool 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?

Given the tool's complexity (nested snapshots, multiple metrics) and the absence of an output schema, the description leaves significant gaps. It does not describe the structure of the 'target-gap review queue' output, the exact meaning of the output, or how the trend math works. The free sample output link helps but is not sufficient for a complete understanding.

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 0% schema description coverage, the description must compensate for parameter meanings, but it only vaguely references 'snapshots' and 'count-to-rate reconciliation.' It does not explain key parameters like 'worsening_threshold_percentage_points' or 'rate_reconciliation_tolerance_percentage_points,' leaving the agent to infer their roles. This is insufficient given the lack of 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?

The description clearly specifies the tool's function: 'Turn two to twelve normalized, aggregate Amazon Seller Performance snapshots into a target-gap review queue' with specific details like 'count-to-rate reconciliation' and 'direction-aware trend math.' This distinguishes it from siblings by focusing on target-gap trend analysis for Amazon Seller Performance, not generic sales or traffic trends.

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 through the input constraints ('two to twelve snapshots') and the exclusion 'no account-health prediction,' but it does not explicitly state when to use this tool over alternatives or when not to use it. It lacks direct comparisons to sibling tools like amazon_sales_traffic_trend, making the guidance mostly 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?

The description explicitly discloses the paid nature, stating it costs $0.25 per call, the server never runs paid work for free, and calling returns payment instructions only. This goes beyond the readOnlyHint annotation and provides critical behavioral context about the payment gate. No contradiction.

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

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

The description is a single dense paragraph, but each sentence serves a purpose: function, payment warning, payment methods, and sample output. It is longer than ideal but compact enough given the need to communicate the paid-gate behavior.

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

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

The description covers the core purpose and payment gate but lacks details on many parameters and the expected output format. With 9 parameters and no output schema, the description is incomplete, though it does disclose the critical paid behavior. It's adequate but with clear gaps.

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

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

Schema description coverage is 0%, yet the description only explains a few parameters: fees, scenarios, and feature values. It does not explain the confirm flags (which are required with const true), report_label, marketplace, or reporting_currency. The description adds some meaning but does not compensate for the low schema coverage.

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

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

The description clearly states the tool applies Individual per-item and Professional monthly fees to up to 36 sold-unit scenarios and computes a break-even. This specific verb+resource framing distinguishes it from the many fee verifiers and other Amazon tools in the sibling list.

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

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

No explicit guidance on when to use this tool versus alternatives, but the first sentence implies the use case: analyzing selling-plan fee break-even. There are no exclusions or alternative tool mentions, so it's borderline implied usage rather than clear context.

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

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

Annotations already indicate readOnlyHint=true, but the description adds critical behavioral context: this is a paid skill, calling the tool returns payment instructions only, and it never runs paid work for free. This significantly exceeds what annotations provide and correctly warns users about the paywall behavior.

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

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

The description is reasonably concise and front-loaded with the core algorithm in the first sentence. The subsequent payment instructions, while lengthy, are relevant for a paid skill and include direct URLs. Overall it earns its place, but could be slightly 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?

With no output schema, the description explains the immediate return (payment instructions) and provides a sample output URL, but it does not clarify post-payment behavior or how the ranking output would be structured. The calculation algorithm is present, but some operational details remain missing for a tool with nested inputs and confirmations.

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

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

The description does not explain any individual parameters. Schema description coverage is 0%, so the description should compensate, but it only describes the algorithm, not the meaning of report_label, reporting_currency, or confirmation booleans. The parameter names are somewhat self-explanatory, but no added semantics are provided.

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

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

The description clearly states a specific calculation: multiply SIPP discount by eligible units, subtract packaging cost, and rank results. It names the exact resource (Amazon SIPP) and distinguishes from sibling fee estimators by focusing on SIPP discount net of packaging costs.

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

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

No guidance on when to use this tool versus other Amazon fee estimators or when not to use it. The only additional instruction is about payment, not usage context or 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?

The description is unusually explicit about the pay-per-call model: $0.50 USD, payment URLs, the 402 challenge, and the hard behavior that calling this tool returns payment instructions only. It also provides a free sample output link. This goes far beyond the readOnlyHint annotation.

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

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

The core functional sentence is concise and front-loaded. The payment instructions are lengthy but necessary for a paid tool; the phrase 'this server never runs paid work for free' is slightly redundant but not harmful.

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

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

There is no output schema and low parameter description coverage, so the description should compensate but does not fully. It explains the conceptual analysis and payment flow, but not the input contract, expected output format, or behavior after payment. The sample-output link helps but does not complete the picture.

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

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

Schema parameter description coverage is 0% and there are 9 parameters, but the description does not explain any parameter names, required fields, or how rows/product_economics are structured. It only gives generic phrases like 'supplied unit economics' and 'direct/halo purchases,' leaving the agent to infer the input contract from names alone.

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, compound outcome: turn a Sponsored Display report into a contribution-ranked review queue, separate direct from halo purchases, compute contribution/margin, and compare ROAS with net contribution. This clearly distinguishes the tool from the many sibling Amazon analytics 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?

It identifies the exact input scenario (seller-supplied Sponsored Display purchased-product report) and required economics, and warns that it is a paid skill returning payment instructions only. It does not explicitly state when to prefer an alternative or when not to call, so it is clear but not exhaustive.

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

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

The description adds crucial behavioral context beyond the readOnlyHint annotation: it is a paid skill, the server never runs paid work for free, and calling the tool returns payment instructions only. This is a significant disclosure that shapes expectations, though it does not cover other potential behaviors like rate limits or data retention, which are not required given the strong annotation baseline.

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

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

The description is well-structured and front-loaded with the core functionality in the first sentence. The subsequent payment information is essential and earns its place, though the inclusion of multiple URLs makes the description somewhat longer than strictly necessary. Overall, it is efficient with no filler.

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

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

There is no output schema, so the description should explain return values, but it only states that calling the tool returns payment instructions—not what the audit review queue contains or how results are structured. The complex parameter set and nested objects are also left mostly unexplained, leaving an incomplete picture for a tool of this 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?

With schema description coverage at 0%, the description must compensate, but it does not explain any of the 9 parameters (report_label, dates, confirm flag, tolerances, campaign structure). The mention of recomputing effective bids and comparing CPC hints at the purpose of some fields but does not provide concrete parameter-level guidance.

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

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

The description clearly identifies the tool as a deterministic review queue for Sponsored Products placement bid adjustments, specifying the inputs (seller-supplied aggregate placement rows and bid settings) and the computations (max effective bids, average CPC, spend share, ROAS). This distinguishes it from sibling tools like amazon_sponsored_display_halo_analyzer and ppc_kit, which address different aspects of advertising.

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 a use case (when you have seller-supplied placement rows and want a review queue) but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. The absence of comparisons to sibling tools leaves usage context only 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?

The description goes far beyond the readOnlyHint annotation by disclosing that it is a paid skill, that the server never runs paid work for free, and that calling the tool returns payment instructions only. It also explains the payment methods and provides a sample output link. This is critical behavioral information that the annotations 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 front-loaded with the purpose and follows with necessary payment details. While it includes multiple URLs and pricing information, every sentence serves a purpose. It is slightly long but not bloated, and the structure is logical.

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 complexity of the tool (batch rows, multiple metrics), the description covers the return values (total investment, unit contribution, break-even units, projected net, shortfall, additional units) and explains the paywall behavior. There is no output schema, so this coverage is essential. However, it does not explain how to construct the request (e.g., required fields, nested object structure), relying on the schema to do that.

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

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

The input schema has 0% description coverage for top-level parameters, and the description does not compensate. It mentions 'expected incremental-units estimate' and 'candidate parent ASIN' but does not explain plan_label, currency, or the structure of rows. The row's fields (e.g., selling_price, enrollment_fee) are only implicitly referenced in the output narrative, leaving the user to guess how to populate the request.

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

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

The description uses a specific verb 'Compute' and states exactly what it does: compute total Vine investment, unit contribution, break-even units, and optional projections. It also explicitly scopes itself by saying 'without predicting sales or recommending enrollment', which clearly distinguishes it from sales forecasting tools.

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

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

The description provides clear context on when to use the tool (break-even planning for Vine enrollment) and includes exclusions ('without predicting sales or recommending enrollment'). It does not explicitly name alternative tools, but the context is unambiguous and the 'PAID SKILL' note warns about the pay-per-call model.

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 annotation, the description discloses critical behavioral traits: it is a paid skill ($0.50/call), calling it returns only payment instructions, and it never runs free. It also explains processing boundaries (no reading text, no inferring cause). This is rich, non-obvious behavior that helps an agent set expectations and avoid misuse.

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 first sentence is dense and informative, capturing the core function. Payment details occupy significant space but are crucial for a paid tool. The wording 'this server never runs paid work for free' is somewhat redundant with 'returns payment instructions only', but overall the structure is clear and well-separated from the functionality sentence.

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

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

The description covers the tool's purpose, constraints, payment model, and immediate output ('payment instructions only'), and even provides a free sample output URL. Missing is a description of what the actual prioritized results look like after payment, but since the immediate output is explicitly payment instructions, the core expectation is set. The lack of an output schema is partially mitigated by the sample link.

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

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

The description explains the meaning of key row fields by referencing 'units', 'NCX rate', 'CX Health band', and 'top-reason labels', which map to schema properties. However, it does not clarify top-level request parameters like report_label, snapshot_date, or reporting_currency. With schema description coverage at 0%, the partial compensation is helpful but leaves gaps for constructing a complete request.

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: 'Rank aggregate seller-supplied Voice of the Customer rows by units and NCX rate'. It clearly details the algorithm—preserving CX Health band, grouping normalized top-reason labels—and explicitly states what it does not do ('without reading customer text or inferring cause'). This distinguishes it from generic prioritization tools and aligns with the title.

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

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

The description implies usage for aggregate seller-supplied VOC rows that need prioritization, but it does not explicitly state when to use this tool versus alternatives. It notes the tool never runs paid work for free and returns payment instructions only, which is a contextual clue, yet no sibling or alternative tools are referenced. Thus guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds valuable behavioral context: it states the tool is deterministic, returns payment instructions only, and provides a free sample URL. It does not contradict annotations and explains the pay-per-call model, which is critical for agent decision-making.

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 overly long due to detailed payment instructions and a free sample URL. The core purpose is stated upfront, but the inclusion of a lengthy payment process and URL dilutes the primary message. It could be more concise by separating payment info into a separate annotation or note.

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

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

Given the tool's complexity (6 parameters, nested object, no output schema, payment model), the description omits critical information: how to use parameters, what the output contains (beyond 'draft copy'), and prerequisites. The payment model is explained, but functional completeness is low.

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 0% schema description coverage, the description should compensate but fails. It does not explain any of the six parameters or the nested ProductFacts object. Only the word 'grounded' hints at using provided product facts, but no mapping to parameters is given. This leaves agents confused about required 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?

The description clearly states the tool produces a deterministic Amazon A+ planning brief with specific deliverables like draft copy, image direction, alt text, asset gaps, and claim-review steps. It distinguishes itself from sibling tools by focusing on A+ content planning, not generic listing or research tasks.

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

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

The description implies usage for creating an A+ content brief but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusion criteria. The mention of payment and sample output gives some context, but lacks direct usage direction.

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

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

The description aligns with annotations (readOnlyHint: true) by stating that calling returns payment instructions only, implying no data modification. It openly discloses the payment requirement and provides a free sample output link, offering full transparency about the tool's behavior.

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

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

The description is a single dense paragraph that efficiently covers purpose, payment, and an example link. While no unnecessary words are used, it could be structured into sections (e.g., purpose, payment, output) for better readability. It remains appropriately sized for the information conveyed.

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

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

The description covers the tool's purpose, payment model, payment methods, and hints at output via a free sample link. Given the complexity (paid skill, no output schema, 5 params), it provides adequate context for an AI agent to understand what happens when calling the tool, though it doesn't detail the exact output format.

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

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

The description mentions 'customer-supplied known names, forbidden terms, category wording, and marketplace references,' which maps to four of the five parameters. However, it does not elaborate on format constraints (e.g., maxLength, minItems) or the meaning of the 'candidate_names' parameter explicitly. Schema has no descriptions, so more parameter detail would improve clarity.

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

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

The description clearly states the tool's purpose: a deterministic collision and wording screen for brand names. It specifies the resource (candidate brand names), the action (screening), and the scope (up to 20 candidates against known names, forbidden terms, category wording, marketplace references). This distinguishes it from sibling tools, which are for other listing or compliance tasks.

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

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

The description explicitly states that this is a paid skill ($0.25/call) and that calling the tool returns payment instructions, not immediate results. It provides payment methods (x402 or credit card). This gives clear context for when and how to use the tool, though it doesn't discuss alternatives or when not to use it.

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

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

The description states it returns payment instructions only, which contradicts the initial copy generation claim. It mentions 'exact source ledger and fixed risky-phrase hold' without explanation. Annotations (readOnlyHint: true) are not contradicted but the description's behavior is inconsistent internally.

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?

Mixes purpose, payment instructions, and sample output link in one paragraph. Could be better structured with separate sections. The payment details are necessary but clutter the purpose statement.

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 complex schema (9 params, nested objects, 0% coverage) and no output schema, the description fails to clarify input semantics, output format, or the actual workflow (payment then generation?). Missing critical context for proper invocation.

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

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

Schema description coverage is 0%. The description only lists parameter names in a sentence but adds no detail about format, constraints, or relationships. For 9 parameters with required nested objects, the description provides zero semantic help.

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

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

Description initially states it generates copy blocks ('hero, story, pillar, call-to-action blocks'), but then immediately says 'calling this tool returns payment instructions only.' This creates confusion about the actual purpose – is it a copy generator or a payment gate? The primary function is unclear.

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

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

No explicit when-to-use or when-not-to-use guidance compared to sibling tools like 'a_plus_content_brief' or 'product_description_html'. The description mentions payment instructions but doesn't clarify the workflow or alternatives. The readOnlyHint is present but not explained in context.

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

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

Annotations declare readOnlyHint: true, which the description supports by stating it returns payment instructions only. The description adds valuable behavioral context about pay-per-call pricing and payment methods, but does not fully clarify the tool's primary action (returning payment instructions vs. performing the audit). No contradictions with annotations.

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

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

The description is relatively concise but includes essential payment details and a link. The first sentence defines purpose, but the second half shifts to payment instructions and sample output. Could be more front-loaded and avoid mixing service details with tool behavior.

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 paywalled nature and lack of output schema, the description omits key details about what the tool actually returns (payment instructions only vs. audit results after payment). The free sample link helps but does not substitute for a clear response format explanation. Incomplete for a tool with complex payment workflow.

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

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

Schema coverage is 0% with no parameter descriptions. The description mentions 'up to 100 CSV rows' (relating to csv_text) and enum options via marketplace, but does not explain field format, constraints, or defaults. The description adds minimal meaning beyond what the schema provides for two parameters.

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 defines the tool as a deterministic audit of CSV rows for various issues, but immediately states calling this tool returns payment instructions only, creating confusion about whether the audit is actually performed or just payment facilitation. The verb+resource is clear but the overall purpose is muddled by the payment disclosure.

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

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

No explicit guidance on when to use this tool vs. sibling tools like listing_audit or compliance_scan. The description does not state prerequisites, alternatives, or exclusions. Usage context is implied only through the audit capabilities listed.

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

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

Discloses that the tool is a paid skill, never runs paid work for free, and returns payment instructions on first call. Also mentions free sample output. These are behavioral traits beyond the readOnlyHint annotation (which is not contradicted). However, it does not fully describe what happens after payment (e.g., exact output format).

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

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

Description is efficiently structured with the main purpose first, followed by payment details and sample link. Every sentence adds value, though the payment section is somewhat lengthy. It is appropriately sized for the complexity.

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

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

Given no output schema, the description covers the main purpose and payment flow but lacks details on the return format (readability score, keyword coverage structure). The sample link partially compensates. It is adequate but not fully complete.

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

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

The description provides no individual parameter semantics; it only implies the tool takes bullets and product facts. With 0% schema coverage, the description does not compensate, leaving many parameters (e.g., focus_keywords, ProductFacts fields) unexplained.

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

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

Description clearly states it performs a deterministic readability pass on bullets across specific marketplaces, with scoring. It specifies the verb (rewrite/readability pass) and resource (bullets). However, it does not explicitly differentiate from sibling tools like listing_audit or title_optimizer, though the unique readability scoring is implied.

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

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

Description mentions payment model and that calling returns payment instructions, implying a two-step process. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among siblings. Usage context is implied by the nature of the tool (bullet rewriting).

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

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

The description discloses that the tool is deterministic, returns payment instructions only, and never runs paid work for free. This adds value beyond the readOnlyHint annotation (which is consistent). It also provides a free sample link, enhancing transparency. No contradiction with annotations.

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

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

The description front-loads the purpose but then includes a long payment block ('PAID SKILL: $0.25 USD per call...'). While important, this could be structured more concisely. The description is lengthy 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?

Given the tool has 11 parameters, no output schema, and low schema coverage, the description is incomplete. It does not describe return values or output format, and many parameter constraints (min/max, enums) are not mentioned. A free sample link is provided but internal behavior remains unclear.

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

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

The description mentions some inputs ('single-unit price, product and fulfillment costs, fixed order fee, percentage fee, target contribution margin') but does not explain all 11 parameters. For example, 'marketplace', 'bundle_sizes', 'candidate_discount_percents' are only generally referenced. With 0% schema coverage, the description fails to compensate adequately.

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

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

The description clearly states it's a 'deterministic price-scenario calculator that compares bundle sizes and candidate discounts' with specific inputs, which is a specific verb+resource. It distinguishes from sibling pricing tools like 'pricing_what_if' and 'deal_roi_calculator' by focusing on bundles and multipacks.

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

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

The description mentions it's a paid skill and provides payment instructions, but does not explicitly state when to use this tool vs alternatives like 'pricing_what_if' or 'deal_roi_calculator'. It implies usage for bundle/multipack pricing scenarios but lacks explicit guidance on selection.

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

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

The description discloses that the tool is a paid skill and that calling it returns payment instructions only, which is behavior beyond the readOnlyHint annotation. It also provides a free sample output URL. However, it does not describe the full behavior of what happens after payment.

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

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

The description is two sentences: the first states the purpose clearly; the second covers payment details. It is front-loaded and efficient, though the payment instruction is somewhat lengthy.

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 13 parameters and no output schema, the description should explain what the readiness report checks for each marketplace and what data is needed. It only says 'from one supplied product record,' which is insufficient for a tool of this 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?

The input schema has 13 parameters with 0% description coverage, and the description adds no parameter-level information beyond mentioning 'one supplied product record.' It fails to explain the meaning or required fields of the parameters.

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

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

The description clearly states the verb (produces a readiness report), the resource (product record), and the specific scope (four marketplaces: Amazon US, Walmart US, Shopify, eBay US). This distinguishes it from sibling tools that focus on individual marketplace aspects.

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

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

The description includes payment instructions and notes that it returns payment instructions only, but it lacks explicit guidance on when to use this tool versus alternatives. No 'when to use' or 'when not to use' context is provided.

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

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

The description transparently discloses that the tool is paid and will return payment instructions only if not paid, which is a critical behavioral trait. This adds significant context beyond the annotations (readOnlyHint=true) and aligns with them.

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

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

The description is front-loaded with the purpose but includes lengthy payment details that could be externalized. It is not optimally concise, mixing core purpose with operational instructions.

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?

While the payment model is explained, the description lacks details on the output format or behavior beyond 'matches, gaps, evidence fields, and ambiguous results.' For a tool with complex nested objects and no output schema, this is insufficient.

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

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

The description provides no information about the input parameters (product, candidate_nodes, max_suggestions). Despite 0% schema description coverage, it fails to compensate, leaving the agent to rely solely on schema titles and types.

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 defines the tool as a 'deterministic candidate ranker' that compares seller-supplied nodes with product facts, providing matches, gaps, and ambiguities. It is specific and distinct from the sibling tools, which are unrelated.

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 focuses on payment instructions rather than when to use this tool versus alternatives. It does not provide explicit scenarios or exclusions, leaving the agent without clear usage guidance.

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

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

The description discloses that the tool returns payment instructions only, which is a critical behavioral trait beyond annotations. However, it contradicts the tool name and initial description that imply it performs the claim check. This creates confusion about actual behavior.

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

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

The description is front-loaded with the core function but includes verbose payment instructions and URLs that could be separated. It is functional but not optimally concise for quick agent understanding.

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

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

For a tool with 4 parameters and no parameter descriptions, the description is incomplete. It fails to explain the optional parameters, output format, or the actual workflow after payment. A sample output URL is provided but does not substitute for inline documentation.

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 0%, and the tool description does not explain the meaning or constraints of any parameter. The optional parameters 'verified_claims' and 'forbidden_claims' are left completely unexplained, forcing the agent to guess their purpose.

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

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

The description clearly states the tool screens text for claims across specific marketplaces. It mentions 'deterministic phrase and evidence screen' which captures the core purpose. However, it does not explicitly distinguish from the sibling tool 'regulated_claim_check', limiting differentiation.

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

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

The description implies usage for claim checking on marketplaces, but no explicit guidance on when to use or not use alternatives like 'regulated_claim_check'. Payment instructions are provided but not usage context.

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

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

The description claims to perform a comparison but then states 'calling this tool returns payment instructions only,' which is contradictory. Annotations include readOnlyHint=true, which is consistent with a payment info endpoint, but the description overpromises functionality. The free sample output URL provides some transparency about expected behavior after payment.

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 overly long and burdened with payment details that belong in external documentation. The core functionality is stated upfront but followed by a wall of text about costs and payment methods, reducing readability. It could be trimmed to one sentence about the comparison and a link to payment docs.

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 complexity (7 parameters, nested objects, enums, patterns), the description is woefully incomplete. It fails to describe output format, monitoring specification details, or how to handle the returned payment instructions. The absence of any parameter guidance and output schema means the agent cannot use this tool correctly without external knowledge.

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 0%, and the tool description provides no explanation for any of the 7 parameters (e.g., 'before', 'after', 'watch_fields'). The description focuses entirely on payment and does not clarify parameter meanings or usage, leaving the schema to do all 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?

The description states it does a 'deterministic comparison of two seller-supplied competitor listing snapshots, with field-level changes and a bounded monitoring specification,' which clearly identifies the primary function. However, the inclusion of extensive payment instructions dilutes the core purpose. It distinguishes itself from sibling tool 'competitor_research' by focusing on changes over time.

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 lacks explicit guidance on when to use this tool versus alternatives like 'competitor_research.' It mentions that calling the tool returns payment instructions only, implying a prerequisite payment step, but doesn't outline typical use cases or exclusions.

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

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

The description adds behavioral details beyond the readOnlyHint annotation, including that it is a paid skill ($0.25 per call), that it never runs unpaid work, and that calling returns payment instructions. This discloses the payment gate and behavior, which is critical for the agent to understand before invocation. No contradiction with annotations.

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

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

The description is several sentences long, front-loading purpose but then adding payment details, URLs, and a free sample link. While the payment info is necessary, it makes the description less concise. It could be restructured to separate operational details from core purpose.

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

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

Given the complexity (paid skill, 4 parameters, no output schema), the description is incomplete. It does not explain the output format beyond 'source links and confidence scores', does not clarify that max_results is forced to 1, and does not describe the mode parameter. The free sample URL is external. Essential details for correct invocation are 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?

The input schema has 4 parameters with 0% coverage in schema description. The description mentions supported marketplaces and output fields but does not explain the 'mode' parameter (only one value), the optional 'marketplace' field, or the constraints on 'max_results' (capped at 1). The description adds little semantic value beyond what the schema already shows, failing to compensate for the lack of 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?

The description clearly states it extracts public product fields from specific marketplaces (Amazon, Walmart, eBay, brand sites) with source links and confidence scores. The verb 'extraction' and resource 'public product fields' are specific, and it distinguishes from sibling tools by focusing on competitor product data rather than listing creation or optimization.

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

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

The description provides context about payment requirements and that it returns only payment instructions unless paid, but it does not give explicit guidance on when to use this tool versus alternatives like competitor_change_monitor or other tools. The usage context is clear, but no exclusions or alternative suggestions are provided.

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

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

Annotations declare readOnlyHint=true, consistent with a read operation. The description discloses that the tool is a paid skill and that calling it returns payment instructions only, which is honest. However, it also claims to perform scanning, creating confusion. The behavioral description is partially transparent but inconsistent.

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 relatively long and includes payment URLs and a sample output link. While front-loaded with purpose, it could be more concise by separating the payment instruction from the core functionality. The structure is adequate but not optimal.

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

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

Given the tool's complexity (5 params, no output schema, paid model), the description explains the payment flow and provides a sample output link. However, it lacks details about the returned match structure and does not cover all parameters, leaving some aspects incomplete.

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

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

The input schema has zero description coverage (0%), and the tool description only mentions 'title, bullets, and description' among the five parameters. It omits 'product_name' and 'marketplace'. No additional meaning is added for the parameters beyond listing them, leaving gaps for the agent.

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

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

The description starts with a clear purpose ('deterministic scan ... returning each match'), but then immediately contradicts itself by stating 'calling this tool returns payment instructions only'. This internal inconsistency undermines clarity, leaving the agent unsure what the tool actually does.

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

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

No guidance is provided on when to use this tool versus its siblings (e.g., claim_check, marketplace_listing_copy_checker). The description focuses on payment mechanics but fails to specify the intended context or prerequisites.

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