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

Annotations already declare readOnly/idempotent/non-destructive, so the description's value is in the async lifecycle (jobToken, no polling, retrieve later), the caveat that Brands legacy campaign reports exclude multi-ad-group campaigns, and the warning not to compare attribution windows as equivalent. These are real behavioral constraints not present in annotations or schema.

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

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

Front-loaded with purpose, then the workflow instruction, then caveats; no filler sentences. The trailing negative list ('no polling loop, no cross-platform attribution...') is compressed to the point of being terse, but it is information-dense rather than padded.

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

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

Output schema exists, so return values need no explanation, and the description already covers the async round-trip, the report scope limits, and attribution-window discipline. An agent has everything needed to call this correctly without opening other tools.

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

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

Schema coverage is 100% and already documents reportType, attributionDays constraints (Brands/Display accept 14 only) and date ranges. The description reinforces attribution-window choice but adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Request an asynchronous Amazon performance report') and enumerates the exact report families covered (SP campaigns/ad groups/placements/search terms/products, SB, SD). The follow-up sentence naming amazon_ads_get_report makes the boundary with that sibling unmistakable.

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

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

Explicitly instructs 'Choose the attribution window explicitly, keep jobToken and call amazon_ads_get_report later', which tells the agent both the required input discipline and the correct next tool. It also fences off misuse with 'No polling loop, no cross-platform attribution and no automatic sums' and 'Does not change advertising or budgets'.

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 read-only, idempotent, non-destructive behavior, so the description's added value is the default-inclusion of paused and archived entities plus the explicit warning that a single page is not an account total and must be paginated. That is meaningful context beyond structured fields, though it says nothing about ordering, rate limits, or auth/profile prerequisites.

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

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

Three short sentences, front-loaded with what is read, followed by the pagination caveat, then the config-vs-performance disambiguation. No filler and every sentence carries distinct information.

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

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

Output schema exists, so return-value explanation is unnecessary, and annotations cover the safety profile. The description covers scope, defaults, and pagination, leaving only minor gaps like required accountId emphasis and region matching already handled by 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 every parameter (states, accountId, nextToken, maxResults, campaignIds) is already documented in the schema, including defaults and limits. The description reinforces the state default and pagination semantics but adds no syntax or format detail beyond the schema, which is the expected baseline.

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

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

States a specific verb and resource ('Read one page of Amazon Sponsored Products ad groups'), naming the ad type explicitly so it is distinguishable from the sibling SD and SB ad group tools. It also clarifies the entities covered (paused and archived by default), so an agent knows exactly what is returned without opening the schema.

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

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

Gives clear operational guidance: 'Continue with nextToken until absent; one page is not an account total,' which tells the agent how to use it correctly, and 'not performance metrics' steers away from using it for reporting (where amazon_ads_create_report applies). It does not explicitly state when to pick this over amazon_ads_get_sb_ad_groups or amazon_ads_get_sd_ad_groups, leaving that inference to the platform name.

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

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

Annotations already declare readOnly, idempotent, non-destructive behavior. The description adds useful operational context by tying the result to campaign/creative setup and warning against fabricating brand IDs, which goes 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?

Two short sentences, front-loaded with the purpose and followed by the key usage constraint. Every sentence carries actionable information for an agent.

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

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

The tool is simple: one required parameter, full schema description coverage, an output schema, and rich annotations. The description supplies the remaining behavioral guidance about the returned ID and safe usage, so nothing essential is missing.

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

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

Schema coverage is 100% and accountId is thoroughly documented in the schema, so the description does not need to repeat parameter details. It reinforces that the call is scoped to the selected profile, but adds little parameter-specific meaning beyond that.

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

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

The description uses a specific verb and resource ('List brands') and narrows scope to brands eligible for Sponsored Brands in the selected profile. No sibling tool covers brands, so an agent can distinguish this from campaign, creative, and report tools without checking schemas.

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

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

It gives clear downstream context: use the returned brandEntityId in campaign and creative configuration, and never invent a brand ID. That tells the agent when this tool is needed, though it does not explicitly name alternatives or when-not-to-use conditions.

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 read-only, idempotent, non-destructive behavior, so safety is covered. The description adds genuinely useful context beyond them: results include PAUSED and ARCHIVED by default, and a single call is only one page rather than a full account total, which prevents an agent from treating a truncated result as complete.

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

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

Three short sentences, front-loaded with the resource and scope, followed by the pagination caveat and the record-type clarification. Every sentence carries distinct information with no redundancy.

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

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

With a full output schema and rich annotations, the description needs only to cover what those fields don't: pagination obligation and default state inclusion, both of which it handles. The only gap is the absence of explicit routing against look-alike negative keyword and negative target 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%, so every parameter including nextToken, states, maxResults, accountId, and campaignIds is already documented in detail. The description only restates the default-state behavior and the nextToken loop, adding nothing about syntax or 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 (Read) and a precise resource: Sponsored Products campaign negative keywords, scoped to one page. It is distinguishable from the account-level amazon_ads_get_negative_keywords and from campaign negative targets by naming 'keywords' explicitly, but it never names a sibling to sharpen that 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?

