AIsa Shopping & Marketplace

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

Annotations already declare destructiveHint=true and openWorldHint=true, so safety is covered. The description adds valuable behavior: independence of items (one failure doesn't cancel others) and per-call billing. These are not derivable from annotations and help the agent set expectations.

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

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

Three short sentences with zero filler. The action and limit are front-loaded. The phrase 'tool-router's batch_use' is redundant since it restates the tool name, but it's a minor flaw. Overall it is concise 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?

With annotations covering destructive behavior and an output schema presumably describing results, the description covers the key operational aspects: concurrency limit, independence, and billing. It doesn't mention error reporting formats, but those likely live in the output schema. It is sufficiently complete for a batch 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 100%, so the schema fully documents each parameter. The description adds no parameter-specific details. The calls parameter's description already explains the structure and batching context, so the baseline of 3 applies; the description doesn't need to compensate.

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 action (execute) and resource (operations) with a concrete limit (up to 20) and concurrency. It doesn't explicitly name the sibling 'use' for single operations, but the distinction is clear enough from the concurrency and limit. The redundancy of 'tool-router's batch_use' is minor.

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 guidance on when to use this tool versus the sibling 'use' tool. The schema note about 'steps at the same execution_level of a plan go in one batch' is helpful, but it lives in the schema, not the description. The description only implies batching via concurrency but doesn't state when to choose it over the single-operation alternative.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — no mention of the result-retrieval lifecycle, task readiness, or that results expire. With annotations carrying the burden, a 2 reflects a description that contributes essentially no 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?

It is a single short sentence with no wasted words, which is good, but the phrase 'ASINs of all its modifications' is ambiguous and the sentence is under-specified rather than genuinely 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?

An output schema exists so return values need not be described, but the description omits essential context for this tool's role: that it is the retrieval half of a submit/fetch pair and that the id must come from a prior submit task. For a task-result endpoint in a large sibling set, that gap matters.

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

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

Schema description coverage is 100% and the single 'id' parameter is well documented in the schema (UUID task identifier, usable for 30 days). The description does not mention the parameter at all, so it adds no meaning beyond the schema. Baseline 3 applies.

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

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

The description gives a verb-less statement of intent ('will provide you with information about the product and ASINs of all its modifications'), which roughly conveys retrieving Amazon ASIN data. However it never says the tool is a task-result fetch keyed by task id, and it does not differentiate from the sibling get_dataforseo_merchant_amazon_asin_fetch_html or from post_dataforseo_merchant_amazon_asin_submit.

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?

There is no when-to-use guidance at all. Critically, nothing tells the agent this endpoint retrieves results of a task previously created via post_dataforseo_merchant_amazon_asin_submit, nor when the html variant would be preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. However, the description adds zero behavioral context of its own and offers only filler text. There is no contradiction with the annotations, but there is no added value either.

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

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

It is short, but the single sentence is filler that does not describe the tool. Brevity that conveys nothing is not conciseness; the sentence does not earn 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 results-retrieval tool that must be paired with a submit task and is only valid for 7 days, the description supplies none of that connective context. Although an output schema exists, the description still omits the essential fact of what operation this is.

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

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

Schema description coverage is 100% and there is only one parameter, so the schema already carries the semantic load (UUID task id, 7-day validity). The description contributes nothing on top, which is the expected baseline of 3 when the schema is complete.

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 is boilerplate ('Description of the fields for sending a request:') that says nothing about what the tool does. It never states that it fetches Amazon ASIN HTML results, nor distinguishes it from get_dataforseo_merchant_amazon_asin_fetch or the sibling HTML-fetch 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?

No usage context whatsoever: no when-to-use, no prerequisite (e.g. that a submit task must run first), and no reference to any alternative like get_dataforseo_merchant_amazon_asin_fetch. The agent is left to infer everything from the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds no behavioral context beyond those structured fields — no mention of caching, rate limits, or when the language list changes.

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

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

A single short sentence with the resource front-loaded. It is efficient, though 'by calling this API' is redundant padding that could be dropped without losing meaning.

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

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

With an output schema present and zero parameters, the description needn't explain return values, and annotations carry the safety profile. However, for a lookup/reference tool in a large sibling set, it should at least hint at the intended workflow (e.g. use the returned codes in fetch/submit calls).

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. It correctly does not invent parameter 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 names a specific resource (supported Amazon languages) and implies a list-retrieval operation, so an agent knows what comes back. It does not differentiate from its closest sibling, get_dataforseo_merchant_google_languages, other than through the tool name, and the phrase 'by calling this API' is filler rather than substance.

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?

There is no statement of when to call this tool, what prerequisite workflow it supports (e.g. resolving language codes before an ASIN fetch), or how it differs from the Locations or Google-language siblings. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so the safety profile is covered. The description adds only the country-filter note and says nothing about the shape of the returned location list; with an output schema present, this is acceptable but thin.

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

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

Two short sentences, front-loaded with the outcome ('you will receive the list'). No padding, though the second sentence could name the consumer tool more precisely.

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

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

With an output schema present, return values need not be described, and annotations cover the safety profile. The definition is adequate for a zero-argument reference lookup, with only the cross-tool routing detail left implicit.

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

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

Zero parameters, so the schema carries nothing to explain and the baseline is 4. The country-filter mention is about a downstream task rather than this call's inputs, which is neutral rather than harmful.

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

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

States a specific verb+resource: returning the list of supported Amazon locations. It clearly distinguishes the resource from the Amazon ASIN/products/sellers siblings, though it does not explicitly differentiate from the analogous get_dataforseo_merchant_google_locations or amazon_languages.

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 sentence 'You can filter the list of locations by country when setting a task' implies this is a reference/lookup call to run before task setup, but it never says when to prefer it over a sibling or that it takes no input arguments.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered by structured data. The description adds no behavioral context at all — not the 30-day result retention limit (which appears only in the schema), nor what the response contains.

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 text is short but it is under-specification rather than conciseness — a truncated sentence with no verb, resource, or useful lead. It occupies space without earning it.

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

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

An output schema exists so return values need not be described, but the description still leaves the tool's purpose, prerequisites (a prior submit call), and the task-id lifecycle entirely unstated. For a fetch-by-id tool in a large sibling set, this is inadequate.

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 a single parameter with 100% schema description coverage, so the schema fully documents the UUID task identifier and its 30-day validity. Per the baseline rule for high coverage, a 3 is appropriate even though the description contributes nothing about the parameter.

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 is a dangling fragment, 'Description of the fields for sending a request:', which never states what the tool does. All meaning comes from the name and title; an agent reading only the description would have no idea this retrieves Amazon product results for a previously submitted task.

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 when-to-use guidance whatsoever, and no mention of the submit/fetch pairing (e.g. post_dataforseo_merchant_amazon_products_submit) or the sibling *_html variant that would help route the agent.

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, idempotentHint, openWorldHint and destructiveHint=false, but the description adds nothing beyond them — not the idempotency of repeated fetches, not the fact that the task id expires after 7 days (that detail lives only in the schema), and not the response shape. For a description that is effectively blank, this is a total gap.

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

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

The text is short but is a stub rather than a concise statement: it is a meta-sentence about fields that never describes the tool, so no sentence earns its place. Brevity here signals under-specification, not efficiency.

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?

Although an output schema and rich annotations exist, the description itself omits the essential context — that this fetches HTML results for a task id generated by a submit call, and that the id is only valid for 7 days. Given the large family of parallel amazon/google fetch and submit siblings, this omission makes correct tool selection very hard.

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% — the single 'id' parameter is fully documented in the schema, including the UUID format and the 7-day retrieval window. Per the high-coverage baseline, 3 is appropriate, since the description adds no parameter meaning of its own.

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 reads 'Description of the fields for sending a request:' — a placeholder boilerplate line that conveys no verb, resource, or scope. The only signal of what the tool does comes from the title, not the description, so an agent gains nothing from the text itself.

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 when-to-use guidance, no mention of the paired submit tool (post_dataforseo_merchant_amazon_products_submit), and no explanation that this retrieves results for a previously submitted task. The agent must infer the submit-then-fetch workflow from sibling names alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds the content of the payload (condition, pricing, shipment, rating), which is modest added value, but it omits the operationally important fact that the underlying task results are only retrievable for a limited window (30 days, per the schema) and that a task must already exist.

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

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

Two compact sentences, front-loaded with the resource being returned, with no filler. It is efficient, though the second sentence could have been spent on usage context rather than restating return fields already implied by the output schema.

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

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

An output schema exists, so explaining return values is not strictly necessary, and annotations cover the safety semantics. The remaining gap is that nothing tells the agent this is a task-id-based retrieval dependent on a prior submit call, which is the single most decision-relevant fact 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?

There is a single parameter with 100% schema description coverage, so the schema fully documents the UUID task identifier and its 30-day retention. The description adds nothing beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

The description gives a specific verb+resource: it returns a list of sellers for a specified Amazon product, and enumerates the data categories returned (condition, pricing, shipment, rating). However, it never states that this is a results-fetch by task id tied to a previously submitted task, so the link to the post_..._sellers_submit sibling is left implicit despite the title hinting 'by id'.

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 when-to-use guidance appears. The description does not say that the required id must come from post_dataforseo_merchant_amazon_sellers_submit, nor does it distinguish this tool from get_dataforseo_merchant_amazon_sellers_fetch_html or the other *_fetch siblings.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered and the description does not contradict it. However, the description adds absolutely no behavioral context — no mention of the 7-day result window (that fact lives only in the schema) or of HTML vs JSON payload 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?

It is short, but it is a vacuous placeholder rather than a concise statement of anything useful. Brevity here reflects missing content, not economy of expression.

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

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

An output schema and rich annotations exist, so return values and safety need not be repeated. But the description leaves an agent unable to tell this HTML fetch apart from the non-HTML sellers fetch or to understand that a prior submit call produced the required id, which is essential context for this tool family.

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 a single parameter with 100% schema description coverage, so the schema fully documents the id and the 7-day retrieval window. Per the baseline rule, this yields a 3 even though the description contributes nothing 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 is a placeholder — 'Description of the fields for sending a request:' — and states nothing about what the tool does. Any purpose signal comes entirely from the tool name/title, not the description, and the name alone does not distinguish this HTML fetch from get_dataforseo_merchant_amazon_sellers_fetch.

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?

There is no when-to-use guidance at all, no mention of the submit/fetch task lifecycle, and no differentiation from the ~24 sibling tools including the non-HTML sellers fetch and the corresponding submit endpoint.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond restating that a list is returned — no note that it is a static reference lookup, costs nothing, or requires no parameters.

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

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

A single short sentence with no filler; the purpose is front-loaded. It is slightly padded with the boilerplate 'by calling this API', which carries no information.

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

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

An output schema exists, so return-value structure need not be explained, and there are no parameters to document. The description is adequate for a simple no-arg reference lookup, though it omits any hint about the language values format or that this is a static enumeration.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey and the schema is trivially complete. Baseline 4 applies for a no-arg tool.

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

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

States a specific verb (receive/list) and resource (supported Google Shopping languages), and the title reinforces it. An agent can distinguish it from sibling google_locations or the *_fetch tools, though the description itself does not name the sibling it differs from.

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 indication of when to call this versus the many sibling reference-lookup tools (google_locations, amazon_languages, list_categories). There are no preconditions or exclusions stated; the agent must infer usage entirely from the name.

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

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

The description goes well beyond the annotations by disclosing a 43 MB response, that it is the largest response in the provider by two orders of magnitude, and that it is free upstream with no billing signal. This is crucial safety-relevant behavior that readOnlyHint and idempotentHint 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?

Every sentence earns its place: the core purpose, a loud warning with quantitative evidence, a concrete example, and the billing caveat. The warning is front-loaded and the red emoji draws attention without adding noise.

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 is complete for a zero-parameter tool with an output schema. It tells the agent what the resource is, why not to fetch it, how to obtain the data instead, and the key behavioral risk. The output schema covers return-value structure, so nothing necessary for correct use 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?

The input schema has no parameters, so there is no parameter burden on the description. Despite zero params, the description adds semantic value by giving a concrete location_code example (2840 = United States) and pointing to documentation for other codes, which helps an agent interpret output rather than requiring schema documentation.

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 and title clearly identify the resource as the list of locations accepted by Google Shopping endpoints. It is distinguishable from sibling tools like get_dataforseo_merchant_google_languages and Amazon-specific location tools by the explicit 'Google Shopping' and 'locations' scope, though it does not explicitly name those siblings.

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

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

The description gives explicit guidance: 'Do not call this from an agent.' It also provides an alternative action ('look other codes up in DataForSEO's documentation') and explains why the tool is unsafe for agent invocation due to response size. This is strong when-to-use and when-not-to-use 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered elsewhere. The description adds nothing behavioral (no mention of the 30-day retrieval window beyond what the schema already says, no auth or rate-limit notes) and does not contradict 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?

It is very short, but the single sentence is a meaningless placeholder that does not earn its place. Brevity here reflects omission, not efficient communication.

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

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

An output schema and rich annotations exist, so return values and safety need not be repeated. However, with an empty description an agent has no textual basis for distinguishing this fetch tool from the many sibling fetch/submit tools, leaving the definition incomplete on the dimension that matters most.

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

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

Schema description coverage is 100% and there is a single required 'id' parameter fully documented in the schema, so the schema carries the parameter semantics. The description adds no meaning of its own, which is the baseline-3 case.

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 is a placeholder ('Description of the fields for sending a request:') that states no verb or resource and merely gestures at schema documentation. Only the tool name and title convey what it does; the description itself provides no 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?

There is no guidance on when to use this tool versus the 24 sibling tools (e.g., the corresponding submit tool or the products_fetch tools). No context, no prerequisites, no alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description contributes nothing beyond that – no mention of the 30-day result retention window or what the call returns, even though the ID parameter's 30-day validity is behaviorally relevant.

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

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

It is short, but the single sentence is a template fragment with no content; brevity here reflects under-specification rather than conciseness. It is not front-loaded with any actionable information.

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

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

With a rich sibling set of fetch/submit variants and an output schema present, the agent needs help choosing this tool and understanding that it is the retrieval half of a submit/fetch pair. The description supplies none of that, leaving the definition materially 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?

Schema description coverage is 100% and there is only one parameter whose UUID format and 30-day lifespan are fully spelled out in the schema. The description adds no 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 is a placeholder sentence ('Description of the fields for sending a request:') that never states a verb, resource, or outcome. Only the title hints at retrieving Google Shopping product results by task id, and the description itself adds no distinguishing information over the sibling fetch 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?

There is no guidance on when to use this tool versus alternatives such as get_dataforseo_merchant_google_products_fetch_html, get_dataforseo_merchant_google_product_info_fetch, or the corresponding submit tools. No prerequisites or context are given.

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

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

Annotations cover readOnly, idempotent, non-destructive, and openWorld, but the description adds no behavioral context such as the 7-day result availability or any rate limits. It is entirely silent beyond a meta-statement about sending a request.

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 placeholder sentence that is under-specified rather than concise; it does not front-load purpose or any meaningful 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?

Though the low parameter count, rich schema, annotations, and output schema reduce the burden, the description still provides no indication of what the tool returns or how to use it. The title partially compensates, but the description itself is not complete enough.

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 single id parameter is fully documented in the schema, including the 7-day retrieval window and UUID format. The description adds no parameter detail, but baseline 3 applies when the schema does the heavy lifting.

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

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

The description is a placeholder ('Description of the fields for sending a request:') that does not state what the tool does or distinguish it from siblings. The title carries the purpose, but the description itself fails to provide any meaningful purpose statement.

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 alternatives like get_dataforseo_merchant_google_products_fetch or the submit tools. Nothing about the 7-day retrieval window or any usage context appears in the description.

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 mark the operation as read-only, idempotent, and non-destructive, the description adds valuable behavioral context: the DataForSEO envelope, where data lives, how status is communicated, and that rejected requests still return HTTP 200. This 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?

Four short sentences with no wasted words. The key purpose is front-loaded, the response envelope is explained in the middle, and the alternative tool is given last. 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?

For a one-parameter fetch tool with an output schema and safety-relevant annotations, this description is complete. An agent knows what to pass, what it will get, how to interpret the response, and how this tool differs from 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 single parameter is fully described in the schema as a DataForSEO task ID, giving the baseline of 3. The description enriches this by explaining that the ID comes from a task queued by the submit operation and maps to tasks[0].result, so the agent understands what kind of ID to pass.

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 exactly what the tool returns: buyer reviews (rating, text, author, date) for one Google Shopping product. It also distinguishes itself from the sibling for product specifications and sellers, so an agent can tell the tools apart without opening schemas.

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 names the prerequisite task created by post_dataforseo_merchant_google_reviews_submit and names the alternative sibling for product specifications and sellers. This gives clear when-to-use and 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is known. The description adds no extra behavioral context such as task retention, rate limits, or what the fetch operation returns. It is not contradictory, but it contributes nothing beyond the structured 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 one short sentence, but it is a useless placeholder rather than a concise statement of purpose. It does not earn its place and leaves the tool's role entirely unexplained.

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 fetch-by-task-ID tool with an output schema and many sibling submit/fetch tools, the description omits what is fetched, that the 'id' references a previously submitted task, and how it relates to the submit counterpart. Even with annotations and an output schema, the description is far too incomplete for correct tool selection.

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

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

Schema description coverage is 100%, and the single 'id' parameter is fully documented in the schema as a UUID task identifier usable for 30 days. The description says it concerns request fields but adds no parameter meaning beyond the schema, 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 is a generic placeholder, 'Description of the fields for sending a request:', with no verb and no resource. It does not state that the tool retrieves Google Shopping sellers results by task ID, so an agent would have to rely entirely on the name and 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?

There is no when-to-use guidance, no when-not-to-use guidance, and no mention of sibling alternatives such as get_dataforseo_merchant_google_sellers_submit or the Amazon equivalent. The description provides no routing information at all.

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. The description adds meaningful context: it is free, stops before any spend, and explains how price.model varies (quoted, list, dynamic, composed). It also clarifies that suggested_max_price_usd has headroom. This goes beyond the annotation flags and gives the agent a clear model of what happens.

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 moderately long but well structured: it opens with the core purpose, then explains the price model in a dedicated paragraph. No redundancy or filler. It front-loads the most critical information (contract fields) and then gives necessary detail about price semantics. Slightly dense but not overly verbose.

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 an output schema, so return values need no description. The description covers the key behavioral aspects (no spend, pricing models, max_price headroom) and clarifies edge cases like routes without a price. For a read-only informational tool, this is complete enough for an agent to use 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 description coverage is 100%, so parameters are already documented. The description adds some nuance, such as how arguments affect pricing and that required parameters may be needed before a price can be quoted. It also clarifies with_quote's purpose (one round trip, spends nothing). These are useful but not essential given the schema's completeness.

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

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

The description states a specific purpose: returning the full contract of one or more operations, including schemas, read_only, side_effects, price, and known_pitfalls. It clearly distinguishes this from executing operations (use, batch_use) and from discovery (search, list_categories). The verb 'get' and the noun 'details' align with the title, and the first sentence 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 implies the tool is used to assess an operation before spending (e.g., 'A quote authenticates like a call but stops before any spend'), and the schema says 'One operation_id from search', hinting at a flow. However, it never explicitly states when to choose this over siblings like use or search, nor does it give exclusions. The guidance is implied, not stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: the tool is free, requires no key, and can direct users to a category-specific endpoint that lists tools directly rather than through search.

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 moderately detailed but every sentence adds useful information: output scope, cost/auth, sibling differentiation, and endpoint usage. It is slightly longer than strictly necessary but remains well-structured and front-loaded with the 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?

For a zero-parameter, read-only tool with an output schema and safety annotations, the description is complete. It covers what the tool returns, the free/no-key access model, and provides the category endpoint for specialized use, leaving no essential gap for an agent to 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?

The tool has zero parameters, so the baseline is 4. The description includes a <category> placeholder only in the endpoint examples, not as a tool parameter, which is appropriate supplementary guidance rather than a parameter-semantics gap.

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: it presents the AIsa catalogue at a glance, including categories, servers, tool counts, and a dedicated category endpoint. It also distinguishes itself from search by explaining that the endpoint lists tools directly instead of via search.

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 usage context: use list_categories for a catalogue overview, and use the provided endpoint when you only need one category. It explicitly contrasts with search ('instead of via search') and notes tool-router has no equivalent, although it does not exhaustively cover all sibling 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 implies a read-style list delivery, while the annotations declare readOnlyHint=false, destructiveHint=true and idempotentHint=false. It says nothing about task creation, the extra charge for high-priority tasks, postback/pingback notification behavior, or that repeated calls create new tasks — all behaviors the annotations suggest but the text omits or contradicts.

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

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

One short sentence with a single clause, so it is structurally efficient and front-loaded. Conciseness is fine, but the single sentence is spent on the wrong content, so it earns only partial credit.

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 non-idempotent, destructive, open-world task-submission endpoint taking a required ASIN plus location/language, the description supplies none of the operational context an agent needs (submission vs. retrieval, cost, notification callbacks). An output schema exists but does not excuse omitting the write semantics.

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 never mentions the body array or any of its members (asin required; one of location_name/location_code/location_coordinate; one of language_name/language_code). Reported schema description coverage is 0% at the top level, so the description was obligated to compensate and does not; it only adds zero parameter meaning beyond the schema's own nested field descriptions.

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

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

The description reads like a retrieval endpoint ('will provide you with a full list of ASINs') even though the tool's name and its post_dataforseo_merchant_amazon_asin_fetch sibling show this is a task-submission call. The resource (Amazon ASIN data) is named, but the action is never identified, so an agent cannot tell what the call 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?

There is no guidance on when to use this versus post_dataforseo_merchant_amazon_products_submit or get_dataforseo_merchant_amazon_asin_fetch, and no mention of the submit-then-fetch asynchronous pattern implied by the sibling set. The reader is left to infer usage entirely from the name.

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

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

Annotations declare readOnlyHint=false and destructiveHint=true, yet the description frames this as an endpoint that "provides results," implying a safe read. It omits that a task is queued, that billing applies, that postback/pingback callbacks exist, and that results are retrieved separately. The description directly conflicts with the declared 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?

It is a single front-loaded sentence with no padding, so it is efficiently sized. However, the brevity is under-specification rather than genuine conciseness, since the one sentence conveys the wrong operation.

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

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

An output schema exists, so return values need not be described. But for a destructive, asynchronous task-submission tool, the description omits the task-creation model, cost implications, callback options, and how results are later retrieved, leaving the agent without essential operational 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?

Top-level schema coverage is 0% (the sole parameter is a body array). The description mentions only keyword, location, and language, adding no syntax or semantics beyond the required fields and ignoring the array-of-tasks structure, postback_data, depth, and pricing fields that the nested schema documents.

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 says the endpoint "provides results from Amazon product listings," which reads like a synchronous fetch. The tool name ("submit") and title ("Setting Amazon Products Tasks") indicate it creates an asynchronous task, so the stated purpose misrepresents what the tool actually does. It names the resource and key inputs but not the real action.

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?

There is no when-to-use guidance, no mention of the submit-then-retrieve workflow, and no differentiation from the many fetch siblings (e.g. get_dataforseo_merchant_amazon_products_fetch). An agent gets no help deciding between submitting a task and fetching results directly.

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=false, destructiveHint=true, and idempotentHint=false, but the description reads like a passive data-retrieval endpoint and never discloses that a billable, non-idempotent task is being created. Key behaviors such as task queuing, delayed results, and cost implications go unmentioned.

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 reasonably sized sentences that are front-loaded, but they spend their space describing the returned data rather than the tool's actual behavior, so the effort is misallocated.

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

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

An output schema exists so return values need not be documented, but for a submit endpoint whose results arrive asynchronously, the omission of task-creation semantics (async completion, postback/pingback, billing) leaves a significant 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?

The description only gestures at location and language settings, which map to a subset of the request fields. It adds no detail on the required asin or the task-control fields, though the nested schema property descriptions are themselves extensive.

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 resource (Amazon sellers for a given product), but the verb 'provides' describes the outcome data, not the action the tool performs. The tool name and annotations indicate it submits an asynchronous task, which the description never states, leaving the agent to infer the actual operation.

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?

There is no guidance on when to use this submit tool versus the sibling get_dataforseo_merchant_amazon_sellers_fetch, nor any mention of the two-step submit-then-fetch workflow. The agent must infer the async pattern entirely.

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=false and destructiveHint=true, so the description should reinforce that this is a mutating, credit-consuming task submission; instead the first sentence uses 'provides data', which reads as a read operation and pulls in the opposite direction. It discloses no cost, no async task lifecycle, and no notification behavior despite pingback/postback fields existing.

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?

Only two sentences, so nothing is bloated, but the structure is mis-prioritized: the output-data inventory is front-loaded while the actual submit action and its required-field constraint are relegated to sentence two.

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 mutating, open-world, non-idempotent task-submission tool with an async submit-then-fetch pattern and an output schema, the description omits the task lifecycle, cost implications, and how the result is later retrieved. An agent could call it but would not understand the workflow it is entering.

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?

Reported schema description coverage is 0% for the single top-level body parameter, so the description must compensate, yet it only restates the product_id/data_docid/gid one-of constraint that the nested schema already spells out verbatim. Location, language, se_domain, priority, and notification URL semantics are neither introduced nor summarized.

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 leads with what the returned data contains (description, images, rating, variations, specifications, sellers) rather than what the tool does, which is submit a task. The second sentence does clarify the task-setting action and its required fields, so purpose is recoverable, but an agent skimming the first sentence could mistake this for a read tool. It also never distinguishes itself from the sibling get_dataforseo_merchant_google_product_info_fetch.

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 the prerequisite that one of product_id, data_docid, or gid must be given, but gives no when-to-use guidance, no mention of the fetch sibling that consumes the submitted task, and no indication of when a submit-vs-fetch workflow applies. Usage context is left entirely to inference.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true and idempotentHint=false, so this is a non-idempotent write that bills and creates a server-side task. The description instead frames the tool as returning product data, implying a safe read, and omits task creation, cost (depth/priority charges), and async delivery details. This conflicts with the write/destructive annotations.

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

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

A single compact sentence with no padding, but it spends its limited space describing return values (title, rank, price, reviews) that the output schema already covers, instead of front-loading the submission action.

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 task-submission tool with a complex nested body and a destructive/non-idempotent annotation profile, the description omits the essential behavioral context (that it creates a task, that results are fetched separately, cost implications) and duplicates result-field information better served by the output schema.

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

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

The description conveys no parameter meaning at all; the top-level 'body' param carries a 0% schema description coverage. However, the nested item properties (keyword, location_*, language_*, depth, postback_url, search_param, etc.) are documented exhaustively inside the schema, so the schema largely does the work the description omits.

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 resource (Google Shopping products for a query) and enumerates the result fields, but it never states the actual action: this is a task-submission endpoint (name and title say 'submit'/'Setting ... Tasks'). Framed as 'will provide you with the list of products,' it reads like a direct-fetch tool rather than an async task creator, so the verb is misrepresented.

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 when-to-use guidance, no mention of the submit-then-fetch workflow, and no routing to any sibling (e.g., get_dataforseo_merchant_google_products_fetch, ..._product_info_fetch, ..._products_fetch_html). The agent is left to infer that this enqueues a job whose results arrive later.

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 valuable context beyond annotations: it discloses the asynchronous nature, the cost on submit ($0.001-$0.0015), that fetching is free, and the return of a task id. It does not contradict the annotations (destructiveHint true, readOnlyHint false) and provides additional cost and workflow details.

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, with about five sentences, and front-loads the core purpose. It includes essential operational details (cost, async behavior) without unnecessary fluff. Well-structured and 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?

For a submit tool with a detailed input schema and an output schema, the description covers the critical aspects: what it does, how to identify the product, the async flow, cost, and the matching fetch tool. It does not mention error handling or edge cases, but these are not essential for the primary use case.

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 has detailed descriptions for each field inside the body array, so the schema carries most of the parameter documentation. The description adds a useful hint about which fields to use (product_id, gid, data_docid) for identification, but does not explain the body structure itself. Since the top-level 'body' parameter has no description, the description partially compensates but not fully.

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 'queues' and the resource 'reviews of one Google Shopping product', and explicitly names the retrieval tool, distinguishing it from other submit tools for different data types (products, sellers, asin). The purpose is unambiguous and well-scoped.

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 guidance on how to identify the product (using product_id plus gid or data_docid) and explains the asynchronous flow, including which fetch tool to use afterward. It does not explicitly contrast with alternative submit tools, but the purpose and sibling names make the intended use clear.

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=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false. The description adds result content and location/language specificity, but it does not disclose the asynchronous task submission behavior, billing implications, or what destructive effect occurs.

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 sentences are reasonably sized and front-load the endpoint name, but they describe output rather than the tool's action. The middle sentence listing data fields is relevant but not tightly focused on invoking the submit 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?

For a complex POST task submission with a nested body schema, the description omits the async task behavior, required identifier combinations, billing/cost warnings, and depth/priority effects. Output schema covers return values, but the description does not make the tool sufficiently actionable.

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 reported at 0% for the top-level body parameter; although nested item fields are documented, the description itself adds no information about required product identifiers, location/language syntax, or the body array. It only alludes to location and language settings, which is insufficient to compensate for the coverage gap.

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

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

The description names the Google Shopping Sellers endpoint and describes the data returned, but it frames the tool as providing results rather than submitting a task. It does not distinguish the submit operation from the sibling fetch 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?

No when-to-use, when-not-to-use, or alternative-tool guidance is provided. The only pointer is to external List of Locations and List of Languages, not to sibling tools or task submission 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 discloses meaningful behavior beyond annotations: search spans the entire AIsa catalogue, candidates may belong to modules other than the current one, multiple providers for the same metric are surfaced, and no API key is required. This gives the agent a clear picture of scope and output 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 purpose and is dense with useful information: scope, no-auth requirement, response shape, and relationship to the catalogue. Each sentence adds operational value, and the structure makes the tool's behavior predictable.

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 discovery tool with output schema, the description is unusually complete: it explains the response modalities, candidate fields, direct pass-through to `use`, full-catalogue search behavior, and cross-provider visibility. An agent has enough context to invoke and interpret the tool 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 all parameters. The description adds value by explaining that the category parameter is not a hard boundary—search spans the full catalogue—and that queries are plain-language task descriptions, which clarifies how to use the tool effectively.

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 finds AIsa data operations across many categories via a plain-language query. It distinguishes itself from siblings like get_details and use by emphasizing that search covers the full catalogue, not just the pinned category.

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 conveys when to use search: when you need to discover operations across the full catalogue, even those not in the current tools/list. It also implicitly contrasts with get_details by noting that returned candidates already include input_schema, so they can be passed directly to `use` without an extra call.

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 readOnly=false, openWorldHint=true, and destructiveHint=true. The description adds valuable behavior beyond that: billing per call, the BatchCallResult response shape, and the error structure with retryable status. It does not spell out side effects, but the destructive flag is already carried by annotations, so the additional context is sufficient.

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

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

Three short sentences, each earning its place: purpose, cost, response shape, and routing guidance. Key behavioral facts are front-loaded, and nothing is redundant with the schema or annotations.

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

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

Given that an output schema exists and all parameters have descriptions, the tool description is complete enough for correct invocation. It covers cost, return/error contracts, and how routing to this tool differs from calling pinned tools directly, leaving no practical 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 100%, and each parameter is already clearly documented: operation_id as returned by search, search_id provenance, arguments matching input_schema, and max_price_usd as a spend guard. The description does not need to add parameter detail, so baseline 3 is appropriate.

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

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

The description opens with 'Execute one AIsa operation,' a specific verb+resource statement. The word 'one' distinguishes it from the sibling batch_use, and the closing note distinguishes it from calling pinned tools directly. An agent can tell what this tool is for immediately.

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 the tool: 'this is the way to call anything found through search.' It also gives the alternative: 'Pinned tools in tools/list can also be called directly.' This is clear when-versus-alternative guidance with no ambiguity.

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