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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds the specific constraint that it should be read once per session, which is useful behavioral context. It also clarifies the content scope ('behavior the official docs do not state'), which goes beyond annotations. No contradiction with annotations.

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

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

The description is a single sentence that is concise and directly states the purpose and the usage hint. It is front-loaded with the topic and ends with the session constraint, making it efficient and easy to parse. There is 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 tool has no parameters, a clear purpose, and an output schema (which likely describes the returned notes), the description is sufficient for an agent to know when and why to call it. It could mention the nature of the notes more explicitly, but the current description combined with the output schema is adequate for a simple read-only informational tool.

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

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

The tool has zero parameters, so the schema fully covers them (coverage 100%). With 0 params, the baseline is 4, and the description does not need to add parameter-specific information. It correctly focuses on behavior and usage rather than parameter details.

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

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

The description clearly identifies the tool as providing undocumented Amazon Ads API behavior, and 'Read once per session' implies a retrieval action. It is specific about the resource (API behavior notes) and distinguishes itself from sibling tools that perform concrete operations like get_plan or list_profiles. However, it lacks an explicit verb like 'retrieve' or 'fetch', so it is clear but not maximally explicit.

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

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

The phrase 'Read once per session' gives a clear timing instruction, implying it should be used at session start. However, it does not mention alternatives or conditions under which to use this tool versus the many sibling tools, nor does it state when not to use it. The guidance is implied rather than explicit.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is covered. The description adds valuable context: the fingerprint equality check and the check_drift default that refuses if values changed. This goes beyond what annotations provide and helps the agent understand the safety mechanism.

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

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

The description is concise and front-loaded with the most critical usage condition (user approval). The second paragraph adds necessary technical detail about fingerprint and drift without fluff. Every sentence earns its place.

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

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

Given the tool's complexity (applying a plan with potential destructive effects) and the presence of an output schema (which presumably explains return values), the description covers the key prerequisites and safety checks. It does not explain what the plan application entails, but that is not required for correct invocation. The fingerprint and drift details are the critical missing pieces that are provided.

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

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

Schema description coverage is 0%, so the description must compensate. It explains fingerprint (must equal the one returned when built/fetched) and check_drift (refuses if values changed). It does not explain plan_id, but that is self-explanatory from its name. The description adds meaning to two of three parameters, which is strong given the zero coverage.

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

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

The description clearly states the action: 'Apply a saved plan.' It specifies the verb and resource, and the context distinguishes it from siblings like list_plans, plan_create, and plan_update. The purpose is unambiguous.

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

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

It explicitly states the precondition 'Only call after the user approved this exact plan,' which is strong when-to-use guidance. It also explains the fingerprint requirement and drift behavior. However, it does not explicitly mention alternatives or when not to use it beyond the approval condition, so it misses the 'alternatives' aspect for a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that data-changing operations are refused, which is a behavioral constraint beyond the annotations. It doesn't detail error handling or response format, but the core behavior is transparent.

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

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

Two sentences, front-loaded with the core purpose and a clear exclusion. Every word earns its place; no fluff.

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

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

For a read-only API caller with annotations covering safety, the description is mostly complete. It lacks details on how to construct body/query/path_params and what the response looks like, but the reference to search_operations and the refusal of mutating operations give enough context for an agent to proceed. The absence of an output schema is partially mitigated by the read-only nature.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by id' and references search_operations, implying the operation parameter is an id, but it doesn't explain market, body, query, or path_params. The description adds some context for the operation parameter but leaves the other parameters to be inferred from their names and schema types.

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

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

The description clearly states the tool calls a read-only operation from Amazon's specs by id, and explicitly distinguishes it from data-changing operations. It also references search_operations as the way to find operations, which helps an agent understand the tool's role.

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

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

The description explicitly says when to use this tool (for read-only operations) and when not to use it (operations that change data are refused; use a plan tool instead). This is strong guidance that prevents misuse.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to repeat safety. It adds the 90-day time window constraint, which is useful behavioral context. It doesn't describe output format (output schema exists) or any side effects, so it adds some value beyond annotations but not extensive.

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

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

The description is concise, front-loading the purpose in the first line. The parameter notes are terse and efficient. However, the use of an ellipsis '...' in the changes list is incomplete and slightly sloppy, and the structure could be improved with clear sections for each parameter.

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 7 parameters, 0% schema coverage, and an output schema present, the description is insufficient for an agent to call the tool correctly. It explains some parameters but omits key ones like market, entity_ids, and campaign_ids, and doesn't clarify the meaning of the allowed values. The agent would have to guess or rely on external knowledge.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It explains 'since' and its relationship to 'days', and lists allowed values for entity_types and changes (with an ellipsis). However, it leaves market, entity_ids, and campaign_ids completely unexplained, which is a significant gap for a 7-parameter tool with a required market parameter.

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

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