It gives operational guidance ('Continue with nextToken until absent; one page is not an account total' and 'configuration records, not performance metrics'), which tells an agent not to use this for reporting. However, it never states when to choose this over amazon_ads_get_negative_keywords or amazon_ads_get_campaign_negative_targets, so sibling selection is left implicit.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds genuinely new behavior: paused and archived entities are included by default, and the result is inherently paginated so a full answer requires looping on nextToken. The clarifying note that these are configuration records rather than performance metrics further prevents misreading of the payload.

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

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

Three short sentences, front-loaded with the core action, then the pagination constraint, then a semantic caveat. Every sentence carries information an agent would otherwise have to guess, and there is no filler.

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

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

With a full output schema and rich annotations, the description only needs to add the non-obvious parts, and it does: default state inclusion, mandatory pagination, and config-vs-metrics semantics. The one remaining gap is disambiguation from the similarly named negative-target siblings across SD/SB/campaign scopes.

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 accountId, states defaults, nextToken, maxResults, and campaignIds in detail. The description only reinforces the pagination token behavior; it adds no syntax, format, or constraint meaning beyond what the schema states, 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 gives a specific verb and resource ('Read one page of Amazon Sponsored Products campaign negative targets'), making the entity type unmistakable. It does not, however, explicitly distinguish itself from the near-identical sibling 'amazon_ads_get_negative_targets' or from 'amazon_ads_get_sd_negative_targets', so an agent must infer the campaign-level vs. other-level scope from the name 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 gives concrete operational guidance ('Continue with nextToken until absent; one page is not an account total'), which steers the agent away from treating a single response as complete. What is missing is guidance on when to choose this tool over the closely named alternatives (get_negative_targets, get_campaign_negative_keywords); usage relative to siblings is only implied.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds behaviour that annotations do not: default inclusion of PAUSED and ARCHIVED, page-vs-total semantics, and the fact that results are configuration rather than metrics. It stops short of describing error or auth behaviour, so not a 5.

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

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

Three short sentences, each carrying distinct information: scope, pagination rule, and the config-vs-metrics caveat. Front-loaded with the resource and zero filler.

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

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

With a full schema, an output schema, and read-only annotations, the description covers the remaining agent-relevant gaps (pagination, default states, entity type). It is nearly complete; only error/permission context is absent, which is minor here.

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 (states, accountId, nextToken, maxResults, campaignIds) is already documented in structured form. The description reinforces the nextToken continuation rule but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

Names a specific verb and resource ('Read one page of Amazon Sponsored Products campaigns') and implicitly distinguishes itself from the SB/SD campaign siblings by pinning the ad product. It also rules out a plausible misread by stating these are configuration records, not performance metrics.

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

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

Gives concrete usage context: pause/archive states are included by default, and the agent must follow nextToken until it is absent because one page is not an account total. It does not explicitly name alternatives like amazon_ads_get_sb_campaigns, but the sibling names make the product split self-evident.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the result includes every version and its files, URLs are never guessed, and there is no cross-profile fallback — i.e. what the agent will and won't get 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?

Three short sentences, no filler, with the core action and scope front-loaded and the sibling routing and constraints following. Every clause carries information the agent needs.

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

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

For a two-parameter, fully documented, read-only tool with an output schema and rich annotations, the description supplies the remaining pieces an agent needs: where the ID comes from, what the response contains, and how missing data is handled. Nothing essential is missing.

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

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

Schema coverage is 100% with patterns and descriptions for both accountId and assetId, so the baseline is 3. The description adds provenance meaning the schema lacks — that assetId must be a native asset library ID sourced from the list tool — which materially reduces the chance of an invented 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 names a specific verb and resource ('Refresh one native Amazon image or video asset in the selected profile') and explicitly separates itself from the listing sibling by pointing at amazon_ads_list_creative_assets. An agent can distinguish it from the ~30 sibling getter tools without opening the schema.

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

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

