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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds that exactly one previously reviewed preview is applied, but it largely repeats the idempotency annotation and omits details such as token expiry, failure behavior, or permission requirements.

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

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

The description is a single front-loaded sentence with no wasted words. It communicates the core action, scope, and idempotent nature efficiently.

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

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

For a low-complexity write tool with rich annotations and an output schema, the description is nearly sufficient. It establishes the preview prerequisite and one-preview limitation, though it leaves the preview_token source and error behavior to inference.

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 the single preview_token parameter. It links the token to a "previously reviewed preview," which adds useful context, but it does not explain where the token comes from, its format, or its validity window beyond that implication.

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: apply a previously reviewed preview to DigiKey MyLists. It is clearly distinguishable from sibling preview/read/update tools because it applies a preview rather than creating, validating, or editing one. The scope is also constrained to exactly one preview.

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 "previously reviewed preview" provides clear workflow context: this tool is used after a preview has been reviewed. It does not explicitly name the sibling preview_mylist_changes tool or state when not to use it, so it falls 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and external-data context is covered. The description adds that it returns 'exact current details' (implying live, not cached data) and performs an 'attributed comparison,' but gives no detail on rate limits, auth, or return structure beyond what the output schema provides.

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

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

The description is a single, front-loaded sentence with no redundant or filler content. It communicates the core action and scope efficiently.

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

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

With an output schema present and read-only annotations, the description covers the basic action. However, for a comparison tool with an undocumented array parameter, it should clarify the expected product-number format and what 'attributed comparison' means, which it currently leaves vague.

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 does clarify that the product_numbers array should contain 'two or more parts,' which adds a minimum-count constraint not present in the schema. However, it does not specify the expected identifier format (e.g., Digi-Key vs. manufacturer part number), leaving a key semantic 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 states a specific verb ('Fetch'), resource ('details for two or more parts'), and scope ('for an attributed comparison'). It distinguishes the tool from single-part siblings like digikey_get_part by requiring two or more parts, though it does not name any sibling explicitly.

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

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

The phrase 'for two or more parts for an attributed comparison' implies the use case (comparing multiple parts), but the description gives no explicit when-to-use guidance, no alternatives, and no conditions for choosing this over digikey_get_part or digikey_find_alternates.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds a meaningful behavioral caveat: results are 'unverified candidates', telling the agent not to treat them as validated. This is valuable context beyond structured fields.

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

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

A single short sentence that is front-loaded and contains no filler. It gets to the point immediately.

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 explained. But with low schema coverage and no usage guidance or parameter details, the description is minimal for a tool with a required input and a limit parameter.

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 mentions no parameter details. It doesn't clarify the meaning or format of 'product_number' or what 'limit' controls. This leaves the agent guessing about 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?

States a verb (find) and resource (alternates) and names the source (DigiKey substitutions and recommendations). However, it does not differentiate from siblings like digikey_compare_parts or digikey_search_parts, leaving overlap that could confuse selection.

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

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

No when-to-use guidance, no conditions, and no mention of alternatives. The phrase 'unverified candidates' implies caution but doesn't specify when this tool is appropriate over a validated alternative.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that list-line data is returned alongside the list itself, which is modest but useful context about payload scope; it says nothing about permissions, rate limits, or whether the read is a live call to DigiKey.

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 tight sentence with the operation front-loaded and no filler. It is efficient, though the extreme brevity is also what leaves the gaps in usage and parameter guidance.

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

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

An output schema exists, so return values need not be explained, and the annotations cover the safety profile. What remains missing is how list_id is obtained and how this read relates to the enumerate/validate/apply siblings — enough to make the definition only minimally sufficient.

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

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

There is one required parameter (list_id) with 0% schema description coverage, and the description does not characterize it at all — no format hint, no statement that it comes from digikey_list_mylists. With a low-coverage schema the description should compensate and does not.

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 ('one DigiKey MyList') plus the payload ('its current list-line data'), which is clearer than a bare name restatement. It implicitly distinguishes the singular read from the sibling digikey_list_mylists (plural enumerate), though it never names that sibling explicitly.

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

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

No when-to-use guidance is given: nothing says this is the fetch-one-list operation to use after enumerating lists or before mutating lines. Siblings like digikey_list_mylists, digikey_validate_mylist and digikey_preview_mylist_changes are not referenced, so the agent must infer the routing itself.

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 openWorldHint=true, so the safety profile is covered. The description adds the useful context that data is 'current' and 'exact,' suggesting live external lookups. However, it does not mention rate limits, authentication requirements, or what happens when a part number is not 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?