The description clearly states the tool returns change history with details of what changed, from what, to what, and when. It distinguishes itself from siblings like get_suggested_bids or run_report by its explicit focus on change history. However, it doesn't explicitly contrast with any specific sibling, so it's clear but not differentiated.

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

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

There is no guidance on when to use this tool versus alternatives. It doesn't mention any context like 'use for auditing changes' or exclude cases where other tools are better. The description is purely declarative and offers no usage direction.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the specific return fields (table, fingerprint, status), which is useful context beyond the annotations. However, it doesn't mention any additional behavior like error handling or pagination, but for a simple read tool this is acceptable.

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

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

The description is a single sentence that directly states the core output of the tool. It is front-loaded and contains no filler or redundant information, making it optimally concise.

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

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

For a simple get-by-id tool, the description provides the key output details and the schema indicates the required parameter. However, it lacks guidance on when to use this tool versus siblings, and it doesn't mention that plan_id is required or how to reference it. The presence of an output schema covers the return structure, but the description is thin on operational context.

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

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

Schema description coverage is 0%, and the description does not explain the plan_id parameter at all. The parameter name is self-explanatory, but the description fails to add any context about how to obtain plan_id or what format it should be in. Since the description carries the burden for low schema coverage, it falls short.

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

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

The description clearly states the tool returns a saved plan's table, fingerprint, and status. This is specific enough to distinguish it from list_plans (which lists plans) and other plan-related tools, though it doesn't explicitly use a verb like 'retrieve' or 'fetch'. The name get_plan reinforces the purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_plans or plan_update. It doesn't mention that it's for retrieving a single plan by ID or contrast it with listing all plans. An agent has to infer usage from the name and schema alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read nature is covered. The description adds useful behavioral context by saying the result includes suggested low/median/high bids next to the live bid, but it does not discuss request scope behavior, optional filter semantics, or rate limits.

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

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

The description is compact and front-loaded with the key resource and action. It earns its place in a single sentence, though the phrasing is slightly awkward and could be clearer about the bid comparison.

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?

Even though the output schema exists and annotations cover safety, the description is incomplete for correct invocation. The required `market` parameter is never explained, and most optional filter parameters lack any semantic guidance. A caller would need external knowledge or sibling descriptions to use this confidently.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only clarifies `kind` values ('keywords' or 'targets') and the idea of existing entities, but leaves `market`, `theme`, `ids`, `ad_group_ids`, and `campaign_ids` unexplained. This is a significant gap for a 6-parameter tool.

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

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

The description names a specific verb and resource: 'get' Amazon's suggested low/median/high bid relative to the live bid. It also narrows scope to 'existing enabled keywords or targets' and specifies the kind values, which clearly distinguishes it from the sibling `get_suggested_bids_for_new`.

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

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

The phrase 'for existing enabled keywords or targets' gives clear context and implies this is the tool for existing entities rather than new ones. It does not explicitly name alternatives or state when not to use it, but the scope is specific enough for an agent to route correctly.

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

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

Annotations already provide the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the description does not need to re-state that. It adds useful scoping context: the tool produces suggestions before an ad group exists and works on books, keywords, and product targets. It does not go further into operational behavior such as limits, dependencies, or how suggestions are calculated, so a 3 is appropriate.

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

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

The description is a single dense sentence with the key pre-ad-group context front-loaded and no filler. The word 'price' is slightly awkward as a verb, but it does not undermine the overall clarity or add unnecessary length.

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

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

The output schema and annotations cover return values and safety, and the description covers the core use case and the most important parameters. However, it leaves a few gaps for a 5-parameter tool: the semantics of market and theme are not explained, and there is no guidance about what happens when both optional keywords and target_asins are absent. These are minor but real gaps.

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

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

Schema description coverage is 0%, so the description has the burden of explaining parameters. It does add real meaning: asins are 'book(s)', target_asins are 'product targets', and keywords are given an inline object shape with EXACT/PHRASE/BROAD match values. It does not explain market or theme, but theme has a default and market is reasonably inferable as the marketplace, so the compensation is strong but not complete.

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

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