It tells the agent exactly where the required assetId must come from ('Pass its native assetId from amazon_ads_list_creative_assets'), which routes usage correctly. It stops short of stating explicit exclusions (e.g. don't use this to enumerate assets or to cross profiles), but the profile scoping constraint is clearly implied by 'in the selected profile' and 'no cross-profile fallback'.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuine value with pagination semantics and the 'configuration records, not performance metrics' caveat, but says nothing about what the returned entity records contain or ordering, leaving the behavioral picture thin 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?

Three short sentences with zero filler; scope and pagination caveat come first, and the metrics disclaimer is a single compact clause. Every sentence carries distinct information.

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

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

An output schema exists, so return values need not be explained, and the description covers the two things the schema cannot: page-not-total pagination and record type. It is essentially complete for an annotated read-only list tool, with only the keyword-vs-target boundary left unaddressed.

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

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

Schema description coverage is 100%, so every parameter including states, nextToken, maxResults and campaignIds is already documented at the field level. The description only restates the archived/paused default that the schema already declares, adding no syntax or constraint detail.

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

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

States a specific verb and resource ('Read one page of Amazon Sponsored Products keywords'), and the 'Sponsored Products' qualifier separates it from the Sponsored Brands/Display keyword and target siblings. It stops short of clarifying the keyword-vs-target distinction that an agent choosing among get_targets/get_negative_keywords would need.

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 invocation guidance: continue with nextToken until absent, and warns that one page is not an account total. It also frames the use case by excluding performance analysis ('not performance metrics'), implicitly routing metrics work to the reporting tools, though it never names that alternative.

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

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

With readOnlyHint/idempotentHint already covering the safety profile, the description adds real value: default inclusion of paused and archived states, the mandatory pagination loop, and the fact that results are configuration records rather than metrics. It stops short of mentioning rate limits or result ordering, so it is strong but not exhaustive.

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

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

Three short sentences with zero filler: scope first, then the pagination rule, then a clarifying note on data type. Every sentence carries information an agent needs before calling.

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

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

The tool has a rich schema and an output schema, so return shape need not be explained; the description covers the remaining risks — partial results and the continuation loop. Nothing essential for a correct invocation is missing.

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

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

Schema coverage is 100%, so every parameter including states, nextToken, maxResults, campaignIds, and accountId is already documented in the schema. The only added semantic is the default-includes-archived note for states, which largely echoes the schema default, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Read one page of Amazon Sponsored Products negative keywords') and clarifies scope by saying paused and archived entities are included by default. It implicitly separates this from the SB/SD and campaign-level negative-keyword siblings via the 'Sponsored Products' qualifier, but never names an alternative 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?

Gives clear operational context: continue with nextToken until absent, and a single page is not an account total, which tells the agent how to consume the tool. It also disambiguates intent ('configuration records, not performance metrics'), but offers no explicit when-to-use-this-vs-sibling routing.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description correctly spends its space elsewhere: it discloses that paused and archived entities are included by default and that a single response is a page, not an account total. That pagination caveat is genuinely valuable behavioral context not present in annotations or 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?

Three short sentences, front-loaded with the operation and scope, then pagination behavior, then a disambiguation note. Nothing is redundant or padded.

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

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

With an output schema present, return-value detail is unnecessary, and the description covers the two things an agent most needs to know: pagination must be followed to completion, and the data is configuration rather than metrics. Only the absence of a named alternative for metrics keeps it short of 5.

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 detailed docs for states, accountId, nextToken and maxResults, so the baseline is 3. The description only restates the archived-included default that the `states` schema already documents, adding no new parameter 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?

States a specific verb and resource ('Read one page of Amazon Sponsored Products negative targets') with clear scope. It implicitly separates itself from sd/sb and campaign-level negative-target siblings via 'Sponsored Products', but never names an alternative, so the differentiation 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?

'Continue with nextToken until absent; one page is not an account total' gives a clear pagination practice, and 'not performance metrics' signals an exclusion. However, it never names the alternative tool (e.g. create_report) for performance data, so the when-to-use guidance is implied rather than explicit.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), but the description adds real context beyond them: results include paused and archived entities by default, a single call is not an account total, and the records are configuration not performance data. It does not mention permission or profile prerequisites, leaving the schema to carry that.

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

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

Three short sentences with zero filler: scope first, then the pagination rule, then the crucial caveat about totals and record type. Each sentence carries distinct information an agent would otherwise get 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 a full input schema, an output schema, and rich annotations, the only remaining agent risks are misunderstanding page-vs-total and entity type, both of which the description explicitly addresses. Nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, so every parameter (states, accountId, nextToken, maxResults, campaignIds) is already documented in the schema. The description only restates the pagination concept via nextToken and adds no format or constraint detail beyond it, which is the baseline-3 case when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Read one page of Amazon Sponsored Products product ads'), and the 'Sponsored Products' qualifier separates it from amazon_ads_get_sd_product_ads and amazon_ads_get_sb_ads. The closing clause 'configuration records, not performance metrics' further distinguishes it from the report 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?

Gives clear operational guidance ('Continue with nextToken until absent; one page is not an account total'), which tells the agent how to consume the tool rather than when to pick it. It never names an alternative sibling or an exclusion condition for choosing this over the SD/SB product ad variants, so selection guidance is only implied by the vendor qualifier.

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

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

Annotations already cover readOnly/idempotent/non-destructive safety, and the description adds real context the annotations lack: data comes from the advertiser's catalog rather than retail scraping, images are native URLs, and the returned visuals are not fully rendered ads. That caveat prevents a common misinterpretation.

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

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

Three compact sentences with the purpose front-loaded and pagination plus the image caveat last. Slightly dense phrasing ('product images are not complete rendered ads') costs a bit of clarity but 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?

With an output schema present, return values need not be explained. The description covers purpose, data origin, and pagination, which is enough for a 7-parameter read tool; only the choice among sibling data sources remains unaddressed.

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

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

