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

Annotations already mark it read-only and non-destructive; the description adds valuable extra context by stating it calls the Account API, consumes no credits, and requires an API key. These details go beyond the annotations and help the agent understand the operation's real-world behavior.

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

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

The description is compact and front-loaded with the core purpose and the critical 'consumes no credits' fact. The second paragraph adds use cases and authentication requirements without filler. Every 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?

With no parameters, no output schema, and rich annotations, the description still fully explains what data is returned, when to use it, and the auth requirement. Nothing essential is missing for an agent to invoke this tool correctly and interpret its likely usefulness.

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

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

The tool has zero parameters, so there is no parameter surface for the description to document. The description focuses on what the tool returns rather than inputs, which is appropriate and makes the schema trivial to satisfy.

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 ('Check the Easyparser account') and enumerates exactly what is returned: plan, credit balance, reset date, rate limits, and daily usage breakdown. This clearly distinguishes the tool from all product- and seller-focused 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 explicit usage context: use before costly jobs, when the user asks about quota/plan, or for usage pattern analysis. It also explains that it consumes no credits, which helps an agent decide to call it. However, it names no alternative tools or explicit when-not-to-use scenarios, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. It adds useful behavioral context: it costs 1 credit, returns current BSR rather than historical data, and clarifies that a lower rank means higher sales velocity. Minor gaps like error handling or missing-BSR cases are not disclosed, but the burden is lowered by 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 concise and well-structured: purpose first, then when-to-use, then alternatives, then cost. Every sentence adds value and no information is wasted.

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

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

For a simple read-only tool with two well-documented parameters and no output schema, the description provides everything needed for a correct call: what it returns, how to interpret the rank, when to use it, when not to, and cost. Nothing essential is missing.

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

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

Schema description coverage is 100% — both asin and domain have full descriptions including pattern, enum, defaults, and usage guidance. The tool description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description starts with a specific verb and resource: 'Get a product's current Best Sellers Rank'. It further explains what BSR consists of (numerical rank and sub-category node identifiers) and positions the tool as lightweight and single-purpose, clearly distinguishing it from siblings like get_product_detail and get_sales_history.

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 guidance is explicit: 'Use this tool when you only need the rank', with concrete examples like daily rank monitoring. It also names alternatives and the conditions for choosing them — get_product_detail when price/rating/content are also needed, and get_sales_history for historical trends.

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

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

Beyond the readOnlyHint/openWorldHint/destructiveHint annotations, the description discloses important behaviors: results expire after 24 hours, an expired item returns a clear message, and the tool is free of per-call credits. It also explains that the returned data varies by job operation, adding context the annotations do not capture.

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 main purpose and organized into clear usage and expiration sections. It is somewhat longer than strictly necessary for a one-parameter tool, but each sentence contributes meaningful guidance, so the length is justified.

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 a single parameter and no output schema, the description covers what the return contains, how to identify the item, the expected call flow, and expiration handling. It could be slightly more explicit about the exact shape of the parsed result, but the examples and reference to the web UI modal provide adequate context.

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

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

The schema already describes item_id, and schema coverage is 100%, so the baseline is 3. The description adds value by telling the agent where to get item_id (from get_bulk_job_items) and that it is the same ID the Data Service calls a query ID, which helps disambiguate the parameter beyond the schema.

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

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

The description opens with a specific verb and resource: 'Fetch the parsed result data of a single bulk job item' and clarifies it returns the actual Amazon data produced by the item. It also distinguishes this from status-only tools by contrasting 'the DATA behind a specific item, not just its status' and by locating it within a typical flow after get_bulk_job_items.

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 guidance is explicit: use it after get_bulk_job_items when the user wants the data behind an item, and the typical flow list_bulk_jobs → get_bulk_job_items → get_bulk_item_result is provided. It also gives an alternative path for expired data by suggesting the matching real-time tool, which clarifies when to switch tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. It adds useful behavioral context beyond the annotations: this is a monitoring endpoint, it is free of per-call credits, and it exposes statuses like failed/invalid/pending/processing. It does not describe the response envelope, but the item-level fields are enumerated.

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 organized: a definition sentence, a usage paragraph, and a credit note. It contains some redundancy across paragraphs but every sentence adds practical value. It is not overly long for a tool with eight parameters and a debugging workflow.

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

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