The description clearly identifies the resource ('Suggested bids') and the distinctive pre-ad-group context, and the phrase 'before an ad group exists' separates it from the sibling get_suggested_bids. It also names the relevant inputs: asins, keywords, and target_asins. However, it lacks an explicit verb like 'retrieves' or 'calculates', relying on the noun phrase and the tool name to convey the action.

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

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

The opening phrase 'before an ad group exists' gives a clear trigger condition for when to use this tool, and it naturally implies that the sibling get_suggested_bids is for the existing-ad-group case. It does not explicitly state when not to use the tool or name alternatives, but the timing guidance is specific enough for an agent to route correctly.

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

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

The description discloses key behaviors beyond what annotations provide: the default states (ENABLED and PAUSED), the effect of include_archived, and the semantics of text_contains filtering (case-insensitive, applied after fetching). This is significant behavioral context that helps an agent predict results and side effects. Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered; the description adds valuable filtering and default behavior details.

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

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

The description is two sentences only: the first states the purpose, the second packs essential parameter details. It is front-loaded with the core action, and every sentence earns its place by conveying non-redundant information. No fluff or 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?

For a tool with 8 parameters and 0% schema coverage, the description covers the most critical parameters (entity, states, include_archived, text_contains) and explicitly notes the filtering behavior. The 'market' parameter is simple, and ids/campaign_ids/ad_group_ids are likely straightforward filters. The output schema likely documents return structure, so the description does not need to. Minor gaps include potential pagination or limit behavior, but these are acceptable given the annotations and 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?

With 0% schema description coverage, the description must compensate. It explains the 'entity' parameter by listing valid values, clarifies 'states' default, and specifies the behavior of 'include_archived' and 'text_contains'. It does not explicitly explain 'market', 'ids', 'ad_group_ids', or 'campaign_ids', but these are self-evident from their names and the context. The coverage is strong for the complex parameters, though a couple of simpler ones are left to inference.

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

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

The description clearly states that the tool lists Sponsored Products entities for a given market, and enumerates all supported entity types (campaigns, ad_groups, keywords, etc.). This distinguishes it from sibling tools like list_profiles or get_plan, which target different resource categories. The verb 'list' and resource 'entities' are specific and unambiguous.

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

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

The description implies usage—when you need to list any of the mentioned entity types—but does not explicitly state when to prefer this tool over alternatives like list_profiles or get_plan. There is no 'use this when' phrasing or exclusions for cases where another tool would be more appropriate. The context is clear enough for a generic list tool, but it lacks explicit routing guidance.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is established. The description adds useful behavioral context—ordering and the inclusion of an applied flag—but does not mention pagination, minimum/maximum limits, or other runtime behaviors beyond the schema.

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

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

The description is a single concise sentence that delivers three useful facts without filler or repetition. It is front-loaded with the resource and immediately communicates the most important output characteristics.

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

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

For a simple tool with one optional parameter, an output schema, and safety annotations, the description covers the essential return semantics: recency, ordering, and applied status. It could additionally clarify the limit behavior, but the tool's overall complexity is low enough that the definition is nearly 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 0%, and the description does not mention the 'limit' parameter at all. The parameter name and default value make its purpose somewhat self-evident, but the description fails to compensate for the uncovered schema, so the agent gets no semantic enrichment from the description.

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

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

The description identifies the resource ('plans'), the ordering ('newest first'), and a key attribute ('whether each was applied'). It does not use an explicit verb like 'List', but the meaning is clear and it is distinguishable from singular/get and mutation siblings such as get_plan, plan_create, and apply_plan.

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

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

The description implies its use for retrieving recent plan records with applied status, but it does not explicitly say when to choose it over alternatives or when not to use it. Context from sibling names (get_plan, plan_create, plan_archive, apply_plan) suggests the intended case, but no guidance is stated directly.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful context by defining the result scope as all profiles reachable by credentials and clarifying the account x marketplace pairing, but it does not disclose additional behaviors like pagination or ordering. No contradiction with annotations.

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

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

The description is a single focused sentence with no filler. The core information is front-loaded and every word contributes meaning.

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

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

For a zero-parameter, read-only listing tool with an output schema and robust annotations, the description is complete. It tells the agent exactly what will be returned and requires no additional caveats.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is nothing for the description to explain. Baseline 4 applies since no parameter documentation is needed.

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 ('lists') and a precise resource definition ('advertising profile (account x marketplace)'), and adds the credential-scoping qualifier 'credentials reach.' This makes the tool's purpose immediately distinguishable from sibling listing tools like list_entities.

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

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

