Nexscope Ecommerce Data MCP

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

Annotations are minimal (readOnlyHint=false, openWorldHint=true), so the description carries most of the burden, yet it discloses nothing about the response shape, credit/quota consumption, rate limits, or pagination behaviour for a 34-parameter query. The word 'Query' frames this as a read, which sits awkwardly with readOnlyHint=false, though the description never actually states a write, so it is not a direct contradiction. Nothing tells the agent what a call costs or what comes back.

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

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

The purpose is front-loaded and clear, but the trigger list is padded with near-duplicates ('wholesale hot products' appears twice, alongside '1688 trending products' and 'trending product rankings'). Roughly half the text is keyword stuffing that could be collapsed to a few representative phrasings.

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 34-parameter filtering tool with no output schema, the description establishes the domain and intent but says nothing about result contents, defaults (pageType defaults to monthly), or result limits. The schema fully covers parameters, but the agent still lacks a picture of what the call returns and how much data it yields.

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% across all 34 parameters, including the weekly-vs-monthly date convention and the Simplified-Chinese keyword requirement, so the schema does the heavy lifting. The description adds no parameter 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 first sentence gives a specific verb and resource: query 1688 product bestseller billboard data for sourcing discovery and wholesale research. That is clearly distinct from product_detail or search_by_image in intent. However, it does not differentiate itself from the near-duplicate sibling nexscope_data_dl_product_billboard or from nexscope_1688_product_search, so the agent has no stated boundary for choosing among them.

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

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

Provides an explicit trigger list plus a strong fallback rule: trigger even when the user does not say '1688 billboard' but wants hot-selling wholesale products or sourcing opportunities. That is clear when-to-use guidance. It gives no when-not-to-use condition and names no alternative tool, so an agent deciding between this and the plain 1688 product search has no stated rule.

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 openWorldHint=true, while the description asserts a 'fixed read-only provider path' — a direct conflict with the structured safety signal. Beyond that conflict it discloses nothing about response shape, failure modes, or rate limits, and no annotations explain the write-permission flag.

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 padding, so it is structurally clean and front-loaded. But the brevity is achieved through omission rather than economy — the one sentence conveys almost no actionable content.

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

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

A detail-lookup tool with three parameters at 0% schema coverage, no output schema, and no useful annotations needs the description to explain the identifier, locale/currency effects, and return contents. None of that is present, so the definition is not sufficient to invoke 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 description coverage is 0% and the description adds no parameter meaning: it never mentions offerId, its numeric pattern, or what country/currency defaults affect (localization vs. pricing). With three undocumented parameters, the description fully fails 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 sentence restates a generic category ('returns normalized public ecommerce research data') rather than saying it returns a 1688 product/offer detail record for a given offerId. Nothing in the text distinguishes it from siblings like nexscope_data_alibaba1688_product_detail or nexscope_1688_product_billboard; only the tool name carries that specificity.

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 use this tool, when not to, prerequisites (a valid offerId), or which sibling to prefer for search/billboard/image-search paths. The phrase 'fixed read-only provider path' hints at provider routing but gives the agent no routing decision.

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

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

Annotations only supply readOnlyHint=false and openWorldHint=true; the description adds no behavioral context such as cost/credit consumption, rate limits, auth requirements, result volume, or pagination. It also never reconciles 'search and analyze' (a read operation) with readOnlyHint=false, leaving the agent unsure whether invoking it has side effects.

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

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

The purpose sentence is good and front-loaded, but the remainder is a keyword-stuffed trigger list with heavy duplication ('1688 product search', '1688 search', '1688 product selection', 'find suppliers', 'supplier search' appear repeatedly). It occupies far more text than the information it conveys, diluting the one sentence that matters.

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 33-parameter, zero-required search tool with no output schema, the description is complete enough on the 'when' but silent on the 'how' — no guidance on minimal viable calls, pagination behavior, or what a result set contains. Acceptable but leaves real gaps for an agent orchestrating a sourcing workflow.

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

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

Schema coverage is 100% and every one of the 33 properties carries a description with defaults and enumerated values (offerType, sortField, shiLiType, etc.), so the schema does the heavy lifting. The description adds no parameter guidance of its own — nothing on the keyWord/goodsUrl mutual exclusivity, Chinese-only keyword constraint, or which filters matter for which sourcing goal — so the baseline 3 applies.

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

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

The description names a specific verb and resource — search products on the Chinese 1688 wholesale platform — and adds domain context (Alibaba domestic B2B market) that makes the target unambiguous. It does not, however, distinguish itself from close siblings such as nexscope_1688_product_detail, nexscope_1688_search_by_image, or nexscope_1688_product_billboard, so the agent must infer the boundary.

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 abundant (indeed excessive) trigger context — sourcing, supplier discovery, keyword selection, price comparison, filtering by sales volume — plus an explicit fallback for users who never say '1688'. But it never states when NOT to use it or which sibling to prefer (detail lookup, image search, billboard ranking), so the routing decision among 1688 tools is left 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 already declare readOnlyHint=false and openWorldHint=true. The description adds return-field content and the scope of the search, but says nothing about auth, quota/rate limits, or side effects — and a 'search' tool being tagged non-read-only is left unexplained, which an agent might want clarified.

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

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

The opening two sentences are well front-loaded with purpose and return values, but the trigger-keyword sentences are a repetitive six-phrase list that inflates length without adding selection signal beyond the first two aliases.

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

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

For an 11-parameter tool with no output schema, the description covers purpose, output fields, and triggering adequately; the schema handles all parameter detail. Only missing pieces are any note on the required image source (exactly one of imageUrl/imageBase64/imageId) and pagination behavior across pages.

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 imageUrl/imageBase64/imageId constraints, pagination, price range, and sort/filter semantics are already documented in the schema. The description only adds a loose hint ('Use an image URL'), adding no syntax or format detail beyond structured fields — baseline 3.

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

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

States a specific verb+resource ('image-based product search on the 1688 platform') and enumerates the returned fields (title, price, MOQ, monthly sales, repurchase rate, trade score, seller identity). The '1688' qualifier distinguishes it from the many sibling image-search tools (Amazon, Temu, TikTok, CJ), though it does not explicitly name the near-identical nexscope_data_alibaba1688_image_search 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?

Gives concrete trigger conditions, including user phrasings ('1688 image search', 'reverse image search 1688') and an explicit broadening rule (trigger whenever an image URL is supplied and 1688 matches are wanted). No exclusion criteria are given and the overlapping nexscope_data_alibaba1688_image_search sibling is never mentioned, so it lacks 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?

The description is consistent with annotations (readOnlyHint=false, openWorldHint=true) — "create" matches a non-read-only, open-world generation operation. However, beyond that it discloses nothing about the long-running/async nature, cost, or that results likely need polling via nexscope_media_task_result; with 26 params and no output schema, that is a notable 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?

A single front-loaded sentence with no waste, which is good structurally, but for a 26-parameter multi-mode generation tool it is arguably too terse to be "appropriately sized" — the brevity comes at the cost of guidance rather than surplus.

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 26 parameters, multiple generation modes (A+, selling-point, size, model, white-background counts) and no output schema, the one-sentence description is far from complete enough. It omits how modes combine, whether counts can be zero, and how output is retrieved, which an agent needs before invoking.

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 every one of the 26 parameters is already documented in the schema, and the description adds only the concept of optional model/scene references. Baseline 3 is appropriate since 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?

States a specific verb and resource: "Create apparel ecommerce image sets from clothing images," plus the optional model/scene reference inputs. It does not name or differentiate against near siblings such as nexscope_ai_product_marketing_image_set_v4 or nexscope_product_scene_variations, so an agent must infer the split from names alone.

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 use this tool versus the many image-set/background/model siblings, and no prerequisites or exclusions. The only usage signal is the implied "apparel input required" from 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?