Schema description coverage is 100%, so enumerated parameters, ASIN pattern, limit bounds, and the asins-vs-search exclusion are already documented. The description only echoes the two pagination modes, adding no syntax or constraint detail 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 (read) and resource (advertised product titles, image URLs, stock, price, eligibility) from the advertiser's Amazon catalog. It partially differentiates from siblings by positioning itself as the Sponsored Products visual source rather than a creative-asset tool, though it never names the closest alternatives.

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

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

Usage is only implied: fetch catalog data as opposed to scraping retail pages, and page via pageIndex or cursorToken. There is no explicit statement of when to choose this over get_product_ads or list_creative_assets, which are the plausible competing sources of product/creative data.

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

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

Annotations already declare readOnly, idempotent, non-destructive behavior, so the bar is lower. The description still adds real value by warning that successful API access does not establish eligibility for Sponsored Brands, Display or DSP — a misinterpretation risk an agent would otherwise walk into when reading the returned account type.

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 tight sentences with zero padding; the core purpose and returned fields come first and the eligibility caveat follows.

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

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

An output schema exists, so return values need not be explained, and the single parameter is schema-documented. What is slightly missing is failure behavior (e.g., an accountId not present in the configured profile list) and an explicit pointer to amazon_ads_list_profiles for discovery.

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

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

With schema coverage at 100%, the accountId format, region-prefix patterns and AMAZON_ADS_PROFILE_IDS reference are already fully documented in the schema. The description contributes nothing further about the single parameter, so the baseline 3 applies.

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

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

States a specific verb (read) and resource (the selected Amazon Ads profile) and enumerates the fields returned: marketplace, account type, currency, timezone. The word 'selected' signals single-profile retrieval, implicitly contrasting with amazon_ads_list_profiles, though that sibling is never named.

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

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

Usage is only implied — an agent must infer that this is the tool for fetching details of one known profile versus listing all profiles. No explicit when/when-not or named alternative is given; the second sentence is a caveat about eligibility, not routing guidance.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive); the description adds beyond them: a single non-blocking check, bounded download size, partial results marked with row offsets, and expiry-driven re-request. It does not describe how incompleteness is signaled (status field vs. error), which is the one remaining behavioral 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?

Four short sentences, front-loaded with the action, then constraints, pagination, and expiry — no wasted text. Slight terseness ('Downloads are bounded') leaves a little to interpret, but nothing is redundant.

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

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

With an output schema available and annotations covering safety, the description supplies the operational facts an agent needs: token provenance, polling-once semantics, pagination offsets, partial results, and expiry. Only the precise incomplete/expired signaling contract is left implicit.

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

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

Schema description coverage is 100%, so limit, offset, jobToken, and accountId are already fully documented in the schema. The description only reinforces that pagination is offset-based via returned row offsets and that the token is profile-scoped, which adds marginal value over the schema baseline.

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

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

States a specific two-part action (poll once for completion, then read native rows) on a specific resource (Amazon report), and explicitly names the sibling that produces the input token, amazon_ads_create_report. An agent can tell this apart from the create/poll siblings without opening a schema.

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

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

Gives explicit prerequisites (jobToken must come from amazon_ads_create_report for this profile) and a recovery path (expired reports must be requested again). It lacks an explicit 'when not to use' statement against other report-ish siblings, but the context needed to call it correctly is present.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description correctly spends its words elsewhere: eligibility gating and the 'no retail scraping' constraint tell the agent this only returns native API data. Pagination behavior is left entirely to the schema fields, but that is a minor 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?

Three short sentences: what it returns, how to resolve IDs, and the eligibility/caveat line. Nothing is repeated from annotations or the schema, and the core purpose leads.

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

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

An output schema exists, so return-value description is unnecessary, and the eligibility and cross-tool resolution notes cover the main decision points. The only thing an agent might still want is a hint about multi-ad scope (one ad per call), which is implied but not stated outright.

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 every parameter (accountId, adId, nextToken, maxResults) is documented in detail there. The description adds no syntax or format guidance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('read native Sponsored Brands creative versions for one ad') plus the concrete payload fields returned (headline, ASINs, logo, image/video refs). The 'Sponsored Brands' qualifier cleanly separates it from amazon_ads_get_sd_creatives 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?

Gives an explicit prerequisite ('Requires Brands eligibility') and routes to the correct follow-up tools for IDs (amazon_ads_get_creative_asset, amazon_ads_get_product_metadata). It doesn't explicitly state the negative case (e.g., use the SD creatives tool for Sponsored Display ads), which keeps it short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, and the description adds genuinely useful behavior: results are paginated one page at a time, all states including archived are returned by default, and eligibility can block the call. It does not cover rate limits or whether an ineligible profile errors versus returns empty.

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

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

Four short sentences with zero filler; the core action and scope lead, followed by prerequisite, paging, and the semantic caveat. Every sentence carries distinct information an agent needs.

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

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