There is no explicit when-to-use guidance or mention of alternatives. However, the phrase 'every advertising profile ... the credentials reach' implies this is the discovery entry point for available profiles, so usage context is present but not directly stated.

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

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

Annotations already indicate the tool is non-read-only and non-destructive. The description adds meaningful behavioral context: the operation builds rather than applies, and archiving 'cannot be undone,' which warns about irreversibility. These statements complement the annotations and do not contradict them, so no annotation contradiction is flagged.

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

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

The description is a single, tightly written sentence with the primary action and warning front-loaded. Every word contributes: 'Build (not apply)' disambiguates the action, and 'Archiving cannot be undone; prefer pausing' delivers critical caution without excess.

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

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

For a tool with four parameters and zero schema-level descriptions, this description is too sparse. It explains the overall action and irreversibility but omits parameter meanings, prerequisites, and what the planned archive output looks like. Even with an output schema present, the description does not close the gap 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 0%, and the description provides no information about the four parameters (ids, note, entity, market). An agent cannot infer what 'ids' refers to, what entity/market mean, or how note is used. The description carries none of the burden of explaining input semantics.

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: 'Build (not apply) an archive.' The parenthetical 'not apply' explicitly distinguishes this from the apply_plan sibling, which helps an agent separate planning from execution. However, it never defines what archiving actually entails or what 'build' produces, so it is clear but not maximally precise.

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 guidance is largely implied rather than explicit. 'Build (not apply)' hints that this is the planning step before apply_plan, and 'prefer pausing' offers a cautionary alternative. But it does not explicitly name sibling tools or state concrete conditions for when to choose archiving over pausing or other alternatives.

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

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

Annotations already indicate this is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds the key nuance that it does not apply the create, only builds it, which is useful behavioral context beyond the annotations. However, it does not disclose other traits such as authentication requirements, rate limits, or what the output represents, and since annotations are sparse, the description carries a heavier burden that it only partially fulfills.

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

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

The description is a single sentence, concise and front-loaded with the crucial 'Build (not apply)' distinction. The example is embedded efficiently. There is no fluff or redundant wording. It earns a high score for structure, though it could have been slightly more explicit about the tool's purpose.

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

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

The tool has 4 parameters, 3 required, and an output schema exists. The description covers only 'items' via an example, but leaves 'market' and 'entity' undefined, which are likely essential for correct usage. It also does not mention what the tool returns or any constraints on the plan structure. Given the complexity and the sparse schema descriptions, the description is insufficient for an agent to reliably call this tool without additional assumptions.

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

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

With 0% schema description coverage, the description is responsible for explaining parameters. It provides an example for 'items' showing the expected structure (fields like campaignId, adGroupId, keywordText, matchType, bid, state), which adds valuable meaning. However, 'market' and 'entity' remain unexplained, and the description does not clarify the allowed values or their semantics. It partially compensates for the schema gap but not fully.

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

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

The description states a specific action ('Build') and object ('a create'), and explicitly contrasts with 'not apply', which distinguishes it from the sibling apply_plan. However, the term 'create' is somewhat vague without additional context, and the example is the only concrete detail. It is clear enough to infer that it constructs a plan for creating entities, but could be more precise.

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

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

The phrase 'not apply' hints that this tool is for building a plan rather than executing it, which differentiates it from apply_plan. However, it does not explicitly state when to use this tool vs alternatives, nor does it mention any prerequisites or scenarios where other tools are preferred. The 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?

The description clarifies that this is a planning operation with no direct application of changes, which is meaningful behavioral context beyond the annotations. It also identifies the data source as Amazon's change history. It does not contradict annotations, and it reinforces the non-destructive nature implied by destructiveHint=false.

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

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

A single, front-loaded sentence that communicates the core purpose, the non-application behavior, and the key parameter semantics. There is no filler or redundancy; every clause adds useful information.

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

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

Despite good annotations and an output schema, the description is incomplete for safe invocation: one required parameter ('market') is completely undocumented, and the optional 'campaign_ids' is also unexplained. An agent would need additional context to know what values these fields accept, making the overall context insufficient for a 3-parameter tool with 0% schema coverage.

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

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

The description gives precise semantics for 'since' (ISO datetime, UTC if no offset), which is valuable because schema description coverage is 0%. However, it leaves 'market' and 'campaign_ids' completely unexplained. Since the schema offers no parameter documentation, the description only partially compensates for the lack of coverage.

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

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