Annotations only declare readOnlyHint=false and openWorldHint=true; the description adds nothing about how generation behaves — no mention of latency, cost, whether it returns image URLs directly or a task id to poll (a real concern given nexscope_media_task_result exists), or how outputNum affects the response. The only added signal is that reference images are optional.

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 front-loaded sentence with no filler or repetition. It is efficient, though the size leaves the gaps noted in other dimensions unaddressed.

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

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

A 5-parameter generative tool with no output schema and no annotations about the return shape should say what comes back (URLs, count, task id). The description says nothing, leaving an agent unsure how to retrieve results or what the call costs.

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 prompt, imageUrl, style, scale and outputNum are fully documented in the schema itself. The description adds nothing beyond restating prompt and optional reference image; 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?

A concrete verb-plus-resource ('Create... scene images') with the output domain named ('product or lifestyle scene images'). However, it does not distinguish itself from near-neighbours such as nexscope_product_scene_variations or nexscope_ai_model_scene_background_replacement, which the name 'background generator' ambiguously overlaps with.

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

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

No guidance on when to reach for this versus the many sibling image-generation tools (banana_*, gpt_image_*, seedream_5_pro, wan_2_7, product_scene_variations) or the background-removal/replacement tools. No prerequisites, no exclusions, no cost or async-workflow caveats.

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

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

Annotations only tell the agent this is a non-read-only, open-world call. The description does not disclose whether generation is synchronous or returns a task ID requiring a follow-up (like nexscope_media_task_result), how many images come back, or that outputs are generated images rather than modified inputs — all critical for a generation endpoint.

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

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

One front-loaded sentence with no filler, and the core action leads. It is arguably too terse for the tool's complexity, but nothing in it 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?

Missing context: with only modelImageUrl required and no output schema, an agent needs to know what the response looks like (image URLs vs. task handle) and that at least one garment URL must accompany the model image. These gaps matter 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 all seven parameters are already documented with examples and constraints (20 MB, 385–4096 px). The description's mention of optional masks and original garment references merely restates the schema, landing at the 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?

A specific verb ('dress') and resource ('model image') plus the garment scope (upper and/or lower) make the function clear at a glance. However, it never distinguishes itself from close siblings such as nexscope_virtual_try_on or nexscope_ai_suit_virtual_try_on, so an agent reading only the description cannot tell which one to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no naming of alternatives among the many apparel/image-generation siblings. The 'upper and/or lower' phrasing hints that at least one garment input is needed, but no explicit rule is stated.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true. The description adds nothing about whether this is synchronous or async, whether the original image is modified or a new one returned, cost/rate limits, or that outputNum controls how many result images come back. For an open-world generation call that is a real gap. No contradiction with readOnlyHint=false.

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 front-loaded sentence with no filler, but it is terse to the point of under-specification rather than efficiently complete; nothing is wasted but little is delivered.

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 four parameters, no output schema, and a generative open-world operation, the description should say at minimum what comes back (image URLs?) and roughly how long or in what form. Nothing about returns or asynchronous behavior is stated, leaving the agent to guess how to consume results.

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 explains imageUrl constraints, the maskUrl option, personType values, and outputNum range. The description contributes no additional parameter meaning, which meets the baseline of 3 for fully documented schemas.

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: improving hand appearance in generated model or lifestyle images. That is clearly distinguishable from generic siblings like nexscope_image_inpainting or nexscope_smart_image_edit_manipulation_v3, though the description never names them or explains the boundary.

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

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

The phrase 'generated model or lifestyle images' implies the use case (fixing hands in AI-generated model photos) but gives no explicit when-to-use rules, no exclusions, and no pointer to alternative edit tools when the problem isn't a hand.

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 and openWorldHint=true, so the agent knows this creates external state. The description adds the useful behavioral detail that pose can be driven either by text or by a reference image, but says nothing about cost, latency, task/polling behavior (relevant given the sibling nexscope_media_task_result), or whether the two guidance inputs can be combined.

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 front-loaded sentence with the core action first and the input-mode constraint second; no filler, no restating 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 4-parameter generation tool with full schema coverage, no output schema, and annotations covering the safety profile, the description covers inputs and intent adequately. The remaining gap is operational: no hint about how results are retrieved (likely an async task) or how the returned images are delivered.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds semantics the schema lacks: prompt and postureUrl are alternatives ('either ... or'), which is not stated anywhere in the property docs. It still doesn't say what happens if both are supplied or whether one is required when the other is omitted.

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

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

States a specific verb and resource ('Generate model pose variations') plus the two input modes (pose prompt or posture reference image), which is enough to distinguish it from siblings like model_swap or virtual_try_on. It stops short of naming those siblings or stating how the output differs, so it is clear but not fully differentiated.

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 use case (you have a model image and want new poses), but never says when to prefer this over nearby tools such as nexscope_virtual_try_on, nexscope_ai_model_swap, or nexscope_ai_model_scene_background_replacement, nor any exclusions or prerequisites.

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

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

The annotations already indicate a non-read-only, open-world operation; the description adds useful context that it generates variants and accepts two distinct scene-input modes. It does not disclose whether generation is synchronous, whether it returns a task ID or media URL, or any cost/rate-limit behavior.

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

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

The description is a single front-loaded sentence with no wasted language. It states the operation and the two input modes efficiently.

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

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

For an image-generation tool with no output schema and minimal annotations, the description is too sparse. It omits return-value behavior, possible asynchronous task handling, and sibling-tool routing guidance that an agent would need to invoke it correctly.

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

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

With 100% schema description coverage, the schema fully documents all eight parameters. The description mentions the two optional scene inputs (reference image or text prompt) but adds no syntax or selection semantics 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 states a specific verb and resource: 'Generate scene variants for a model image.' This clearly identifies the core operation, though it does not explicitly differentiate the tool from nearby siblings such as nexscope_ai_background_generator or nexscope_product_scene_variations.

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

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

The description implies usage by explaining that the tool takes either a scene reference image or a text scene prompt. However, it does not state when to choose this tool over alternatives, when not to use it, or how to decide between the two input modes.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true, so the description carries most of the burden. It says nothing about whether generation is synchronous or returns a task/job id for later polling via nexscope_media_task_result, about latency, cost, or what happens to the supplied image URLs. Only the input composition is conveyed, which is purpose rather than 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?

A single front-loaded sentence with no filler; the core operation and its ingredient inputs appear immediately and nothing is repeated from structured fields.

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

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

This tool has 11 parameters. The 9 optional ones control style, scene blending, prompts, and output count, and their schema descriptions (including defaults and ranges) are detailed enough that an agent can invoke the tool correctly without more prose in the description.

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

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

Schema description coverage is 100%, so every parameter is already documented with examples, ranges and defaults. The description's mention of "optional masks, scene references, and prompt guidance" adds no semantics beyond the schema; baseline 3 applies.

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

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

States a specific verb and resource ("Generate model images") and describes the composition: source product image plus model head image, with optional masks, scene references and prompts. This distinguishes it conceptually from siblings like clothes changer or virtual try-on, but it never acknowledges the near-identical sibling nexscope_ai_model_swap_2_0, so the agent has no basis for choosing between them.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. Given a crowded image-generation sibling set (model_swap_2_0, model_pose_generation, model_scene_background_replacement, virtual_try_on), the description leaves selection 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 only declare readOnlyHint=false and openWorldHint=true; the description adds no behavioral context such as whether generation is asynchronous and returns a task ID (the presence of nexscope_media_task_result among siblings strongly implies it), cost/latency expectations, or failure modes for invalid URLs. For a paid, side-effecting generation call with thin annotations, that is a material gap.

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

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

A single front-loaded sentence naming the required inputs first and the optional controls second, with no filler. It is efficient, though the brevity leaves the tool under-explained rather than over-explained.

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?