With an output schema present and full param coverage, the description covers what annotations and schema cannot: eligibility gating, one-page-at-a-time semantics, and the warning that this is configuration data. Only the ineligibility failure mode is left unstated.

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 states, nextToken, maxResults, campaignIds and accountId are all documented in the schema itself. The description only restates the all-states default and the continuation-token pattern, adding little beyond what the schema already provides — 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 ('Read one page of') and a scoped resource ('Sponsored Brands ad groups'), and names the paging model up front. The 'Sponsored Brands' qualifier lets an agent distinguish it from amazon_ads_get_sd_ad_groups and the generic amazon_ads_get_ad_groups without opening the schema, 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?

It states a real prerequisite ('Requires Brands eligibility in this profile') and a usage constraint ('follow nextToken'), and 'Configuration is not performance' implicitly steers agents wanting metrics toward the reporting tools. The exclusion is stated but the alternative (amazon_ads_create_report) is never named, so routing still takes a small 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 this is a read-only, idempotent, non-destructive operation, but the description adds useful context beyond them: Brands eligibility is required, archived states are included by default, and the result is configuration rather than performance data. It does not cover rate limits or detailed return behavior, but the output schema likely handles the latter.

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

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

Four short sentences are front-loaded with the core purpose, then eligibility, pagination, and a key semantic caveat. There is no filler or repetition.

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 rich annotations, a fully documented schema, and an output schema, the description supplies the key non-schema context an agent needs: eligibility, default inclusion of all ad states, pagination via nextToken, and the distinction between configuration and performance. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the parameter documentation already carries the full burden. The description only echoes schema-level facts such as the default state coverage and nextToken continuation, adding little semantic meaning beyond the structured fields.

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: 'Read one page of Sponsored Brands ads.' This clearly distinguishes the tool from sibling resources such as campaigns, ad groups, and creatives in the same Sponsored Brands family.

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

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

It states a real prerequisite ('Requires Brands eligibility in this profile') and tells the agent to follow nextToken, which is useful operational guidance. It does not explicitly name when to choose this over sibling endpoints, so it falls short of the top score.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real behavioral context the annotations cannot: an eligibility gate, that ARCHIVED is included by default, and the crucial caveat that results are configuration and not performance. It stops short of noting error or 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?

Four short sentences, front-loaded with what the tool returns, followed by precondition, pagination, and the config-vs-performance caveat. Nothing is redundant and nothing could be cut without losing meaning.

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

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

With a full output schema and complete parameter documentation, the description only needs to supply prerequisites and behavioral caveats, which it does. The minor gap is what an agent should do when the Brands eligibility check fails.

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 accountId, states, nextToken, maxResults and campaignIds are all documented in the schema itself. The description only echoes the all-states default and the continuation-token flow, adding little syntax or semantics beyond what the schema already supplies; 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 (Read), resource (Sponsored Brands campaigns), and scope (one page), which immediately separates it from the SD and generic campaign siblings. The size of the result set is bounded up front, so the agent knows this is a paginated list rather than a full dump.

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?

"Requires Brands eligibility in this profile" is a genuine precondition, and "follow nextToken" tells the agent how to continue rather than re-call blindly. However, it never states when to prefer this over the seemingly overlapping amazon_ads_get_campaigns sibling, so the routing decision is left partly 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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description's only added behavioral fact is that results are paginated and archived entities are included by default, which is helpful. It also mentions a "returned cursor" while the input schema exposes only startIndex/limit, leaving it unclear which field the agent should pass 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?

Two short sentences, front-loaded with the core action and followed by the pagination caveat; nothing is padded. The only minor cost is the ambiguous "cursor" reference, which slightly muddies the otherwise crisp wording.

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

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

With a full output schema and complete annotation coverage, the description only needs to supply purpose and the pagination caveat, which it does. The lone gap is the mismatch between the mentioned cursor and the schema's startIndex-based paging, which an agent may have to resolve by inspecting the output schema.

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

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

Schema description coverage is 100%, and each parameter already documents defaults, bounds, and formats (including the region-qualified accountId form). The description adds no parameter-level detail beyond the generic mention of cursor/offset, 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 ("List one page of Sponsored Brands keywords") and scopes it with "including archived entities," which an agent could not infer from the title alone. It does not explicitly distinguish itself from close siblings such as amazon_ads_get_sb_negative_keywords or amazon_ads_get_keywords, so the differentiation is implicit in the name rather than stated.

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 pagination guidance ("Follow the returned cursor or offset; one page is not the whole inventory"), which is genuinely useful for calling the tool correctly. However, it says nothing about when to choose this tool over sibling keyword/target endpoints or what prerequisites apply beyond the schema's accountId.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is covered. The description adds genuine behavioral context beyond those hints: results include archived entities and a single call is only a partial view requiring further paging. Some gaps remain (no per-call caps or rate limits), but the added pagination warning is valuable.

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

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

Two tight sentences with no filler, and the resource scope is front-loaded before the pagination caveat. Every sentence carries function.

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

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