There is no output schema, so the description carries the burden of explaining what the tool returns, and it does list the item fields. It also covers the key workflow, credit implications, and a downstream use of item_id. The only notable gap is the lack of an explicit response structure or pagination behavior explanation, though page/limit are in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds extra meaning on top of the schema. It explains that group_id comes from list_bulk_jobs, that status='failed'/'invalid' is the debugging use case, and that search_key is useful for locating a specific ASIN in a large job. This goes beyond the schema's field-level 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 has a specific verb and resource: 'Inspect the individual items inside a bulk job' and enumerates exactly what each item contains (input value, status, error message, credit cost, completion time). This clearly distinguishes it from sibling list_bulk_jobs, which lists jobs rather than item-level details, while the item-level scope is explicit.

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

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

The description gives concrete when-to-use guidance: debug a job after list_bulk_jobs shows failed_items or invalid_items > 0, and filter with status='failed' or status='invalid'. It also explains when to use search_key and how to follow up with the Data Service using item_id, which is actionable and specific.

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

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

Annotations already declare readOnlyHint and non-destructive behavior, so the added value comes from context: the tool inspects delivery to the callback_url, returns status and timestamps, and is free of per-call credits. This enriches the operational picture beyond the structured annotations without contradicting them.

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

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

The description is three sentences with no filler: purpose is front-loaded, the main use case is immediately clear, and the scoping options are stated economically. The free-credit note is useful and 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?

For a 9-parameter, optional-parameter read-only tool, the description covers the primary use case, scoping strategy, and expected output concepts. It doesn't enumerate every parameter, but the schema handles those details. A minor gap is the lack of any statement about pagination or response shape, but the absence is not critical given the schema descriptions.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful provenance for group_id ('from list_bulk_jobs') and reinforces the omit-vs-scope behavior. This is a modest but real improvement over the schema 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 names a specific verb and resource: 'Check webhook delivery logs for bulk jobs' and clarifies the deliverable ('whether completion notification was delivered to callback_url, delivery status, and timestamps'). It also frames the tool around a concrete debugging scenario, distinguishing it from siblings like get_error_logs and list_bulk_jobs without ambiguity.

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

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

The description gives an explicit trigger: 'Use this when a job shows as completed but the user's system never received the webhook.' It also explains the group_id scoping option and the all-jobs scan behavior. However, it does not explicitly state when to prefer an alternative sibling tool or when not to use this tool, so it misses the full 'when-not/alternatives' test.

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

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

Annotations already declare readOnlyHint and non-destructive behavior; the description adds useful behavioral context beyond that: it is a monitoring endpoint, it costs no credits, it returns both BULK and REALTIME channels, and it includes request_id plus query_params for tracing failures. 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 purpose, then gives usage triggers, filter guidance, and a credit-cost note. Every paragraph earns its place; there is only minor overlap between the row-fields list and the filter examples, but nothing wasteful.

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

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