This is a complex generative tool with 8 parameters and no output schema, yet the description says nothing about the return value (image URL vs. task handle), polling requirements, or the difference from the v1 sibling nexscope_ai_model_swap. An agent could invoke it but would not know what to do with the result.

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 every one of the 8 parameters is already documented with ranges, defaults, and examples. The description only echoes that segmentation and scene controls are optional, adding marginal meaning beyond the schema; 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?

States a specific verb and resource: generate model images from a product image plus a full model reference, with optional segmentation and scene controls. An agent can tell it is an image-composition/generation tool. However, it never distinguishes itself from the sibling nexscope_ai_model_swap, so which version to pick is left to guesswork.

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 exclusions, no named alternatives. It does not say when the optional segmentation mask or scene image should be supplied versus omitted, and it does not explain when to choose this over nexscope_ai_model_swap or nexscope_ai_model_scene_background_replacement.

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 openWorldHint=true, so the mutation profile is partly covered, but the description adds nothing beyond the trivial 'create' framing. For a generative, likely long-running job, it doesn't disclose that outputs are asynchronous / need polling via a task-result tool, that every image-count parameter defaults to 0 so at least one type must be requested, or any cost/time implications.

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 well-formed sentence with no filler, and the core purpose is front-loaded. It is efficient but borders on under-specification given the tool's complexity, which keeps it from a 5.

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

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

With 22 parameters, no output schema, and a broad generative workflow, the description would need to explain the output shape (set of images?), async retrieval, and how the many count/style parameters combine. None of that is present, so an agent cannot call this confidently without deducing everything from 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 schema already documents all 22 parameters including provider, resolution, aspect ratio, A+ counts and library IDs. The description only vaguely gestures at 'product images and brief inputs', adding no syntax, defaults, or cross-parameter dependencies (e.g. sellerPoint required unless isExtractPrePoint) beyond what the schema states. 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 gives a specific verb and resource — creating ecommerce product marketing materials such as selling-point images and A+ style visuals from product images and brief inputs — which lets an agent distinguish it from generic image-generation siblings like nexscope_banana_2_image_generation or nexscope_ai_background_generator. It stops short of naming a sibling or stating the scope boundary explicitly, so it lands at 4 rather than 5.

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

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

The description offers no when-to-use guidance: it never says when this composite marketing-image set should be chosen over the many single-purpose siblings (background generator, virtual try-on, product scene variations, plain image generation), nor does it state any prerequisites or exclusions. The agent must infer selection purely from the name and the 22-parameter schema.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true. The description omits key behavior for an image generation job: whether the call is synchronous or returns a task handle to poll (a nexscope_media_task_result sibling exists), cost/latency, and that masks must be pixel-aligned with their sources. No contradiction, but little added value.

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 front-loaded sentence with no filler; the core action comes first and the optional-mask capability follows. It is arguably too terse rather than too long.

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

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

A generative mutation tool with no output schema and no async/polling disclosure leaves the agent unsure what comes back and whether to wait or poll. The description does not compensate for the missing return-value information.

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

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

Schema coverage is 100%, so all five parameters are already documented with examples, including size and 20 MB limits. The description restates that garment and model masks are optional but adds no constraints or interaction rules 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?

Specific verb+resource: 'Dress a model image with a one-piece outfit or suit image.' The 'one-piece' qualifier implicitly separates it from the tops/bottoms clothes-changer sibling, though no sibling is named explicitly.

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

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

No statement of when to use this versus nexscope_virtual_try_on, nexscope_ai_clothes_changer_for_tops_bottoms, or nexscope_ai_model_swap. The only routing signal is the word 'one-piece', which the agent must infer as an exclusion.

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

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

Annotations only say readOnlyHint=false and openWorldHint=true; the description adds no operational context. It does not say whether generation is asynchronous and requires polling via nexscope_media_task_result, what happens on model/invalid-duration mismatch, cost implications, or how the saleCountry/targetLanguage localization affects output. For a heavy generation job this leaves the agent blind to the workflow.

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 front-loaded sentence with no filler. It is efficient, though extremely terse given 10 parameters and six required fields – brevity here shades into under-specification.

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 10 parameters, 6 required, no output schema, and only two weak annotations, the description should explain the async result flow and model/resolution/duration interdependencies. As written it tells the agent almost nothing it could not infer from the schema alone.

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

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

Schema description coverage is 100% and the videoType/videoTime cross-constraints are documented in the schema itself, so the schema carries the semantics. The description only echoes that settings are 'model-specific' without adding anything beyond what the schema already establishes.

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

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

States a specific verb and resource: 'Generate a product marketing video', and names the inputs (reference video, reference images, model settings). The word 'reference' distinguishes it from plain text-to-video siblings like nexscope_seedance_2_0_video_generation, but no sibling is named explicitly to confirm the distinction.

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 statement of when to choose this over alternatives – notably the model-specific video generators (seedance, kling, wan, hailuo) or nexscope_sales_talking_video. Nothing about prerequisites such as needing a publicly reachable reference video, or exclusions.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the agent knows this is not a pure read operation. The description adds useful security context by stating that access and refresh tokens are never accepted or returned, but it does not explain the side effects of starting authorization or what authorization creates or updates.

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

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

The description is two tightly written sentences with no wasted text. The main capability is front-loaded, and the token-safety constraint follows efficiently.

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 five-parameter tool with full schema coverage and no output schema, the description covers the core purpose and a key security constraint. However, it does not describe what the connection/profile metadata contains, what starting authorization returns, or how operation-specific behavior differs, leaving some context gaps.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, including operation-specific requirements for region, marketplaceId, and connectionId. The description does not add parameter-level semantics beyond what the schema provides, which is the baseline case for a fully documented 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 uses a specific verb and resource: it starts Amazon Ads OAuth authorization or returns connection/profile metadata. It is clear about the tool's scope, but it does not explicitly differentiate itself from nearby siblings such as nexscope_data_amazon_ads_authorize_url or nexscope_data_amazon_ads_profiles.

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

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

The description explains what the tool does but gives no explicit guidance on when to use it versus alternatives. It does not clarify how to choose among operation=authorize, operation=connections, and operation=profiles, nor does it name sibling tools.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true; the description adds genuinely non-obvious behavior: paths and provider methods are derived server-side (so no URL construction), and mutations are two-phase with a required confirmation step. It omits auth/connection scoping and preview-output semantics, so it stops short of 5.

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

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

Two sentences, zero filler, with the operation-ID restriction and the mutation-safety rule front-loaded. Slightly cryptic jargon ('sb/sd/sp', 'derived server-side') costs it the top score rather than any padding.

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, mutation-capable, open-world gateway with no output schema, the definition covers the safety-critical preview/confirm flow but leaves out where the allowed operation IDs are enumerated, what preview returns, and how confirm behaves on failure. Adequate scaffolding, but an agent would need external knowledge to use it confidently.

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

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