Output schema exists, so return values need not be described, and the pagination requirement plus archived-entity inclusion cover the main risks. Missing is any note on how campaign/ad-group filters interact with the returned page or expected ordering, though the schema mitigates much of that.

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

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

With 100% schema description coverage, the schema fully documents limit, states, startIndex, campaignIds, adGroupIds, and the accountId profile-ID convention. The description only alludes to cursor/offset without naming the parameters or explaining filtering semantics, so it provides no meaningful lift over the schema.

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

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

States a specific verb and resource ("List one page of Sponsored Brands negative keywords") and adds scope ("including archived entities"), which separates it from the account-level amazon_ads_get_negative_keywords. It does not explicitly distinguish itself from the closest sibling, amazon_ads_get_sb_negative_targets, so it stops 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 gives a clear pagination instruction ("Follow the returned cursor or offset; one page is not the whole inventory"), which is real usage guidance for invocation. However, it offers no when-to-use/when-not guidance relative to the many sibling listing tools, leaving the agent to infer that this is the SB-specific negative keyword lister.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds two non-obvious behaviors beyond that: archived entities are included in the result set, and a single response is an incomplete page requiring cursor/offset continuation.

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 zero filler. The resource identification is front-loaded, and the pagination caveat follows immediately behind it where it is most actionable.

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

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

An output schema exists, so return shape need not be described. The description covers the two things an agent could get wrong with a paginated read tool: assuming one page is the full inventory and assuming archived entities are excluded. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so every parameter (limit, states, nextToken, campaignIds, adGroupIds, accountId) is already documented. The description's reference to 'cursor or offset' loosely maps to nextToken but adds no syntax, defaults, or filter semantics beyond what the schema states.

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

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

States a specific verb and resource ('List one page of Sponsored Brands negative targets'), and the 'Sponsored Brands' qualifier plus 'negative targets' separates it from siblings like amazon_ads_get_sd_negative_targets and amazon_ads_get_negative_targets. The scope is further bounded by 'including archived entities', so an agent can identify the resource without opening the schema.

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

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

Gives concrete usage guidance for pagination: 'Follow the returned cursor or offset; one page is not the whole inventory', which tells the agent how to consume results correctly. It does not explicitly state when to prefer this over gateways like amazon_ads_get_sb_targets (positive targets) or the report tools, so no exclusions are provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and non-destructive, so the safety profile is covered. The description adds genuinely non-structured behavior: that results are single-page and require cursor/offset continuation, and that archived entities are included by default — a real data-scope disclosure. Rate limits and result ordering remain unstated, keeping it below a 5.

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

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

Two short sentences, zero filler, and the pagination caveat is front-loaded immediately after the purpose statement. Nothing in it restates the tool name redundantly or wastes a clause.

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

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

With an output schema present, return-value explanation is not required, and the annotations plus 100%-covered schema carry the rest. The description supplies the two behavioral facts an agent could not infer — pagination and archived inclusion — leaving only minor gaps like ordering and deprecation of the offset/cursor 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 every parameter (limit, states, accountId, nextToken, campaignIds, adGroupIds) is already documented in the schema with formats, defaults and bounds. The description only gestures at pagination and archived inclusion, both of which the schema already encodes, so it adds no parameter-level meaning beyond 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 description states a specific verb and resource — 'List one page of Sponsored Brands targets' — and adds scope ('including archived entities'). It is clearly separable from siblings like amazon_ads_get_sb_keywords or amazon_ads_get_sb_campaigns by resource, though it never explicitly contrasts itself with the neighboring amazon_ads_get_targets / amazon_ads_get_sd_targets variants.

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 operating guidance: 'Follow the returned cursor or offset; one page is not the whole inventory,' which tells the agent this is a paginated enumeration rather than a one-shot fetch. It does not, however, indicate when to prefer this over amazon_ads_get_targets (sponsored products) or amazon_ads_get_sb_negative_targets, so the routing guidance is contextual rather than explicit.

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

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

Annotations already declare read-only, idempotent, non-destructive, open-world behavior. The description adds meaningful context beyond them: Display eligibility, offset-based pagination rather than cursors, conservative partial-page marking, and a clarification that records are not performance metrics.

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 short, front-loaded, and largely waste-free. The final sentence about native media references is useful but slightly tangential for an ad group listing tool.

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

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

With rich annotations, full schema coverage, and an output schema, the description supplies the key missing behavioral context: eligibility, pagination quirks, and the non-performance nature of the records. It is complete enough for an agent 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 coverage is 100%, so the schema already documents accountId, count, and startIndex. The description adds pagination-related nuance about startIndex and partial pages, but does not add parameter meaning beyond what the schema provides for accountId or count.

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: 'Read one page of Sponsored Display ad groups.' The 'Sponsored Display' qualifier distinguishes it from the sibling non-SD ad group tool, but it does not explicitly name alternatives or contrast with 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?

It gives a prerequisite ('Requires Display eligibility') and pagination guidance, but does not say when to use this tool versus siblings such as amazon_ads_get_ad_groups or amazon_ads_get_sd_campaigns. Usage is implied by the SD scope rather than explicitly directed.

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

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