A single, well-structured sentence that front-loads the core purpose and lists the data categories retrieved. No filler or 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?

An output schema exists, so return values need not be explained. However, with zero schema description coverage on two parameters, the description is incomplete for an agent to call this tool correctly without guessing parameter formats and the role of manufacturer_id.

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%, meaning neither parameter is documented in the schema. The description adds no information about what product_number or manufacturer_id should contain, how to format them, or when manufacturer_id is needed. With two parameters and zero schema coverage, the description should compensate but does not.

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 (Get) and resource (product/part data) with the exact data categories retrieved: product, variation, stock, lifecycle, and pricing. An agent can distinguish this from digikey_search_parts because the description emphasizes retrieving 'current exact' data for a known part rather than searching.

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 word 'exact' implies this is for retrieving a specific known part rather than searching, which differentiates it slightly from digikey_search_parts. However, there is no explicit statement of when to use this versus digging through search results, and no mention of prerequisites or error 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 readOnlyHint=true and openWorldHint=true, so safety and reach are covered structurally. The description adds the useful detail that results are scoped to the authenticated user, but says nothing about pagination behavior despite the presence of a limit parameter, nor about ordering or what happens when the user has no lists.

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

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

A single front-loaded sentence with no filler or redundancy. It is appropriately sized for a simple list operation, though brevity here edges toward under-specification rather than disciplined conciseness.

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

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

An output schema exists, so return value shape need not be explained, and annotations cover the read-only profile. What remains missing is any treatment of the limit parameter and pagination, which for a list endpoint with a default page size is a meaningful gap.

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

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

Schema description coverage is 0%, so the single 'limit' parameter (default 50) is undocumented in both the schema and the description. The description never mentions limiting or pagination, leaving the agent to guess what the parameter controls and whether more results can be fetched.

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 clear verb+resource (list MyLists) and scopes it to the authenticated user, which is more precise than the bare name. However, it offers no differentiation from the closely named sibling digikey_get_mylist, so an agent cannot tell from the description alone which one to pick for a single list vs. all lists.

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

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

There is no guidance on when to use this versus digikey_get_mylist or the other mylist siblings (validate, preview, apply, update_line, remove_line). The only implied context is that the user must be authenticated, which is inferred from 'authenticated user's' rather than stated as a precondition.

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 openWorldHint, so the safety profile is covered. The description adds genuinely non-obvious behavior beyond that: the preview is 'expiring' and 'signed', implying a time-limited token returned to the caller. It still omits what happens on invalid SKUs and how list_id vs list_name interact.

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

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

A single front-loaded sentence with a clear verb and no filler; the key non-mutating guarantee is stated up front. It is efficient, though arguably too terse given the schema's complexity.

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 taking a nested array of line items with target price, attrition, packaging and reference fields at 0% schema coverage, one sentence is not enough. An output schema exists so return values need not be explained, but the input contract is largely 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 0% across 4 top-level params and a 9-field nested RequestedLine object. The description only hints that part numbers must be 'exact' SKUs and says nothing about lines, list_id/list_name selection, or assembly_count, leaving the nested pricing/attrition fields entirely undocumented.

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

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

States a specific verb and resource ('Validate exact SKUs', 'return an expiring, signed preview') and contrasts itself with the write path via 'without changing DigiKey'. It is distinguishable from apply_mylist_changes, though it does not explicitly differentiate itself from the similarly named sibling digikey_validate_mylist.

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 'without changing DigiKey' and 'preview' imply this is a dry-run step before apply_mylist_changes, so the usage context is inferable. However, no sibling is named and there is no explicit when/when-not guidance versus validate_mylist or apply_mylist_changes.

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 and idempotentHint=true, so the destructive nature is known. The description adds the requirement for explicit user confirmation, which is useful context, but it doesn't elaborate on what else gets destroyed or any side effects. With annotations providing the safety profile, 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?