Schema coverage is 100%, so all seven parameters are already documented in the input schema, including action, confirmationToken, and payload filter conventions. The description only adds the constraint that operationId must come from the ads_manager.sb/sd/sp namespace, which is marginal added meaning over the schema's 'Exact catalog operation ID'.

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 it 'accepts only documented ads_manager.sb/sd/sp operation IDs', which gestures at a generic gateway for Sponsored Brands/Display/Products calls, but never states the actual verb (executes/forwards Amazon Ads API operations). It is not tautological, but an agent cannot tell from the text how this differs from the many nexscope_data_amazon_ads_developer_proxy_* siblings that appear to hit the same endpoints.

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 one concrete procedural rule — mutations must go through preview then confirmation — which is implicit guidance for how to call the tool. However, there is no when-to-use/when-not guidance, no pointer to where the operation catalog lives, and no routing versus the per-endpoint proxy 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 only declare readOnlyHint=false and openWorldHint=true; the description adds the valuable disclosure that this is an asynchronous three-phase lifecycle (create, then poll, then download by token), which the annotations cannot convey. It still omits what an agent needs to run that lifecycle safely: how long polling takes, whether tokens expire, and any auth/connection prerequisites beyond connectionId.

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 tightly packed sentence that front-loads the contract reference and then delivers the three branching rules in order. Nothing 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 14-parameter tool with a nested configuration object and no output schema, the description covers the most confusing part (which mode you are in) but leaves the heavy lifting of new-report composition to the schema. It is adequate to call the tool correctly, but an agent still has to infer interactions between configuration and the flat fields.

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 every parameter is already documented, including reportId and documentToken. The description usefully reinforces the mode-switching semantics of those two fields but adds no syntax, defaults, or guidance on how configuration replaces reportTypeId/adProduct/groupBy/columns. 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 names the underlying operation (get_report) and enumerates the three modes it performs: create, poll, and download an Amazon Ads report. It is a specific verb+resource statement, but it never distinguishes this generic reporting tool from sibling tools like nexscope_amazon_ads_sp_insights_report_download or nexscope_amazon_ads_sp_insights_report_status.

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 concrete mode-selection rules: omit reportId to create, supply reportId to poll, supply documentToken to download. That is a real when-to-do-what mapping. It stops short of saying when to pick this tool over the sibling report-status/download tools, so it is clear context without exclusions.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true, so the description's disclosure that this reuses existing Amazon Ads authorization and is a tokenized, asynchronous report job adds real behavioral value an agent needs. It still omits what the created report contains and whether repeated creates are idempotent or rate-limited.

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?

At two sentences it is tight with no filler, but the front-loaded sentence is infrastructure trivia about auth rather than the action being performed. The information density is good; the ordering and emphasis are wrong.

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, six parameters at 0% coverage, and a mutation annotation (readOnlyHint=false), the description should at minimum say what the create call returns (a reportId) and how the following poll/download tools consume it. It gestures at the lifecycle but omits the handoff details and any parameter meaning, so an agent cannot reliably invoke it.

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

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

Schema description coverage is 0% across six parameters, and the description explains none of them: timeUnit, detailLevel, advertiserAccountId and the date bounds are all undocumented. Worse, it introduces 'reportId' and 'documentToken', which are not in the input schema, which can mislead the agent about what to pass to this 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?

The description never states what the tool produces. It says only that it uses existing authorization and describes an async lifecycle ('Create once, poll by reportId, then download using a documentToken'), leaving the agent to infer from the name that this generates a Sponsored Products audience report. Nothing distinguishes it from the many sibling report tools (sp_insights_report_status/download, sp_search_impression_share_report, amazon_ads_reporting).

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 three-phase workflow (create -> poll -> download) is stated, but there is no guidance on when to pick this tool over the large family of amazon_ads report siblings, nor any prerequisites such as authorization state or which advertiser account to pass. The agent must guess selection criteria from the name 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?

The description adds real context beyond the annotations: it reuses existing Amazon Ads authorization and uses tokenized download handling, and the token flow implies the documentToken is single-use/obtained downstream. However, with readOnlyHint=false and no output schema, it fails to say what is actually produced (file, URL, bytes), whether the token expires, or what side effect justifies the non-read-only hint.

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 with no filler, and the workflow sequence is compact. The first sentence, however, leads with implementation detail ('Uses existing... tokenized download handling') rather than the action, which buries the point.

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

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

For a two-parameter terminal download tool with no output schema, the description should clarify the returned artifact and token lifetime. It covers the auth and token aspects but leaves the consumer without knowing what it receives or whether the token can be reused, which matters given readOnlyHint=false.

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

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

Schema coverage is 0%, so the description must carry the parameter burden. It names documentToken and ties it to the download step, which is the key semantic, but never explains where the token comes from (the status poll) or what connectionId means beyond 'existing authorization', leaving connectionId entirely undocumented.

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 never states plainly that this tool downloads an Amazon Ads Sponsored Products Insights report; the verb 'download' appears only inside the workflow clause 'then download using a documentToken'. An agent must lean on the tool name and the sibling status tool to infer the resource. The scope (sp insights report) and the exact action are never in one clear 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?

'Create once, poll by reportId, then download' gives sequencing context, implying this is the terminal step after nexscope_amazon_ads_sp_insights_report_status, but the alternatives are never named and there are no exclusions. The agent gets implied placement in a workflow rather than explicit guidance on when to choose this versus the reporting/status 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?

The description adds context that existing Amazon Ads authorization and tokenized download handling are used, which is useful beyond the annotations. It does not clarify polling behavior, possible status values, or why readOnlyHint is false for what appears to be a status-check operation.

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 only two sentences and avoids filler. The auth sentence comes first, while the workflow sentence is compact but slightly confuses input reportId with the output-side documentToken.

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 status-polling endpoint with no output schema and no documented connectionId, the description is too thin. It does not explain what status information is returned, how pending or failed reports appear, or how connectionId should be obtained.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It mentions reportId in the polling workflow but does not explain connectionId at all, leaving a required parameter undocumented.

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 implies polling a report by reportId, but never explicitly states that this tool retrieves the status of an SP Insights report. The name and title carry most of the purpose signal, while the description focuses on auth and workflow phrasing.

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 outlines a create-once, poll-by-reportId, then download-with-documentToken sequence, which gives implied usage context. However, it does not explicitly say when to use this versus the sibling nexscope_amazon_ads_sp_insights_report_download or what conditions indicate completion.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true, so the description's additions — that it reuses existing Amazon Ads authorization and returns tokenized downloads — are genuinely useful. However, 'poll by reportId' and 'download using a documentToken' refer to identifiers that do not appear anywhere in the input schema (additionalProperties=false, only connectionId/startDate/endDate/timeUnit/advertiserAccountId), leaving the actual call sequence ambiguous; report contents, latency, and format are also undisclosed.

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 and no padding, which is good. But the lead sentence spends the front-loaded position on implementation trivia ('existing Amazon Ads authorization and tokenized download handling') instead of what the report delivers, which is the information an agent most needs first.

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, zero parameter documentation, and minimal annotations, the description carries the full burden and falls short: no report metrics, granularity semantics (timeUnit DAILY vs SUMMARY), account scoping, or output shape. The async lifecycle is the only substantive thing conveyed, and even that is not reconcilable with the parameter list.

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

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

Schema description coverage is 0% for 5 parameters, so the description must compensate and it does not: startDate, endDate, timeUnit, connectionId, and advertiserAccountId are never mentioned or explained. The only identifiers it names (reportId, documentToken) are not input parameters at all, which adds confusion rather than meaning.

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

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