Annotations already cover readOnly/idempotent/non-destructive, but the description adds genuinely non-obvious behavior: pagination is offset-based rather than cursor-based, full pages are flagged partial, and returned records are not performance metrics. The partial-page caveat is the kind of quirk that prevents incorrect pagination logic in a caller.

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

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

Four short sentences, front-loaded with purpose then prerequisites then pagination then data caveats. No filler and every clause carries operative information.

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

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

With an output schema present, return shape needn't be explained, and the description still covers eligibility, pagination semantics, partial-page behavior, and the nature of creative fields. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaning beyond the schema by explaining that startIndex is the pagination mechanism and why no cursor exists. It does not restate count or accountId, which the schema already handles well.

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 — 'Read one page of Sponsored Display campaigns' — and the 'SD' qualifier plus 'one page' distinguishes it from the sibling get_sb_campaigns and get_campaigns. An agent can route correctly without opening the schema.

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

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

'Requires Display eligibility' gives a concrete prerequisite that tells the agent when this tool is callable. It does not name an explicit alternative or exclusion, so it stops short of full when/when-not guidance.

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

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

Beyond the read-only/idempotent annotations, it discloses eligibility requirements, the pagination model, and that full pages are conservatively marked partial. It also clarifies that records contain native media references and are not performance metrics, which meaningfully sets expectations.

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

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

Four tightly written sentences, front-loaded with the tool's purpose. Each sentence adds a distinct and useful fact: eligibility, pagination behavior, and data 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?

Given the rich schema and the existence of an output schema, the description covers the key call-context concerns: eligibility, pagination, and data type. It is nearly complete, though it could explicitly route agents away from sibling creative or product-ad tools.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description adds useful pagination semantics by stating that pagination uses startIndex rather than a cursor, helping prevent cursor-style pagination attempts.

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: 'Read one page of Sponsored Display creatives.' It clearly distinguishes this from SD product ads, targets, and generic creative-asset tools by naming the exact resource and scope.

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

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

It gives clear usage context, including the prerequisite 'Requires Display eligibility' and the caveat that records are 'not performance metrics.' It does not explicitly name alternatives such as amazon_ads_list_creative_assets or amazon_ads_get_sd_product_ads, so exclusions are 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 readOnly/idempotent/non-destructive, so the description adds real value beyond them: an entitlement precondition (Display eligibility), a pagination model caveat (offset-based rather than cursor), and a result-fidelity warning that full pages are conservatively marked partial. The note that records are not performance metrics also prevents misinterpretation of the payload.

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?

Roughly four short sentences, front-loaded with the purpose, then eligibility, pagination, and a data caveat. Nearly every clause earns its place, though the 'Creatives include native media references' sentence is tangential to negative targets and reads as an aside.

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

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

With an output schema present, return structure needn't be described, and the description covers the remaining agent-relevant concerns: entitlement, pagination mechanics, and partial-page semantics. It omits any mention of what a negative target record keys on or how it relates to SD campaigns/ad groups, which would help in a 30-sibling namespace.

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 accountId, count, and startIndex are already fully documented, and the description does not restate them. It does add one genuinely useful semantic point — that paging is offset-based via startIndex rather than a cursor — which earns slightly more than the baseline but not a high score.

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 ('Read one page of Sponsored Display negative targets'), and the 'Sponsored Display' qualifier cleanly separates it from the sibling SB and generic negative-target tools. It stops short of naming the alternative tools explicitly, so differentiation is by naming convention rather than by routing.

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?

'Requires Display eligibility' gives one concrete prerequisite for when the tool is callable, and the pagination sentence gives call mechanics. However there is no guidance on when to choose this over amazon_ads_get_sd_targets, amazon_ads_get_campaign_negative_targets, or amazon_ads_get_negative_targets, leaving usage largely implied by the name.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavior: offset-based pagination rather than a cursor, conservative partial-page marking, and an explicit warning that these records are not performance metrics (routing reporting needs to create_report).

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

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

Four short sentences, each carrying distinct information: purpose, precondition, pagination quirk, and output-scope caveat. No filler and the core identity is front-loaded.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description still covers eligibility, pagination semantics and the non-metrics caveat. Only the missed explicit routing to the Sponsored Products sibling keeps it from being fully complete.

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

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

Schema description coverage is 100%, with count, accountId and startIndex all documented including the 'use nextStartIndex from the previous page' hint. The description reinforces the startIndex-not-cursor point but adds no new syntax or constraints beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Read one page of Sponsored Display product ads'), and the 'Sponsored Display' qualifier separates it from the Sponsored Products sibling amazon_ads_get_product_ads. It stops short of explicitly naming that sibling, so the differentiation is implied by the ad-product prefix rather than spelled out.

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?