A single, front-loaded sentence with no waste. It states the action and the critical condition directly.

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 destructive and has an output schema, so return values need not be explained. However, the description is minimal for a destructive operation, and it doesn't clarify the role of the 'confirm' parameter, which is crucial for safety. It provides some context but leaves 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 coverage is 0%, so the description must compensate but does not. It mentions 'exact IDs' implying list_id and unique_id are needed, but adds no format or semantics beyond what parameter names suggest. The 'confirm' flag is not explained in the description. Baseline is 3 because the schema itself defines the parameters, but description could do more.

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 (delete) and resource (MyList line), differentiating it from siblings like update_mylist_line or apply_mylist_changes. It is slightly vague about the scope ('line' rather than 'part entry'), but the core purpose is clear.

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 a clear condition for using the tool: only when the user explicitly confirms the exact IDs. It does not name alternative tools, but the gate condition is explicit and useful.

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

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

Annotations cover safety (readOnlyHint=true, openWorldHint=true), so the bar is lowered, but the description adds nothing beyond that: it doesn't explain the effect of the in_stock and exclude_marketplace defaults, pagination/limit behavior, or the 'standard pricing' distinction. For an external-API search tool, this leaves meaningful behavior undisclosed.

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

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

A single short sentence with no padding, but that brevity comes at the cost of substance rather than being earned conciseness.

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

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

An output schema exists so return values needn't be described, but with 0% parameter coverage, unexplained defaults, and no usage guidance, the definition is not complete enough for an agent to call it confidently alongside ten 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 0% and none of the four parameters (query, limit, in_stock, exclude_marketplace) are explained in the description. The one added phrase, 'standard pricing', corresponds to no parameter, so the description does not compensate for the schema gap at all.

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 verb (Search) and resource (DigiKey parts), but the qualifier 'discovery candidates using standard pricing' is vague jargon that doesn't tell the agent what makes this different from digikey_get_part, digikey_compare_parts, or digikey_find_alternates. The purpose is inferable but not sharply defined.

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

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

No when-to-use guidance, no prerequisites, and no mention of any sibling tool as an alternative. The agent must guess whether this is the entry point for part lookup versus the get/compare/alternates 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?

With annotations already covering readOnlyHint=false, destructiveHint=false, idempotentHint=true, and openWorldHint=true, the description adds the important two-mode behavior: preview by default or explicit confirmation to replace an existing line. It does not describe permissions or side effects in detail, but it adds meaningful behavioral context beyond the annotations.

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

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

The description is a single front-loaded sentence with zero wasted words. It states the operation and mode switch efficiently, making it easy to scan before opening the schema.

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

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

The tool has an output schema and annotations, so return values and safety hints are partially covered. However, for a four-parameter mutation-like operation with 0% schema description coverage, the description is too thin: it omits parameter semantics, consequences of replacement, and guidance against sibling 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 0%, so the description must compensate for parameter meaning, but it only hints at confirm and the target line. It does not explain list_id, unique_id, or the fields within the nested RequestedLine object, leaving most required parameters undocumented.

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

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

The description names a specific action (preview or explicitly confirm replacement) and a tightly scoped resource (one existing MyList line). It does not explicitly contrast with siblings like apply_mylist_changes or remove_mylist_line, but the singular line and replacement framing are clear enough to distinguish the operation.

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

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

The phrase 'Preview or explicitly confirm' implies a two-phase usage model, with confirm controlling commit versus preview. However, it never states when this tool is preferable to sibling tools such as preview_mylist_changes, apply_mylist_changes, or remove_mylist_line, so the guidance remains 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 declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. 'Refresh' implies re-fetching external data (consistent with openWorldHint) and 'report warnings' hints at a non-mutating validation output, adding modest context. However, it doesn't explain what a warning looks like, whether results are cached, or rate/credential constraints for the external DigiKey call.

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

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

Single front-loaded sentence with a specific verb and outcome, zero filler. Efficient, though it could be slightly richer given the tool's role.

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 needn't be explained. But for a parameter that is entirely undocumented (0% coverage) and a read-only external validation tool with no usage guidance, the description leaves gaps an agent would need to fill elsewhere.

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 there is one required parameter (list_id) that the description never mentions or explains. The tool's name implies a MyList context, but the description does not clarify list_id's format or source, leaving the sole parameter undocumented.

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

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

Clear verb ('Refresh... against exact DigiKey product data') and resource ('every MyList line'), with an explicit output ('report warnings'). Distinguishes itself from siblings like digikey_update_mylist_line (which mutates) and digikey_get_mylist (which just reads), though it doesn't name an alternative directly.

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

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

The description implies this is a validation/refresh operation for a MyList, but it offers no explicit when-to-use guidance, no condition selecting it over digikey_preview_mylist_changes or digikey_get_mylist, and no statement of prerequisites.

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