The description narrates a lifecycle (create, poll, download) but never states what the report actually is or contains — the agent must rely on the title/name for 'SP Search Impression Share'. It does not distinguish this from siblings like nexscope_amazon_ads_sp_audience_report, nexscope_amazon_ads_sp_insights_report_status, or nexscope_amazon_ads_sp_insights_report_download, which appear to cover adjacent report types and the same poll/download pattern.

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 explicit when-to-use or when-not-to-use guidance, and the many Amazon Ads siblings are never named. The create/poll/download sequence hints at a multi-step workflow but leaves the agent to guess whether polling and downloading happen through this same tool or through the separate *_status/*_download 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?

The annotations only say readOnlyHint=false and openWorldHint=true, so the description earns credit for disclosing two non-obvious traits: provider methods/paths are derived server-side (so the caller never supplies them) and mutations are two-phase with a single-use confirmation token. It does not cover error/rollback behavior or rate limits, but the two-phase commit disclosure is substantive context beyond annotations.

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

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

Two front-loaded sentences with no filler, and the most consequential constraint (documented IDs only) comes first. Given the complexity of the tool, however, the extreme terseness leaves no structure for discovering the operation catalog, which borders on under-specification rather than conciseness.

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

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

For an open-world, 7-parameter meta-tool with no output schema, the description covers the call contract but omits critical operational context: where the valid operationId catalog lives, what happens if a confirm fails or the token expires, and how reads differ from mutations in practice. Sufficient to attempt a call, insufficient to be confident without trial and error.

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 operationId, action, payload, queryString, connectionId, confirmationToken, and adType. The description only reinforces the operationId naming family; it adds no new semantics about payload shape or the preview/confirm token lifecycle beyond what the schema states. 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 identifies the tool as a dispatcher over 'ads_manager.sb/sd/sp operation IDs', which tells an agent it executes Amazon Ads operations generically. However, it never states the verb directly (execute/call an ads operation) and does not distinguish itself from sibling entry points such as nexscope_amazon_ads_manager, nexscope_amazon_ads_reporting, or the many nexscope_data_amazon_ads_developer_proxy_* tools. The purpose is inferable but not sharply drawn.

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 mutation workflow ('preview followed by confirmation') is real usage guidance and the constraint that only documented operation IDs are accepted narrows inputs. But there is no when-to-use-this-vs-alternative guidance against the many sibling Amazon Ads tools, and no prerequisites (connection setup, authorization) are described. Guidance is implied rather than explicit.

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

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

Adds behavior an agent cannot get from annotations: one prompt per call, no cross-call session state, and the requirement to re-summarize prior context for follow-ups. Also clarifies that url only supplements page context and must not be the Amazon homepage. Annotations (readOnlyHint=false, openWorldHint=true) are not contradicted, but the description does not address latency, auth, or cost of the open-world call.

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

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

Purpose and the one-prompt-per-call constraint are front-loaded, which is good. However the long comma-separated trigger phrase list ('Amazon Alexa, Alexa shopping assistant, Amazon smart assistant, AI shopping guide...') is padding that crowds out more useful guidance, and the description repeats the follow-up rule twice.

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?

No output schema exists, and the description does cover the return shape and the markdown/json format choice. Combined with the follow-up/session guidance, an agent has enough to invoke it correctly; only error handling and permission/rate-limit expectations are absent.

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

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

Schema coverage is 100%, so the baseline is 3; the description largely restates the schema (single-entry prompts array, url-optional page context). It does add the session-independence nuance for prompts, but says nothing about the format parameter beyond what the schema already 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?

States a specific verb and resource: initiate natural-language Q&A via Amazon's Alexa shopping assistant, and enumerates the return shape (guidance answers, product groups, ASIN lists, follow-up questions). That distinguishes it from keyword-style siblings like nexscope_amazon_search, though the tool never names an alternative directly.

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

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

Gives a broad but concrete trigger set (Alexa shopping assistant, conversational product selection, follow-ups) and explicitly extends the trigger to users who never say 'Alexa' but want natural-language product recommendations. It also explains the follow-up rule: summarize prior context and resend as a new prompts[0]. No explicit when-not-to-use or named alternative, so not 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 are thin (readOnlyHint=false, openWorldHint=true), so the description does real work by describing the returned data shape and the weekly/monthly/recent-N-days time slicing. It says nothing about cost, quota consumption, authentication, or why a pure lookup is flagged non-read-only — all relevant for an open-world external data API. No direct contradiction, but the behavioral surface is only partly 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 opening sentence is well front-loaded, but the second sentence is a sprawling trigger-phrase dump that repeats 'ASIN reverse keyword lookup, traffic keywords, organic ranking, ad ranking, search volume, Nexscope keywords, click concentration, week-over-week search volume' — largely duplicating terms already in the first sentence. This is trigger-stuffing rather than information, and it dilutes an otherwise good definition.

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 10 parameters but full schema coverage and no output schema, the description usefully compensates by enumerating the returned metrics and the time-window modes, which is exactly what an agent needs to interpret results. The one-ASIN-per-call limit and pagination are covered by the schema. Minor gap: no note on data latency or country defaults beyond what the schema states.

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 every parameter including the dense 'conditions' flag/period enumeration is already documented. The description adds no syntax, defaults, or format guidance beyond what the schema carries, 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 first sentence states a specific verb and resource: reverse-lookup traffic keywords for a given Amazon ASIN, and enumerates the metrics returned (organic/ad rank, search volume, traffic share, ABA TOP3 concentration, conversion rate). That is far more specific than a tautology. However, it never distinguishes itself from close siblings such as nexscope_amazon_traffic_keywords, nexscope_amazon_asin_traffic_summary, or nexscope_data_sf_asin_keywords, so an agent facing those options gets no routing signal.

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?

Trigger conditions are stated clearly and in operational terms: the user mentions ASIN keyword analysis, reverse lookup, competitor keyword peeking, or traffic-driver analysis, plus the useful catch-all that it applies even when 'Nexscope' is not named. What is missing is the other half of routing guidance — when NOT to use it and which sibling to prefer for keyword-first or summary-level questions.

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 openWorldHint=true, so the agent knows mutation semantics are ambiguous, but the description adds nothing about cost, data freshness, or what 'current period' means. There is no disclosure of rate limits, credit consumption, or how the 10-ASIN cap behaves on overflow. Almost all of the text is trigger keywords, not behavioral context.

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

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

The first sentence is well front-loaded, but the rest is a long comma-separated trigger dump with heavy repetition (traffic sources, traffic structure, ASIN traffic analysis, organic traffic share appear multiple times). Little of that volume earns its place versus a short list of distinct intents.

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 analytical tool with no output schema and only two terse annotations, the definition should say what the response contains and how period comparison is framed. It explains the analysis topic well but not the output shape, data source, or period definitions, leaving gaps an agent must guess at.

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%, including the sortBy enum list, country options, and conditions filters, so the schema does the heavy lifting. The description adds no parameter-level meaning beyond that — it never mentions the ASIN requirement, the last7d vs startDate/endDate rule, or pagination. 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 opening sentence names a specific verb and resource: analyze ASIN traffic source composition and exposure distribution, with current/previous/new/exited period comparisons. That is enough to separate it from generic product-research siblings. It never explicitly names a neighboring tool (e.g. nexscope_amazon_traffic_keywords or nexscope_amazon_asin_keywords), so sibling differentiation is only implicit through the topic list.

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

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

The description gives an extensive when-to-use trigger list (organic vs paid share, exposure breakdown, period comparison, keyword churn, competitor traffic) and explicitly says it should fire even without the user naming Nexscope, which is real routing guidance. It stops short of exclusions or naming which sibling to use instead when the ask is pure keyword lists rather than traffic composition.

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 openWorldHint=true; the description says nothing that explains or supports this — it reads as a pure query tool, leaving the read/write nature ambiguous. No operational behavior is disclosed: no rate limits, no auth/account requirements, no pagination or result-cap behavior, no latency/snapshot caveats, and no mention of the historical vs 'nearly' data modes that materially change results.

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

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

The first sentence is a well-formed, front-loaded purpose statement, but it is followed by a bloated trigger keyword list that repeats items verbatim ('sales filtering', 'BSR analysis' appear twice) and pads with near-synonyms. Roughly two-thirds of the text is keyword stuffing that does not help an agent decide or invoke.

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 67-parameter tool with no output schema, the description does cover the broad shape of the filter space (dimensions map reasonably onto the parameter groups). But it omits anything about sorting/pagination defaults, variant handling (showVariation), historical snapshots, and multi-marketplace constraints beyond a passing mention, which are the parts an agent most needs 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?

Schema description coverage is 100% across 67 parameters, so the schema already documents ranges, enums and formats (marketplace enum, matchType, order.field, dataSnapshotMonth). The description lists filter dimensions at a high level but adds no semantics beyond the schema — no guidance on keyword language translation, weightUnit dependency, fsellerNation format, or the filterSubNode prerequisite.

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

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

The description states a specific verb+resource ('search and filter Amazon products') and enumerates the filter dimensions supported (price, monthly sales, BSR, gross margin, ratings, fulfillment, badges, seller origin) across multiple marketplaces. It is clear what the tool does, but it never distinguishes itself from the many closely-named Amazon siblings (nexscope_amazon_market_product_search, nexscope_amazon_product_database_search, nexscope_amazon_product_discovery, nexscope_amazon_search), so the 'broad' qualifier in the name is never explained.

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 a long trigger list of scenarios (product selection, sales filtering, BSR analysis, niche discovery, competitor analysis, market opportunity), which gives context for when to use it, and it explicitly says to trigger even when 'Nexscope' is not mentioned. However several of those listed scenarios map directly to dedicated siblings (nexscope_amazon_niche_info, nexscope_amazon_competitor_lookup, nexscope_amazon_opportunity_report_by_keyword), and the description gives no exclusions or routing rules, so the guidance actively risks misrouting.

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 (readOnlyHint=false, openWorldHint=true) already frame the safety/open-world profile, and the description adds nothing beyond them: no note on marketplace scoping, result shape (flat list vs tree), pagination, or whether an unknown label/nodeId errors. Notably, the 'browsing/search' framing reads as a pure read while readOnlyHint is false, leaving the mutation profile genuinely ambiguous.

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 front-loaded sentence with no filler. It is efficient, though its brevity is closer to under-specification than true conciseness for a tool with five parameters and no 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?

For an open-world lookup with no output schema and five optional parameters, the description leaves the agent guessing about what comes back (category hierarchy vs flat label list) and about which parameter combinations are valid. The schema covers inputs, but the description does not close the outcome-side 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% with all five parameters documented (including the operation=like/nodeLabel dependency), so the schema carries the parameter burden. The description only echoes the mode mapping and says nothing about the 'table' selector or nodeId semantics beyond what the schema already states.

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

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

The description names the resource (Amazon category/parent-node data) and distinguishes the two modes it supports: exact parent-node browsing and label-based search, which map to operation=lookup and operation=like. It is clear what the tool does, though it never contrasts itself with adjacent category/market tools in the sibling list.

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

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

Usage is only implied by the two described modes ('exact parent-node browsing' vs 'label-based category search'); the description never says when to choose one over the other, nor any prerequisites (e.g. needing a known nodeId vs a label). No alternatives or exclusions are named.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true, so the description usefully adds that results come from Nexscope snapshots, cover 12 marketplaces, and contain sales/BSR/pricing/rating/growth fields. It says nothing about data freshness, credit/quota cost, or result limits, and the readOnlyHint=false on what reads as a read/analysis tool is left unexplained.

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

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

The first sentence is well front-loaded, but the trailing trigger list is keyword stuffing that repeats phrases ('competitor analysis, ASIN reverse lookup' appears twice) and pads length without new information. About half the description could be deleted with no loss of 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?

For a 15-parameter, zero-required tool with no output schema, the description covers what data comes back and across which marketplaces, which is the most important missing piece elsewhere. It omits what happens when no filters are supplied, how paging interacts with the 40-ASIN cap, and any response-size expectations.

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 every parameter (including the nested order.field/order.desc and the snapshot month) is already documented. The description only echoes a few filter dimensions (ASIN, keyword, seller, brand, category) without adding format, default, or interaction rules 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 opening sentence gives a specific verb and resource (find and analyze Amazon competitors) plus scope: 12 marketplaces and the metrics returned (sales, BSR, pricing, ratings, growth trends). It does not, however, differentiate itself from the many near-identical Amazon lookup siblings such as nexscope_amazon_product_search, nexscope_amazon_market_product_search, or nexscope_data_ss_competitor_lookup.

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 says to trigger on competitor-research intent and even when 'Nexscope' is not mentioned, and lists the query dimensions (ASIN, keyword, seller, brand, category) — genuinely useful context. But it offers no when-not guidance and never names an alternative, which matters given dozens of overlapping Amazon discovery tools in the sibling set.

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 openWorldHint=true, so the safety profile is partly covered structurally, yet the description never addresses what external data source is queried, whether calls are rate-limited or metered, or why a keyword lookup is flagged non-read-only. It does add useful value by enumerating the metric fields returned (search volume, trends, PPC bids, ranking difficulty), which annotations cannot express.

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

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

The opening sentence is well front-loaded, but the remainder is a bloated trigger-phrase dump with heavy duplication ('keyword discovery' appears three times, 'keyword expansion', 'related keywords', 'PPC bid research' and 'keyword mining' each twice). This repetition adds no information and dilutes the signal.

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 12 parameters, no output schema and a non-read-only profile, the description does meaningful work: it names the marketplaces and lists the metric categories returned, which substitutes for a missing output schema. It stops short of explaining how the many filter parameters combine or what the response shape looks like, but the essentials for calling it are 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 description coverage is 100%, so every one of the 12 parameters (sort, needCount, marketplace, word-count and volume filters) is already documented in the schema. The description adds no format hints, defaults or interaction notes beyond repeating the marketplace coverage already present in the marketplace field, so the baseline 3 applies.

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

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

States a specific verb and resource: it expands a seed keyword into a list of related keywords with search volume, trends, PPC bids and ranking difficulty, across 10 named Amazon marketplaces. The purpose is immediately clear. It does not, however, differentiate itself from close siblings such as nexscope_amazon_keyword_intelligence, nexscope_amazon_keyword_overview or nexscope_seo_keyword_expand, so an agent gets no signal on which to pick.

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

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

The description spends most of its length listing trigger phrases, which does convey when to activate the tool, but it provides no exclusions and never names an alternative sibling for overlapping needs. The implicit 'trigger when the user mentions X' framing is repeated rather than elaborated, so usage context is present but shallow.

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 genuine scope context (15 marketplaces, ~3 years of weekly data) beyond the sparse annotations. But it says nothing about output shape, latency, or why readOnlyHint=false on what reads as a pure query tool — the only mutating side effect (CSV download) is documented solely in the parameter schema, not in the description.

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

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

The opening sentence is well front-loaded, but the trigger list badly duplicates itself — 'ABA data', 'keyword mining', 'search ranking trends', 'market opportunity analysis', 'seasonal keywords' each appear twice verbatim — padding roughly half the text with no new 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 tool with no output schema and openWorldHint=true, the definition explains what data is queried and where it comes from but not what the agent gets back (e.g., keyword rows, metrics such as click share/conversion share, whether a URL or structured result is returned). That leaves a real gap for a tool this broad.

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 region, createDownloadUrl, and analysisDescription are already well documented with examples and an enum-like site list; the baseline of 3 applies. The description adds no guidance on how the natural-language analysisDescription should be phrased or how region interacts with the requested data.

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

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

States a specific verb and resource — querying/analyzing Amazon ABA (Brand Analytics) search term data — plus concrete scope: 15 marketplaces, roughly 3 years of weekly data. The only gap is that near-identical siblings such as nexscope_data_aba_intelligent_query, nexscope_amazon_keyword_overview, and nexscope_amazon_keyword_expansion are never mentioned, so an agent cannot tell which one to pick.

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

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

Gives explicit trigger conditions and even extends them beyond literal keywords ('Even if the user does not explicitly mention ABA...'). However, it provides no exclusions or alternative routing versus the many sibling keyword tools, so 'when not to use' is absent.

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

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

The annotations already declare readOnlyHint=false and openWorldHint=true; the description adds no behavioral context beyond them. It does not say what data source backs the analysis, how fresh the data is, whether calls consume credits or quota, or what the response includes, so an agent learns nothing about cost or side effects before invoking.

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

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

The trigger list repeats itself almost verbatim — 'keyword competition, supply-demand ratio, competitor count' appears twice in one sentence — and piles synonym upon synonym instead of stating scope. The one useful fact (implicit triggering without naming the product) is buried at the end of a bloated keyword dump.

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 is the only place to learn what an 'overview' returns — and it never says, leaving the agent to discover whether it gets a competition score, a metrics table, or a narrative. Combined with silent date-range behavior, this is adequate but thin for a data-query 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% with five well-documented parameters (keyword, country with its option list, last7d, startDate/endDate pairing), so the schema carries the semantics. The description contributes nothing parameter-specific, which is acceptable at full coverage but earns only the 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 opening sentence names a specific resource and analysis type: Amazon keyword market competition overview. That is enough to distinguish it from image/patent/TikTok siblings, but it does not differentiate it from the many closely-named Amazon keyword siblings such as keyword_summary, keyword_intelligence, or keyword_expansion, which an agent must guess between.

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 list (keyword competition, supply-demand ratio, competitor count, search volume estimation, competitiveness assessment) and even covers the case where the user omits the product name. However, it offers no when-not-to-use guidance and never names an alternative sibling, which is the main thing an agent needs in a fleet of dozens of Amazon keyword tools.

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

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

The description adds real behavioral facts beyond the annotations: results are exact search volume aggregated into 7-day periods and cover ten marketplaces. It says nothing about data freshness/lag, credit cost, history depth, or how large a response can get, which matters for an openWorldHint tool with no output schema. The readOnlyHint=false value is conservative rather than contradicted by the framing as a 'query', so no contradiction flag.

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

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

The core sentence is front-loaded and precise, but it is followed by a twelve-item list of near-synonymous trigger phrases and then a final sentence that restates the same trigger condition ('if their need involves viewing the search volume trend ... should also be triggered'). Substantial keyword stuffing for an idea already conveyed by the first sentence.

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

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

With four fully documented required parameters and no output schema, the description supplies what is missing: it says what the response conceptually contains (exact search volume trends bucketed in 7-day periods) and the marketplace span. Only secondary details such as history depth and result size are absent.

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

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

Schema coverage is 100%: keyword, marketplace enum list, date format, and the 366-day max interval are all documented in the schema itself. The description adds no parameter-level meaning (no mention that marketplace accepts only the ten listed codes, no date-range advice), so baseline 3 applies.

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

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

The first sentence states a concrete verb and resource: it returns Amazon keyword exact search volume trends in 7-day periods across 10 named marketplaces. That distinguishes it in substance from keyword-overview or keyword-summary siblings, but no sibling is actually named, so an agent still has to infer which keyword tool to pick from the huge registry.

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 an unusually rich trigger list (search volume trends, seasonality, fluctuations, popularity over time) and explicitly says it should fire even when the user does not mention 'Nexscope', which resolves the main routing ambiguity for this branded tool. It offers no exclusions, however, so there is no guidance on when to prefer a sibling such as a keyword-overview or keyword-intelligence tool instead.

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` and `openWorldHint: true`, so the description does not need to repeat basic safety hints. It adds useful domain scope by naming the first 3 pages, 30-day exact search volume, median PPC bid, and TOP3 ASIN data, but it says nothing about auth requirements, rate limits, data freshness, or what the `readOnlyHint: false` annotation means for this analysis tool.

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

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

The first sentence is front-loaded and informative, but the trigger list is excessively long and repeats terms such as 'PPC bid analysis', 'search result brand distribution', and 'competitive landscape'. The repetition bloats the description without adding discriminating guidance.

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

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

Given a simple two-parameter schema and no output schema, the description provides enough output-scope context for an agent to understand what will be returned. It is missing sibling differentiation and output-format expectations, but it is otherwise complete for this analysis 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% for the two parameters, and the schema already documents `keyword` and `marketplace` with examples and allowed marketplace codes. The description does not add any parameter-level guidance beyond what the schema provides, 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 clearly states a specific analysis resource and scope: keyword Share of Voice for Amazon, covering first-3-page visibility split, search volume, PPC bid, TOP3 ASIN metrics, and 10 marketplaces. It is clear what the tool does, but it does not explicitly distinguish itself from the similarly named sibling `nexscope_data_js_keywords_share_of_voice` or nearby keyword-intelligence tools.

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

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

It gives an extensive list of user trigger phrases and explicitly says to trigger even when the user does not name Share of Voice. That is strong when-to-use guidance, but it does not state when not to use the tool or name alternatives such as other keyword or competitive-analysis 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 only declare readOnlyHint=false and openWorldHint=true, which is itself puzzling for what reads as an analytical query tool; the description never addresses this and gives no auth, quota, or latency context. It does add useful behavioral detail — that results are filterable by ASIN, scoped to a 7-day window or a custom date range, and can be narrowed by new-traffic keyword filters — but says nothing about what the response contains or how pagination behaves.

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

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

The first sentence is well front-loaded and dense with the right information. It is then followed by a ~20-item run-on trigger list that is highly redundant and pushes the description well past what an agent needs, though it remains prose rather than pure keyword spam thanks to the closing conditional sentence.

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

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

For an 11-parameter analytical tool with no output schema, the description explains what dimensions exist but not what a record looks like, whether results are per-ASIN rows or per-channel aggregates, or how totalNfScore/totalSpSocre style metrics should be read. Since there is no output schema to fall back on, that gap is meaningful even though the parameter schema is fully documented.

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 description's mention of ASIN filtering, custom date ranges, and new traffic keyword filters mostly restates what the schema already documents in detail, including the sortBy enum spelling quirks. It adds no interpretation of the complex `condition` filter or of how last7d interacts with startDate beyond what the schema says.

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

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

The opening sentence gives a specific verb and resource ("Break down all competitor ASIN traffic sources under a given keyword") and enumerates the exact traffic channels covered (organic, SP ads, SB, SBV, AC/ER/TR slots). That is enough to separate it from keyword-level siblings such as nexscope_amazon_keyword_overview, but it never names a sibling tool or states what it does NOT cover, so an agent must infer the boundary with nexscope_amazon_asin_traffic_summary on its own.

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 a long, explicit trigger list of user phrasings ("keyword traffic sources", "organic traffic vs paid traffic share", "recommendation ad/non-ad split") plus

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 supply readOnlyHint=false and openWorldHint=true, and the description adds the 14-marketplace scope. It discloses nothing about cost or quotas, even though the schema warns that querying beyond 15 days 'doubles the cost' — that commercial behavior is arguably the single most important thing an agent should know before calling. No contradiction is flagged, but the read-only framing of 'Query' sits in mild tension with readOnlyHint=false.

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

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

The first sentence is well front-loaded, but the rest is keyword spam that duplicates itself almost verbatim ('price history, BSR ranking, profit analysis, FBA fees' appears twice). The repeated trigger list consumes most of the text without adding selection signal.

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 and thin annotations, the description should carry more weight than it does: it omits the credit/cost model, the default 15-day trend window behavior, and any disambiguation from sibling Amazon product tools. It is adequate to identify the resource but not to confidently route among the many alternatives.

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 explains ASIN (multi-value, comma-separated, max 10), marketplace codes, includeTrend, and the date-range cost implication. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

The opening sentence gives a specific verb, resource and scope: 'Query Amazon product detail and historical trends by ASIN using Nexscope data, covering 14 marketplaces.' However, it never distinguishes this from near-identical siblings such as nexscope_amazon_product_detail, nexscope_amazon_product_history or nexscope_amazon_product_price_series, so the 'market' qualifier is left unexplained.

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 expressed only as an undifferentiated trigger-phrase list ('Trigger when the user mentions...') plus a catch-all instruction to fire even without the brand name. There is no statement of when NOT to use it, nor which sibling to prefer when the request is for a plain product detail or a price-series lookup, which matters given dozens of overlapping Amazon 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?

It adds some useful context beyond the annotations: coverage of 14 marketplaces and historical monthly lookback. It does not explain why readOnlyHint is false, nor does it cover rate limits, auth requirements, data freshness, or pagination behavior. With annotations present, this is an acceptable but incomplete behavioral disclosure.

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 trigger list is heavily duplicated, repeating phrases like product search, competitor research, category analysis, brand bestsellers, seller analysis, seasonal products, and historical snapshot twice. This bloat makes the description longer without adding information and obscures the useful first sentence.

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

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

For a six-parameter search tool with no output schema, the description covers the high-level purpose and some scope, but it does not explain what results look like, how to compose queryType/queryValue combinations, or how pagination behaves. Since critical query construction details are deferred to SKILL.md, the description is only adequately complete.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description reinforces historical lookback and 14-marketplace scope but adds no meaningful detail about queryMode, queryType, queryValue formatting, or how these parameters interact beyond what the schema says. 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 first sentence clearly states a specific verb and resource: multi-dimensional Amazon product search and filtering using Nexscope data, with 14 marketplaces and historical monthly snapshots. It does not distinguish this tool from several close siblings such as nexscope_amazon_broad_product_search or nexscope_amazon_product_database_search, so it falls short of a 5.

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

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

The description lists many trigger scenarios and even says to use it when the user does not explicitly mention Nexscope if their need involves Amazon product search or exploration. However, it gives no exclusions or alternatives among the many similar Amazon search/research siblings, so the guidance is broad and not decision-useful for tool selection.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, yet the description never clarifies that this is a read-only listing endpoint, nor does it mention auth requirements, rate limits, result ordering defaults, or pagination behavior. For a 71-parameter screening call the agent gets no behavioral context beyond the metric names already in the schema.

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

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

The capability sentence is front-loaded and earns its place, but the trigger list is a padded, comma-chained enumeration that repeats 'market research' and 'market selection' variants, and the closing 'even if the user does not explicitly mention Nexscope' restates the same activation idea twice.

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 71 parameters, one required field, and no output schema, the description covers what can be filtered but says nothing about what a result row contains, whether results are paginated by default, or how to interpret the returned market metrics. That leaves a real gap for a tool of this complexity, though the metric coverage does orient the agent adequately.

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 min/max prefix pairs, unit conventions (percentages 0-100, ratios 0-1, nodeIdPath format) are already documented in the schema. The description's enumeration of metric families adds only a high-level grouping and no syntax, default, or interaction guidance beyond it.

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 opening sentence states a specific verb and resource: filter Amazon niche markets by category dimensions, and enumerates the metric families it screens on (size, competition, concentration, seller structure, new-product share, price/rating/margin). However, it never differentiates itself from the many near-identical siblings (nexscope_amazon_market_statistics, nexscope_amazon_niche_info, nexscope_amazon_opportunity_search_by_metrics, nexscope_data_ss_market_research), so an agent cannot reliably disambiguate on purpose alone.

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 supplies a long list of trigger phrases (market research, niche category research, opportunity screening, concentration analysis) and explicitly says to invoke even when 'Nexscope' isn't named, which gives real activation context. But there is no when-not guidance and no routing statement telling the agent to prefer a sibling like market_statistics or niche_info for adjacent needs, so the usage boundary remains underspecified.

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 openWorldHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds the useful detail that results are aggregated per category node and lists the metric families, but says nothing about cost/credits, whether a report job is created (which would explain readOnlyHint=false for what reads like a query), or latency. There is mild tension between the purely descriptive 'output a statistics dashboard' phrasing and readOnlyHint=false, though nothing outright 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?

The opening sentence correctly front-loads the capability and its output metrics. However, the trigger section is padded with near-duplicate phrases ('category market statistics', 'market selection dashboard', 'category statistics', 'node market quality') that add length without adding routing information, and the final sentence restates brand-independence at excessive length.

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, describing the returned metrics is the right compensation and is done. Still missing for a 5-parameter node-based query: where the agent should obtain nodeIdPath (e.g., via nexscope_amazon_category_lookup), how 'month' behaves when omitted, and how this differs from the market_research/niche_info 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?

Schema description coverage is 100%, with every parameter documented, so the baseline is 3. The description loosely gestures at topN and newProduct by mentioning 'top listing' and 'new product related metrics', but adds no syntax, defaults, or the nodeIdPath format guidance beyond what the schema already states.

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

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

States a specific verb and resource: it produces a market statistics dashboard for a category node, and enumerates the metrics returned (top-listing rating, average price, BSR, sales, seller count, new-product metrics). It never names a sibling such as nexscope_amazon_market_research or nexscope_amazon_niche_info, so differentiation from those adjacent tools is left to inference.

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

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

Gives a concrete list of trigger situations (market selection, market fundamentals assessment, node market quality, top product statistics) and explicitly says to trigger it even without the 'Nexscope' brand mention, which is genuine routing guidance. It offers no when-not conditions and never points to an alternative tool for the same need.

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 provide almost nothing (readOnlyHint=false, openWorldHint=true) and the description adds no behavioral context: no mention of credit/quota cost, rate limits, latency, freshness of the data, or what the response looks like. Worse, the description frames the tool purely as "query and analyze" (read semantics) while annotations declare readOnlyHint=false, so an agent cannot tell whether the call has side effects or consumes account resources.

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 dominated by a keyword-stuffed trigger list with duplicates ("price trends" and "out-of-stock rate" each appear twice) and near-synonyms ("market insights," "niche market insights," "market intelligence"). The one genuinely differentiating fact — that this variant is keyed by market ID — sits in the final clause instead of being front-loaded.

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

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

For a two-parameter read tool with a fully documented schema and no output schema, the metric families are broadly sketched, so an agent knows roughly what comes back. However, it omits how to discover a nicheId (presumably via a search/opportunity tool) and gives no indication of output shape or pagination, which are the main practical gaps 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%: nicheId is documented (single ID, max 1000 chars) and countryCode is documented (US/JP/DE, default US), so the schema carries the parameter burden. The description only reinforces the nicheId-as-market-ID meaning. Notable omission: it never tells the agent where to obtain a valid nicheId.

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 concrete verb pair (query and analyze) plus a specific resource (Amazon niche market insights) and enumerates the metric families returned (market metrics, buyer reviews, competitive landscape, price trends, growth trends). It also narrows scope to "a specific Amazon niche market by market ID," which implicitly separates it from the by-ASIN and by-keyword siblings, though that distinction is buried at the very end rather than stated up front.

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 a long list of trigger phrases ("niche market analysis," "brand concentration," "out-of-stock rate," etc.) and a useful fallback rule: trigger even without the word "Nexscope" when the need is market-level intelligence by market ID. That is real usage guidance, but there are no when-not conditions and no pointer to the obvious alternatives in the sibling set (nexscope_amazon_niche_info_by_asin, nexscope_amazon_niche_info_by_keyword, nexscope_data_jm_get_niche_info), leaving the agent to guess which niche-info variant to 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 declare readOnlyHint=false and openWorldHint=true, but the description adds no behavioral context: it does not explain what side effects are possible, whether any state is modified, authentication requirements, latency, or data-source constraints. It only restates the analytical dimensions of the result, not operational behavior 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 front-loads the purpose but then bloats into a long, repetitive keyword-trigger list that duplicates terms like 'monopoly level', 'brand concentration', and 'competitive landscape'. The keyword stuffing dilutes the useful signal and makes the definition less efficient than a concise trigger statement.

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

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

With 41 parameters and no output schema, the description should explain return values or operational behavior more fully. It does identify several analytical dimensions returned (monopoly level, brand concentration, success rate, opportunity score), but it omits how results are structured, what the optional filters do in combination, and any output format details.

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

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

Schema description coverage is 100%, so all 41 parameters are documented in the schema. The description contributes only the high-level notion that the ASIN parameter identifies the product whose niche is analyzed, without adding format, default, or filtering semantics 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 states a specific verb and resource: deep analysis of Amazon niche markets by product ASIN, and enumerates the covered dimensions such as monopoly level, brand concentration, new product success rate, and market opportunity score. It distinguishes itself only implicitly from keyword-based siblings via the repeated 'by ASIN' framing, without naming any sibling explicitly.

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

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

It gives extensive trigger conditions, including a fallback rule for when the user does not explicitly mention 'niche market' or 'ASIN' but needs competitive-landscape evaluation for a product's niche segment. It does not name alternatives such as the keyword-based or general niche-info siblings, nor does it state when not to use this tool.

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