'Requires Display eligibility' gives a real precondition for use, which is more than most sibling tools offer. However, there is no statement of when to prefer this over amazon_ads_get_product_ads or amazon_ads_get_sd_creatives, and no exclusion guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), yet the description adds non-obvious behavior: offset pagination instead of a cursor, the conservative 'partial' marking of full pages, and the caveat that records are not performance metrics. That last note prevents a real misuse (treating targets as metrics). It stops short of describing what a 'partial' page means operationally or what the native media references look like.

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

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

Four short sentences, front-loaded with the action and carrying eligibility, pagination mechanics, and a data caveat with no padding. Slightly clipped phrasing ('Creatives include native media references') costs a bit of clarity, but 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?

With an output schema present, the description doesn't need to explain return values, and it covers the essentials an agent needs: eligibility gate, pagination model, partial-page flag, and the warning that these are not metrics. The only gap is guidance on choosing this over adjacent SD target/creative tools.

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

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

Schema description coverage is 100%, so all three parameters are documented in the schema, including startIndex's 'use nextStartIndex from the previous page.' The description reinforces the offset model but adds no format or constraint detail beyond the schema, so the baseline 3 applies.

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

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

The description opens with a specific verb+resource: 'Read one page of Sponsored Display targets.' That clearly separates it from SD campaign/ad-group/creative siblings. It does not explicitly contrast with amazon_ads_get_sd_negative_targets, which is the nearest ambiguous sibling, so an agent must infer the split from the name 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?

'Requires Display eligibility' is a genuine precondition, but there is no statement of when to reach for this tool versus the SD negative-targets or creative siblings. Usage is implied by the resource name rather than stated.

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

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

The annotations already declare this is a read-only, idempotent, non-destructive operation. The description adds useful behavioral context beyond annotations by noting default inclusion of paused and archived entities and warning that a single page is not the full account total.

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

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

Three short sentences are front-loaded with the core operation and the most important caveat about pagination. Every sentence carries useful information with no wasted wording.

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

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

Given the rich schema, output schema, and annotations, the description supplies the remaining context an agent needs: the result type, default state inclusion, and pagination limitation. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description reinforces the default state behavior and nextToken continuation pattern, but it does not add substantial parameter-level meaning 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: reading Amazon Sponsored Products targets. It scopes the result as configuration records rather than performance metrics and notes that paused and archived entities are included by default, which distinguishes it from report-oriented and other ad-type 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 clearly explains pagination behavior: continue with nextToken until absent, and one page is not an account total. It also implies the right context by clarifying these are configuration records, though it does not explicitly name alternative sibling tools such as negative-target or SB/SD target tools.

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

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

Annotations already declare this as a read-only, idempotent, non-destructive, open-world operation. The description adds useful behavior beyond that: pagination via nextToken with the same filters, returned download/playback URLs and moderation metadata, and the caveat that uploaded assets do not prove campaign delivery.

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

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

The description is front-loaded and dense: the first sentence establishes the search scope and return content, followed by pagination, a caveat, and a sibling alternative. Every sentence contributes useful selection or invocation 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?

Given rich annotations, full schema descriptions, and an output schema, the description provides enough additional context to call the tool correctly. It covers pagination, filter reuse, asset types, caveats, and the key sibling alternative for Sponsored Products images.

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 parameters are already well documented. The description reinforces that nextToken must be used with the same filters, but otherwise adds little parameter-level meaning 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 uses a specific verb and resource: "Search the Amazon creative asset library" and enumerates the asset kinds and returned details. It also distinguishes this listing tool from amazon_ads_get_product_metadata for Sponsored Products images, so an agent can identify its role without opening the schema.

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

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

It states the search context, explains one-page pagination with nextToken, and explicitly routes Sponsored Products images to amazon_ads_get_product_metadata instead. The caveat that uploaded assets are not proof of campaign use or delivery also clarifies the tool's evidential limits.

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 real behavioral detail beyond the annotations: profiles outside the allowlist are never returned or counted, and configured-but-absent IDs surface in missingProfileIds. Annotations already establish read-only/idempotent safety, so this is meaningful extra context, though it says nothing about pagination or failure modes for unreachable regions.

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

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

Three compact sentences, front-loaded with what is listed, then the allowlist constraint, then the edge-case output field. No filler.

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

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

With an output schema present and no parameters, the description covers what is returned (marketplace, account type, currency, timezone) and explains the one non-obvious output field, missingProfileIds. Nothing needed to invoke it correctly is absent.

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

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

Zero parameters, so the baseline is 4; the description still adds value by naming the two configuration sources (AMAZON_ADS_PROFILE_IDS and AMAZON_ADS_REGION) that implicitly drive the result set.

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 (List) and resource (advertising profiles), plus scope qualifiers: only profiles in AMAZON_ADS_PROFILE_IDS reachable in AMAZON_ADS_REGION. This clearly separates it from the singular sibling amazon_ads_get_profile and from the many get_* campaign/ad-group tools.

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

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

The description implies this is the enumeration step constrained by an allowlist, but never explicitly says when to call it versus amazon_ads_get_profile or which siblings depend on its output. The scoping rule is clear; the selection guidance is left implicit.

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