The description states a specific verb ('Build') and resource ('a plan restoring bids and states'), and explicitly distinguishes itself from applying by saying '(not apply)'. It also names the data source ('Amazon's change history'), so an agent can tell what this tool does at a glance and separate it from apply_plan and get_change_history.

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

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

The phrase '(not apply)' gives an implied usage boundary: use this tool when you want to construct a plan rather than execute one. However, it does not name the alternative tool explicitly, nor does it state when to prefer this over get_change_history, plan_update, or plan_create. The guidance is present but mostly implicit.

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

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

The annotations include 'openWorldHint: true', indicating the tool may interact with external systems, and 'destructiveHint: false', indicating it is not destructive. The description adds that it 'builds' an update, which is non-destructive. Since annotations already cover safety, the description adds minimal behavioral context beyond clarifying the non-apply nature. No contradiction found.

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

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

The description is concise, consisting of one sentence with an example. It is front-loaded with the core purpose ('Build (not apply) an update') and the example clarifies the changes format. No unnecessary detail.

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

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

Given the tool's complexity (building an update with flexible changes) and the lack of schema descriptions, the description provides a key example but does not explain the full range of possible changes or how to specify the entity and market. The presence of an output schema may cover return values, but parameter semantics are incomplete. The description is sufficient for basic use but leaves gaps for comprehensive use.

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

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

The input schema has no descriptions, and the schema description coverage is 0%. The description explains the format of the 'changes' array with examples, which is helpful, but it does not provide details on other parameters like 'entity', 'market', or 'note'. Since coverage is 0%, the description must compensate, and it only partially does so for 'changes', leaving other parameters ambiguous.

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

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

The description clearly states the tool 'Build (not apply) an update', using a specific verb 'Build' and resource 'update'. It distinguishes itself from the sibling 'apply_plan' by explicitly noting it does not apply. The description also provides concrete examples of the changes format, making the purpose clear and differentiating from related 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 indicates that this tool builds an update rather than applying it, which serves as a clear usage guideline differentiating it from 'apply_plan'. However, it does not explicitly mention when to use this tool versus alternatives, such as 'plan_create' or 'apply_plan', or provide context on when to use each. The exclusion is implied but not exhaustive.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, so the safety profile is already covered. The description adds valuable behavior beyond that: group_by changes output semantics (sums numeric columns per group rather than daily rows) and save_to writes every row to a JSON file. The save_to write is an output-file write, not a data-source mutation, so it does not contradict readOnlyHint.

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

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

Purpose and date format are front-loaded in the first sentence. The preset list is necessary since the schema has no enums, and the group_by/save_to explanations earn their place because the schema has zero descriptions. Slightly run-on formatting but efficient overall.

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 format is covered. The description handles the complex aspects (presets, group_by transformation, save_to side-effect) and date format. The only material omission is the required 'market' parameter, which has no description or enum to guide the agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains preset (all seven valid values), group_by (summing behavior with examples), save_to (writes JSON), and start/end date format (YYYY-MM-DD, any length). The only gap is 'market', which is required but never described.

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

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

The description states a clear verb+resource: 'Run a report... return rows or totals' with date range YYYY-MM-DD. The preset list further scopes what kinds of reports. It's clearly distinct from all sibling tools, none of which run reports, though it doesn't explicitly name a sibling as the alternative.

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 strong HOW-to guidance (presets, group_by semantics, save_to behavior) but no explicit WHEN-to-use versus alternatives. Usage context is implied by the unique purpose, yet there's no guidance on when not to use it or which sibling might be more appropriate for a given scenario.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context about the scope (~1,200 operations in published specs) but does not describe behavior such as return format, pagination, or filtering logic. With annotations present, this is adequate but not additional rich behavioral disclosure.

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

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

The description is a single concise sentence with no wasted words. It front-loads the action ('Find') and the resource ('any of the ~1,200 operations'), making the purpose immediately clear.

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

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

Despite having an output schema and annotations, the description lacks key context: it does not explain the 'api' parameter, offer any usage guidance, or mention what happens when no results are found. For a tool with two parameters, this is incomplete from an agent's decision-making perspective.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It explains the 'text' parameter as a keyword but leaves 'api' completely unexplained, despite it being an optional filter. The description only partially compensates for the schema gap.

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

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

The description clearly states the tool's function: finding operations from Amazon's published specs by keyword. It uses a specific verb ('find'), a specific resource ('operations in Amazon's published specs'), and a specific method ('by keyword'), which distinguishes it from siblings like call_operation or get_plan.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that call_operation should be used for invoking operations, or any other contrast with sibling tools. Usage context is only implied by the search-oriented phrasing, not explicitly stated.

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