Given that there is no output schema, the description compensates by spelling out the returned columns, the two error channels, filtering options, tracing capability, and pricing behavior. For an 11-parameter optional-filter tool, this is sufficiently complete for an agent to select and call 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?

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining which filters matter most, giving concrete error_code examples like 'WEBHOOK_ERROR_404' and 'SOMETHING_WENT_WRONG', and clarifying the BULK vs REALTIME channel semantics. It does not deeply expand page/limit or date semantics, but the schema already covers those.

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-resource pair ('List the user's API request error logs') and anchors the output to the Errors page of the web app. It clearly distinguishes this tool from the sibling data tools by stating it covers both real-time API errors and bulk job errors with specific fields.

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 lists trigger phrasings such as 'why are my requests failing?' and 'show me recent errors', and gives the main filter strategy. It does not name when-not-to-use cases or alternative sibling tools, so it stops short of full routing guidance.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it costs 1 credit, returns structured fee-category data rather than a human-readable string, and is designed for fee calculation. The only omission is a more detailed return format description, but that burden is reduced by the present 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 three sentences with no wasted words. It front-loads the tool's output, then covers usage guidance, the alternative tool, and credit cost. Every sentence contributes a distinct piece of decision-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?

For a low-complexity tool with two parameters, full schema coverage, and clear annotations, the description is sufficient. It explains what the tool returns, when to use it, when not to use it, how it differs from the nearest sibling, and that it costs one credit. No critical selection or invocation context is missing.

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

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

Schema description coverage is 100%, so the baseline of 3 applies: the schema fully documents asin and domain, including format, examples, defaults, and marketplace meaning. The description does not add parameter-specific semantics beyond what the schema already provides, which is acceptable given the complete 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 begins with a specific verb and resource: 'Get a product's precise physical and logistical attributes' and explicitly names the package dimensions and fee category. It also positions the tool as 'the FBA fee-estimation and shipping-cost tool,' which clearly distinguishes it from siblings like get_product_detail.

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

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

The description gives explicit when-to-use guidance: shipping, storage, FBA fees, or warehouse planning. It also provides a clear when-not-to-use and names the alternative: 'Do NOT use it for general product info — get_product_detail includes a human-readable dimensions string, but only THIS tool returns the structured fee category and exact measurements.' This is model guidance.

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

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

Beyond the readOnly/openWorld/destructive annotations, the description discloses credit costs, the extra cost of a_plus_content, and the constraint to provide either an identifier or a URL but never both. It could add more about rate limits or response shape, but the annotations already cover the safety profile and the added operational details are valuable.

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

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

The description is tightly structured: purpose and data scope first, routing guidance second, then operational constraints. Every sentence adds useful selection or invocation information, with no filler or repetition of schema details.

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

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

For a complex 7-parameter tool with no output schema, the description provides a full picture: what data comes back, which sibling covers narrower needs, how to choose identifier vs URL, cost implications, and the a_plus_content special case. The schema covers parameter semantics, so nothing essential is missing.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds extra semantic value by explaining the mutually-exclusive identifier/URL rule, the credit cost tied to a_plus_content, and the default behavior, which goes beyond what the schema states.

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

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

The description opens with a specific verb ('Fetch complete, structured information') and names the resource ('single Amazon product') plus an explicit list of returned fields. It distinguishes this tool from siblings like get_product_offers and get_bestseller_rank by emphasizing the full-product-profile scope.

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

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

It states 'Use this tool when you need a full product profile' and then explicitly routes narrower needs to alternative tools: get_product_offers for seller prices, get_bestseller_rank for rank only, and get_package_dimensions for shipping dimensions/FBA category. This gives an agent crisp selection rules.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds substantial operational behavior beyond the annotations: each page costs 1 credit, pagination should be minimized, filters are cheaper than pagination, and the result includes the Buy Box winner. This is the kind of cost and response context an agent needs 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 front-loaded with the most important information: what the tool returns and its purpose. Every sentence contributes value, including the cost warning and sibling differentiation. It is slightly longer than strictly necessary, but the extra length is justified by the pagination-cost guidance and the alternative-tool routing.

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

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

There is no output schema, but the description enumerates the key return fields (price, shipping, condition, fulfillment type, seller rating, Buy Box winner), making the result shape understandable. It also covers cost behavior, pagination strategy, filter alternatives, and when to use a sibling tool. For a read-only offer-list tool, this is complete enough for an agent to select and 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?

Schema coverage is 100%, so the schema already documents every parameter. The description adds useful semantic guidance beyond the schema by explaining that max_page should be kept at 1 unless the full list is needed and that condition/shipping filters should be preferred over pagination. It does not add per-parameter detail for all 7 params, but the schema is already comprehensive, so this is above baseline.

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

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

The description uses a specific verb and resource: it fetches the list of seller offers for a product and enumerates exactly what is returned (price, shipping cost, condition, fulfillment type, seller rating, Buy Box winner). It also distinguishes itself from get_product_detail by emphasizing the WHO-sells-at-WHAT-price use case, so a model can differentiate it from siblings.

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

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

It explicitly states when to use this tool ('when the question is about WHO sells the product and at WHAT price') and when not to, pointing to get_product_detail for product details. It also gives operational guidance: start with a single page, only increase max_page when needed, and prefer condition/shipping filters over pagination because it is cheaper.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond the schema: the credit-cost rule per month of history, the weekly aggregation of the response array, and the requirement to ask the user for the range. It does not detail response shape or pagination, but the core invocation behavior is well disclosed.

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 well structured with paragraph breaks: purpose, use cases, and cost rule. Most sentences earn their place. The 'time machine' analogy is slightly extra but aids understanding of the tool's positioning. Front-loaded with the core purpose before the detail.

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

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

For a read-only tool with three documented parameters and no output schema, the description covers what an agent needs to select and invoke it: metrics returned, weekly aggregation, cost behavior, and default guidance. It could mention more about the response structure or limitations, but the core decision-making context is present.

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

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

Schema coverage is 100%, so parameters are already documented in the schema. The description adds valuable semantics on top: the cost implication of history_range, the recommendation to default to 3 months, and the fact that weekly data is returned. This goes beyond the schema's enum defaults and justifies a score above baseline.

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

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

The description opens with a specific verb and resource: 'Retrieve a product's historical performance over up to 12 months' with weekly aggregated trends. It explicitly names the tool as the deepest competitive-intelligence tool and contrasts it with get_product_detail for simple price checks, clearly differentiating it from siblings.

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

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

It gives explicit use cases (trend forecasting, seasonality analysis, conversion-rate estimation, due diligence) and an explicit non-use case ('Do NOT use it for a simple current price check'), naming the cheaper alternative. It also provides a clear default behavior ('default to 3 months') and instructs to ask the user about the history range.

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?

While annotations already declare readOnlyHint=true and destructiveHint=false, the description adds meaningful operational behavior: 'Each page costs 1 credit' and the max page limit. It also frames the tool's depth relative to aggregate data. There is no contradiction with annotations, and the description provides useful context beyond the structured metadata.

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

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

The description is compact and front-loaded with the core purpose. Each paragraph earns its place: purpose, when-to-use, and cost/optimization tip. There is no filler or redundant restating of the schema.

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

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

Despite lacking an output schema, the description states the returned data (star ratings, comment text, dates), the key filters, the cost model, and the alternative tool. An agent has enough context to select and invoke the tool correctly, including how to approach 'dissatisfied customers'.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds value beyond the schema with the max_rating tip ('set max_rating to 3') and the credit-per-page context for max_page. It does not explain every parameter, but it enhances practical understanding of the filter 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 opens with a specific verb and resource: 'Read individual buyer feedback entries for an Amazon seller: star ratings, comment text, and dates'. It clearly states the filterable dimensions and explicitly distinguishes itself from the sibling get_seller_profile by calling itself the 'reputation deep-dive tool' and contrasting aggregate scores versus individual comments.

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

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

The description gives explicit when-to-use guidance: 'Use this tool when the user wants to read actual buyer comments about a seller, analyze complaint patterns, or audit service quality.' It also names the alternative tool for a different need: 'For aggregate reputation scores... get_seller_profile is sufficient and cheaper.' The 'max_rating' tip adds a concrete strategy for a specific use case.

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

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

Annotations already mark the tool read-only and non-destructive; the description adds meaningful operational behavior: each page costs 1 credit, starting with one page is advised, and sort_by can surface relevant products. It also reveals that the response includes refinement filters and that exclude_refinements can shrink payload size. 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 three short paragraphs are dense but not bloated: output scope, when to use, and key operational caveats each get one block. The most important disambiguation and cost warning appear early, and no sentence merely restates the schema.

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

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

For a broad catalog tool with no output schema, the description covers return contents, refinement filters, credit pricing, page limits, seller_id/url exclusivity, and sort options. Minor gaps like page size or specific error behavior are not critical given schema and annotations, but a fully complete description might state how many products are returned per page.

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

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

Schema coverage is 100%, so the baseline is 3; the description still adds value by explaining that one must provide EITHER seller_id OR url (never both), giving concrete sort_by enum examples, and noting the per-page credit cost tied to max_page. This raises it above the baseline without duplicating schema text.

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 action ('Extract a seller's full product catalog') and enumerates exact data fields (ASIN, brand, category, price, Prime, variants, rating) plus refinement filters. It is clearly distinct from get_seller_profile, which the description explicitly names as the reputation/legal-identity sibling.

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

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

It states concrete use cases (competitor inventory analysis, stock monitoring, pricing-strategy research) and gives an explicit exclusion: for legal identity or reputation, use get_seller_profile. It also gives tactical guidance about page credits and sort_by, so an agent knows when and how to select it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavior beyond annotations: 'Costs 1 credit' discloses a resource-consumption trait, and 'Provide EITHER seller_id OR url — never both' discloses an input-exclusivity rule. It stops short of describing failure/error behavior, but with strong annotation coverage the bar is lower.

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-organized into three focused paragraphs: what it returns, when to use it, and invocation constraints/cost. The purpose is front-loaded in the opening sentence. It is slightly longer than strictly necessary — the positioning line 'This is the supplier-verification and brand-protection tool' partially restates the opening — but every other sentence carries distinct information.

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

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

With no output schema, the description compensates by naming the return content (legal name, address, feedback trends over specific windows). It covers use cases, sibling routing, parameter exclusivity, workflow, and cost. Remaining gaps are minor: it doesn't specify what happens if neither parameter is provided or how the 'never both' rule is enforced, but with 0 required parameters and read-only annotations, the description is adequate for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by stating the mutual-exclusion relationship between seller_id and url ('never both'), which the schema does not encode as a constraint. It also explains how to obtain a seller_id via get_product_offers, complementing the schema's format 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 uses a specific verb ('Unmask') with a clear resource (Amazon merchant) and enumerates concrete outputs: legal business name, registered business address, and feedback trends over 30/90/365 days and lifetime. It further differentiates itself from siblings by declaring itself 'the supplier-verification and brand-protection tool' and explicitly contrasting with get_seller_products and get_seller_feedback.

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

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

Provides explicit trigger phrasings ('who is this seller?', 'is this merchant legitimate?') and compliance/invoicing scenarios. It names specific alternatives and the conditions that select them: 'To see WHAT the seller sells, use get_seller_products. To read individual buyer reviews about the seller, use get_seller_feedback.' It also gives a workflow hint to discover a seller via get_product_offers first.

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 signal read-only and non-destructive behavior, and the description reinforces this by explicitly saying it 'reads the SAME data as the Bulk Requests page' and that monitoring endpoints 'do not consume credits.' It adds valuable context about job status semantics, including partial_success meaning some items failed or were dropped, which goes well 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 well-structured and front-loaded: it states the primary purpose first, then use cases, then statuses, then cost behavior. Every sentence earns its place, and the user-facing example quotes make the tool's intent immediately clear without being bloated.

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 carries the burden of explaining return-value context; it lists the key row fields, meaning of statuses, and how to drill into items or webhook logs. It also clarifies credit usage and cross-app visibility, making the tool fully usable by an agent without needing to infer missing 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?

Schema description coverage is 100%, so the baseline is 3 and the schema fully documents all 7 parameters. The description usefully explains output fields and status semantics, but it does not add new meaning to the parameters themselves beyond what the schema already provides.

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

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

The description opens with a specific, concrete function: 'List the user's bulk extraction jobs with their progress,' followed by the exact row fields (operation, domain, status, counts, timestamps). It clearly separates this tool from siblings by directing users to get_bulk_job_items and get_bulk_webhook_logs for drill-down, so an agent can identify which tool to call.

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 explicit with concrete trigger phrases: 'Use this tool when the user asks about their bulk jobs: "is my job done?", "what bulk jobs are running?", "did the DETAIL batch finish?".' It also names alternatives for follow-up actions, such as passing group_id to get_bulk_job_items or get_bulk_webhook_logs, giving clear when-to-use and when-to-route-elsewhere guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it works WITHOUT an API key, returns a catalog of operations, and also includes supported Amazon marketplace domains. This meaningfully enriches what the structured data alone conveys.

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

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

Three sentences deliver the core purpose, high-value context (no API key), usage guidance, and additional return data (marketplace domains) with no wasted words. The most important behavioral instruction is front-loaded early.

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 discovery tool with a single optional parameter and no output schema, the description covers what is returned, when to call it, and the fact that no API key is needed. The agent has enough context to invoke it correctly and to know what follow-up action to take.

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?

There is only one optional parameter, and the schema already documents it fully with an enum and a clear description ('Get the usage guide for one operation instead of the whole catalog'). The tool description adds no new parameter-level information, so the baseline score of 3 is appropriate since the schema carries the burden.

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

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

The description clearly states a specific verb and resource: 'List all Easyparser operations available in this server,' and goes further to describe the content types (parameters, credit costs, example use cases). It also differentiates itself from the 16 operation-specific sibling tools by positioning itself as the discovery/catalog 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 explicitly says to call this tool first and to use it when unsure which tool fits the user's question, which is clear and actionable. It does not explicitly name alternatives or state when not to use it, but the context strongly implies that this is a pre-discovery step before selecting a sibling operation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds valuable behavioral traits beyond annotations: it costs 1 credit, guessing the wrong identifier_type returns no results, and ASIN is accepted as an input for validation. This goes beyond the schema and annotations without contradicting them.

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

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

The description is well organized: purpose first, then use cases, then the critical semantic warning, the sibling alternative, and cost. It is slightly verbose with the metaphorical 'bridge' sentence, but every sentence contributes operational value and the key guidance 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?

For a 3-parameter, no-output-schema tool, the description covers the input space, the main error condition, the sibling routing, and the credit cost. It does not detail the return payload beyond 'essential product snapshot,' but that is acceptable since no output schema exists and the core lookup purpose is clearly satisfied.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful parameter-level nuance: it stresses that identifier_type must match the code or results are empty, explains digit lengths for UPC/EAN/ISBN, and notes that ASIN is also a valid identifier_type for validation. This enriches the enum semantics beyond the schema's short 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 states a precise verb-resource pair: convert external product identifiers (UPC, EAN, GTIN, ISBN, JAN, MINSAN) into Amazon ASINs. It further scopes the output as 'an essential product snapshot' and explicitly names search_products as the sibling for keyword queries, distinguishing this tool from alternatives.

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

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

It gives explicit when-to-use context ('when the user has a barcode or standard product code') and a concrete when-not-to-use rule ('If the user gives a keyword instead of a code, use search_products instead'). It also warns that identifier_type must match and provides digit-length checks, which are actionable usage instructions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful non-obvious behavior: each page costs 1 credit, one page typically returns 20-40 products, and refinements must be discovered from a prior response. This goes beyond the annotations without contradicting them.

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

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

The description is well-structured and front-loaded: what it returns, when to use it versus get_product_detail, and operational guidance on cost and filtering. Every section earns its place; there is no filler or redundant restating of the tool name.

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 10-parameter tool with no output schema and a large sibling set, the description is impressively complete. It covers purpose, expected outputs, cost model, pagination guidance, exclusion of alternatives, and the refinement discovery workflow. The remaining details are handled by the 100% schema coverage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra value by explaining the relationship between keyword and url, recommending exclude_sponsored for organic analysis, and instructing users to first run a search and read the refinements field before passing refinement IDs. This is real semantic guidance beyond the schema.

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

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

The description opens with a specific verb-resource pair ('Search Amazon by keyword or a full search/category URL') and enumerates concrete outputs (ASIN, title, price, rating, review count, Prime status, badges). It also differentiates itself from get_product_detail by explicitly stating when not to use it, so an agent can distinguish it from the closest sibling.

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

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

Provides explicit when-to-use guidance ('market research, keyword analysis, and product discovery') and an explicit exclusion: if the user has an ASIN or product URL, do NOT search, use get_product_detail. It also gives practical guidance about page costs, result volumes, and how to discover valid refinement IDs before filtering.

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