A2A Peptides

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

With readOnlyHint=false and no positive safety hints, the description carries the behavioral disclosure burden. It explains that an allow routes the order intent with an envelope and card URL, while a deny returns filtered licensed destinations, and adds the guardrail 'never a vial'. It does not fully detail side effects like audit/logging or auth requirements, so it stops short of 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?

The description is compact at two sentences and front-loads the main verb. The second sentence is dense and stylized, but contains the necessary branch behavior and guardrail; 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?

The two-mode behavior is described, and an output schema exists to cover return values. However, with five optional parameters and no param-level descriptions, an agent still cannot confidently know how to populate intent_id, decision_id, or limit, and the description does not address selection against sibling directory 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 0%, so the description must compensate, but it only loosely maps to practice_scope and counterparty_card_url ('card URL'). The parameters decision_id, intent_id, and limit are effectively unexplained, leaving an agent to guess their role and format.

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 ('Hand off over A2A') and clarifies the two distinct branches: routing an order intent to a licensed counterparty agent on allow/require_rx, and returning provider-directory destinations on deny. It distinguishes itself from dispensing tools with 'a referral, never a vial', though it does not explicitly name or contrast sibling 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 when to use the tool by tying behavior to decision types: allow/require_rx versus deny. However, it never explicitly states alternatives among sibling tools or conditions under which this tool should not be used, leaving selection guidance implicit rather than direct.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that presentations must be 'authorised', implying a permission requirement not in annotations, and clarifies the ID format by referencing get_item. It does not describe output behavior, but the output schema exists, so that 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?

A single, direct sentence that front-loads the primary action and includes a clarifying reference. No filler or repetition; the structure is efficient.

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

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

The tool has 2 parameters and an output schema, so the description need not detail return values. However, because schema coverage is 0% and only presentation_ids is partially addressed, the description is incomplete for correct invocation. The optional decision_id is completely undocumented, making it unclear whether or how an agent should populate it.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'ids as for get_item', which gives partial meaning to presentation_ids, but does not explain decision_id at all. With two parameters and no schema descriptions, this is a significant gap that leaves the optional decision_id parameter 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 verb 'Compare' and the resource 'presentations', and indicates the action is side-by-side comparison. It references 'ids as for get_item' to clarify the ID format, which adds precision. However, it does not explicitly distinguish from sibling tools beyond the naming, though there is no obvious overlapping tool.

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

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

Usage is implied by the description—comparing presentations is a distinct operation. The reference to get_item suggests the same ID scheme, but there is no explicit statement about when to use this tool versus alternatives or any conditions that would favor a different tool. This leaves an agent to infer the scope.

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 readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the description is not required to restate those. It adds useful behavioral context: the intent 'settles by x402 on peptides-x402.ai', which tells the agent the downstream settlement mechanism. It does not disclose side effects, idempotency behavior, or failure modes, but the annotations cover the basic safety profile.

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 front-loads the core action and adds two pieces of contextual information. It is compact and readable, though the mention of 'reason_code + rule_set_version' is slightly cryptic and could be clearer.

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 5 parameters, 0% schema coverage, and no parameter explanations in the description. The output schema exists, so return values are covered, but the agent cannot determine what values to pass for presentation_id, decision_id, quantity, tenant, or ship_to. The workflow context ('after the gate') is helpful but insufficient 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%, so the description carries the full burden for parameter meaning. It mentions 'reason_code + rule_set_version' as carried by the intent, but these are not even parameters in the schema. The actual parameters (presentation_id, quantity, decision_id, tenant, ship_to) are not explained at all, leaving the agent to guess their 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 ('create') and resource ('order intent'), and adds meaningful context: it is for a 'cleared item after the gate' and carries 'reason_code + rule_set_version'. This distinguishes it from sibling tools like gate_transaction and search_cleared_items, though it does not explicitly name a sibling.

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

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

The phrase 'after the gate' implies a sequencing condition—this tool should be used after gate_transaction has cleared an item. However, it does not explicitly state when not to use it or name alternatives, leaving the agent to infer the workflow position.

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, so the safety profile is covered. The description adds behavioral context beyond that: the tool is coupled to gate_transaction output and only accepts allow or require_rx decision types, which is not derivable from the schema or 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 with no filler; the core purpose is front-loaded and the key precondition follows immediately. The phrasing is slightly fragmentary ('Licensed parties for...') but economical and every clause 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?

An output schema exists so return values need no explanation, and annotations cover the safety traits. The description states the gate_transaction dependency, which is the main integration requirement. It omits guidance on non-eligible decisions and tenant semantics, leaving minor gaps for a moderate-complexity 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?

With 0% schema description coverage, the description must carry parameter meaning. It meaningfully explains decision_id (must come from gate_transaction and be allow/require_rx) and clarifies presentation and jurisdiction as the look-up keys. However, tenant is only mentioned ('tenant as a parameter') without explaining its role, and no format constraints are provided.

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 the resource ('licensed parties') and scope ('for a presentation in a jurisdiction'), and anchors it in the pipeline by requiring a decision_id from gate_transaction. It is distinguishable from siblings like resolve_actor and search_cleared_items, though the noun-phrase opening is slightly less explicit than a verb-led statement.

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

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

It conveys the key precondition—only usable with an allow or require_rx decision_id from gate_transaction—which orients the agent to the correct point in the flow. It does not name alternative tools or explicitly state when not to use it (e.g., for deny decisions), leaving exclusions 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 cover readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds useful behavioral context by stating that the result is a 'frozen' reason code and includes the rule-set version, source page, and decision_id, which clarifies that this is a deterministic decision output rather than a live enforcement action.

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 that front-loads the core decision and then lists inputs and outputs without wasted words. Every clause contributes either to what the tool does or what it returns.

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 6 parameters, 4 required, no schema descriptions, and an output schema. The description covers the overall purpose and return fields, but it leaves several parameter semantics unexplained and offers no usage context. Given the complexity and missing schema coverage, more detail is needed for an agent to invoke this correctly in all cases.

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 description coverage at 0%, the description must compensate, and it does partially: it enumerates pathway values and specifies substance identifier formats (name, INN, or unii:). However, actor_class, channel, ship_to, and credential are left undefined, and credential is not mentioned at all, so the compensation is incomplete.

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 decision outcome — allow, deny, or require_rx — and names the relevant input dimensions (substance, pathway, actor class, channel, ship-to). It also distinguishes itself from siblings by noting the frozen reason code, rule-set version, source page, and decision_id produced for downstream tools.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as get_compounding_eligibility, get_pathway_status, or create_order_intent. The phrase 'for the downstream tools' implies a pipeline position, but it does not state conditions, exclusions, or selection criteria.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds context about the precondition and the structure of the returned data, which is helpful. 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 dense sentence that packs purpose, precondition, and output summary. It is front-loaded and not verbose, though it uses domain-specific jargon that may reduce immediate readability.

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

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

There is an output schema (not shown here), but the description provides a good verbal overview of the returned fields (banners, pos_count, product_urls, tenant offers). It also notes the precondition. Missing error handling or behavior when the decision is not allow/require_rx, but that is minor for a read-only, idempotent tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains decision_id as coming from gate_transaction and presentation_id implicitly, but does not explain tenant at all. The mention of 'tenant offers' hints at tenant's role, but it's not explicit. This is a moderate 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 retrieves availability data for a presentation, conditioned on a gate_transaction decision. It specifies the exact data returned (banners, pos_count, product_urls, tenant offers) and distinguishes itself from sibling tools like get_price or get_item by focusing on availability after a gate decision.

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 defines the precondition: the tool should be used after gate_transaction has returned allow or require_rx, with the decision_id. This gives a clear temporal usage context. It does not name alternatives or when not to use it, but the precondition is a strong implicit guideline.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the context of 'from the register' and the list types, but does not disclose any behavioral traits such as failure modes, data source limitations, or whether results are cached. Given annotations cover the key safety aspects, this is acceptable but not enriched.

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 that directly states the core question. It is concise with no filler, and the key information (substance, jurisdiction, list types) appears early. It could be improved with structured sections, but it is efficient for its 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?

An output schema is present, so return values are defined externally. The description is adequate for a simple lookup tool with two string parameters. However, it lacks guidance on edge cases (e.g., unknown substances, jurisdiction format) and does not explain the relationship to sibling tools. For the tool's complexity, it is minimally sufficient but not comprehensive.

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 'substance' and 'jurisdiction' implicitly in the sentence, but provides no additional meaning such as accepted formats, examples, or required representations. The description adds no value beyond what the tool name and schema already convey, leaving the agent to infer parameter details from the schema alone.

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 purpose: to determine whether a substance may be lawfully compounded in a jurisdiction and which list/standard applies. It uses a specific verb ('get') and resource ('compounding eligibility'), and the mention of specific standards (503A/503B, provincial, magistral, Specials) distinguishes it from sibling tools like get_availability or get_price.

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 conditions that would make it the right choice, nor does it reference any sibling tools or exclusions. The usage context is implied by the purpose, but there is no explicit 'use when...' or 'instead of...' 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context by saying events are dated and URL'd and by listing categories, but it does not disclose pagination, ordering, filter combination behavior, or other execution traits. This is adequate but not rich.

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. It front-loads the core output characteristics and packs the event type list into a compact series, which helps an agent quickly understand the tool's coverage.

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 structure and safety, so the description does not need to re-explain those. However, it misses usage guidance and the semantics of the since parameter, leaving the overall picture adequate but incomplete for fully informed 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?

With 0% schema description coverage, the description must carry parameter meaning, but it only explains substance and jurisdiction as filters. It never mentions the since parameter or how the filters combine, leaving part of the input semantics undocumented. This is a meaningful gap for a tool with only three parameters.

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 a resource: enforcement events, and scopes them to a substance or jurisdiction. It enumerates concrete event types like warning letters, import alerts, and proposed rules, which makes the tool's purpose specific and distinguishable from generic getters. It lacks an explicit verb and direct sibling contrast, so it falls just 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 no guidance about when to choose this tool over alternatives or when not to use it. It implies use for enforcement event lookups, but it does not state conditions, exclusions, or preferred contexts. The sibling tools include other getters, but no differentiation is 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?

The read-only, idempotent, non-destructive safety profile is already covered by annotations, so the description carries less burden here. It adds that the operation returns exactly one presentation and that offers are tenant-scoped ('tenant is a parameter'), which is useful behavioral context 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 compact, front-loaded, and contains no filler. The dense parenthetical enumeration of identifier formats and the clipped trailing field list are efficient but slightly harder to parse than a more structured phrasing would be.

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 main identifier parameter and the returned record shape are well covered, and an output schema is present. However, decision_id semantics are missing, tenant behavior is only partially explained, and no guidance is given on failure or unauthorized lookups, leaving the overall picture slightly incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It significantly clarifies presentation_id by listing seven accepted identifier formats, and it mentions tenant, but it leaves decision_id completely unexplained and does not clarify what tenant controls beyond offers.

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

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

The description names a specific resource ('one authorised presentation by id') and enumerates the accepted identifier formats, so the agent knows exactly what the tool fetches. Listing the returned fields (brand, strength, form, route, device, pack, holder, status, offers) differentiates it from siblings such as get_price, get_availability, and get_label_and_indication.

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

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

The description implies the trigger case: use this when you already have a presentation/package identifier from one of the listed jurisdictions and need the full catalogue record. It does not explicitly state when not to use it or name alternatives, so the routing guidance is inferred 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?

Annotations already declare readOnly=true and idempotent=true, so the description only needs to add context. It adds the licensed-only scope and the 'pointers' return concept, but does not disclose behavior for invalid or unlicensed presentation IDs. 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?

A single, front-loaded sentence that states the resource, the licensed-only restriction, and the identifier scope with 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?

For a one-parameter read-only tool with an output schema and safe annotations, the description is largely complete. The only residual gap is the lack of an explicit mention of what to do when the presentation is not licensed, but this is a minor omission given the tool's simplicity.

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

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

The schema provides only a string type for presentation_id with no description, and schema coverage is 0%. The description does add meaning by tying the parameter to a licensed presentation with US NDC, CA DIN, or EU EMA number, but it still leaves the exact accepted format or identifier type implicit.

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 ('label and indication pointers') and a key constraint ('licensed presentation only') with recognizable identifiers, and the title supplies the 'get' verb. It is clear enough to select, though it does not explicitly differentiate itself from siblings like get_safety_label.

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 'only' conveys that this tool is restricted to licensed presentations and thereby implies when to use it, but no alternatives or exclusions are named. Unlike a strong definition it does not tell the agent what to use for unlicensed or non-approved products.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond noting that decision_id is required (already in the schema). It does not mention error cases, permission requirements, or what happens if the pathway does not permit the request.

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

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

The description is a single, short sentence with no wasted words. However, it is under-specified to the point of being cryptic, so the brevity does not serve the agent's comprehension. It is concise but not effectively structured to convey essential context.

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 (which reduces the need to explain returns), the description fails to define critical terms like 'lawful lot' and 'pathway', and does not address how the three required parameters interact. An agent cannot reliably determine correct usage without additional 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?

The schema has 0% description coverage, so the description carries the full burden of explaining parameters. It only mentions decision_id as required, without explaining its purpose, format, or relationship to the pathway. It offers no meaning for lot or presentation_id, leaving the agent without enough information to construct valid calls.

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 resource (certificate of analysis) and scope (a lawful lot of a presentation), which goes beyond a tautology. However, terms like 'lawful lot' and 'presentation' are unexplained and the description does not distinguish this tool from siblings such as get_safety_label or get_label_and_indication, leaving ambiguity about its exact 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?

No guidance is provided on when to use this tool versus alternatives. The phrase 'where the pathway permits' hints at a condition but does not clarify how to determine that condition or when to choose another tool. There are no explicit exclusions or alternative recommendations.

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, idempotentHint=true, and openWorldHint=false, so the safety profile is well-covered. The description adds meaningful behavioral context: it specifies that the status is from a frozen vocabulary, includes an effective date and rule-set version, and references a source page. This goes beyond the annotations and helps the agent understand the nature of the returned data without needing to inspect the output schema. The only minor gap is that it doesn't describe the exact structure of the response, but that is covered by the output 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 one clear, dense sentence that front-loads the core data (status with frozen vocabulary) and then lists the associated metadata (effective date, rule-set version, source page). No filler words; every element contributes meaning. It is appropriately sized for a tool of this simplicity.

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 fairly simple signature (3 params, no nested objects) and an output schema exists, so the description doesn't need to explain return structure. It covers the essential context: what the status represents, that it is jurisdiction- and pathway-specific, and that it includes metadata. Given the annotations already cover safety and idempotency, the description is sufficiently complete for an agent to invoke it correctly. The only missing piece is explicit guidance on choosing this over similar lookups like get_substance_record, but that is a minor gap given the clarity of the resource.

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

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

The schema has 0% description coverage, meaning neither the properties nor the description explain the parameters. The description mentions 'substance', 'pathway', and 'jurisdiction' implicitly but doesn't add format, enumeration, or selection guidance. However, the parameter names themselves are fairly self-explanatory, and the description's reference to 'one pathway in one jurisdiction' clarifies the semantic scope. Since the description adds marginal value beyond the parameter names but doesn't fully explain constraints (e.g., frozen vocabulary for status, not for substances), a baseline 3 is appropriate.

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

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

The description states the specific resource (substance, pathway, jurisdiction) and the kind of data returned (status with frozen vocabulary, effective date, rule-set version, source page). It clearly distinguishes this from sibling tools like compare_presentations or get_item, though it doesn't explicitly name a sibling as an alternative. The verb is implicit ('The status of...') but the resource and output are specific enough for an agent to understand 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 implies when to use this tool (when you need the status of a substance on a specific pathway in a specific jurisdiction with frozen vocabulary). It does not explicitly state when not to use it or mention alternatives like get_substance_record or compare_presentations. The context of sibling tools suggests this is a targeted lookup, but no explicit exclusions are given, leaving the agent to infer the scope.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable context about the dependency on gate_transaction and the licensed-party source, which goes beyond the annotations. No contradictions exist.

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

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

The description is a single sentence that is concise and front-loaded with the core purpose. It avoids verbosity, though the packed conditional clause could be clearer. Overall, it is appropriately sized for the tool's simplicity.

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?

While the output schema and annotations fill some gaps, the description leaves presentation_id and tenant unexplained. For an agent to correctly invoke this tool, it needs to know what presentation_id refers to and how tenant is used. The prerequisite is clear, but parameter semantics are under-specified, making the definition only partially 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%, so the description must compensate. However, it only mentions decision_id implicitly and does not explain presentation_id or tenant. The parameter names are somewhat self-explanatory, but with zero schema descriptions, the tool provides minimal guidance for constructing valid calls.

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 'Price basis (list · contract · reimbursement) from a licensed party' and specifies a prerequisite condition tied to gate_transaction. This distinguishes it from sibling tools like get_availability or get_item, making the purpose 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?

The description explicitly says 'once gate_transaction has answered allow or require_rx (decision_id)', indicating when this tool should be used and that a prior decision is required. It doesn't list exclusions or alternatives, but the conditional context is sufficient for an agent to understand the usage 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds modest value by indicating the result is a pointer rather than the full safety label and by naming the label page and pharmacovigilance scheme as components. 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 compact fragment with no filler or redundant wording. The core object, 'safety label pointers,' is front-loaded, and the parenthetical adds necessary output detail without bloating the text.

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 low parameter count, strong read-only annotations, and presence of an output schema, the description is serviceable but not complete. Its main gaps are the lack of parameter format guidance and the failure to explicitly distinguish it from get_label_and_indication, which an agent would need for confident tool selection.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the parameters. It only mentions 'jurisdiction' in passing and never clarifies accepted formats or values; 'substance' is left entirely to inference from its name. The description does not meaningfully compensate 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 identifies the returned resource as 'safety label pointers' for 'licensed products' and hints at the output composition via the parenthetical. It is clear but lacks an explicit verb and does not directly differentiate itself from the sibling get_label_and_indication.

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 or when-not-to-use guidance is provided. The phrase 'for licensed products' gives a mild scope cue, but it does not explain when this tool should be chosen over siblings like get_label_and_indication or get_item, nor does it mention any exclusions.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, so the description does not need to restate those. It adds useful behavioral context beyond annotations: 'Every field carries its source page' is a provenance guarantee, and 'one pathway row per jurisdiction × pathway' clarifies output cardinality. These are meaningful disclosures an agent would not get from the schema or 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 dense sentence that front-loads the core scope ('One molecule') and then lists the record's contents efficiently. It has no redundant phrases and every clause adds 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?

The annotations and output schema reduce the burden on the description, and the description gives a solid overview of return contents and provenance. However, it lacks input-format guidance for the 'substance' parameter and any usage routing among the many get_* siblings, so the definition is only minimally complete 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?

The schema has a single required parameter 'substance' with 0% description coverage, so the description must compensate. It does not clarify what values 'substance' accepts (e.g., INN, UNII, CAS, or a database identifier) or its format. The description lists identifiers as record fields, not as accepted inputs, leaving the agent to guess how to populate the required 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 defines the tool's resource: a single substance record, enumerating its specific contents (identifiers, aliases, class, pathway rows, enforcement events, safety references). The phrase 'one molecule' and the distinct field set differentiate it from sibling tools like get_item and get_safety_label, even without naming 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?

The description gives no explicit guidance on when to use this tool instead of related siblings. It implies the tool is for fetching a single substance record, but it never states exclusions, alternatives, or conditions. An agent must infer usage from the tool name and content list.

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 annotation readOnlyHint=false already signals mutation, and the description's 'Write' aligns with that. It adds that the tool returns the line id, which is useful, but it does not disclose side effects such as duplicate audit lines on repeated calls or whether the audit line is immutable once written.

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 with no filler, front-loads the action, and includes the most relevant return detail compactly. Every word earns its place.

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

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

For a write tool with no parameter descriptions and an output schema, this description is only minimally adequate. It omits valid kind values, the meaning of reference_id, and the relationship to gate_transaction or create_order_intent, leaving too much for the agent to infer.

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 kind, reference_id, and note. It does not explain any of these parameters; the phrase 'for a gate decision or an order intent' hints at possible kind values but never maps them to the schema. Required fields remain opaque.

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 ('Write') and a specific resource ('audit line'), and it narrows the scope to 'a gate decision or an order intent.' This distinguishes it from siblings like create_order_intent and gate_transaction by resource type, though it does not explicitly name a competing tool.

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

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

The description implies the tool is used when an audit line must be written for a gate decision or order intent, but it does not explicitly state when to use it versus alternatives, nor does it describe prerequisites or exclusions. The usage context is inferable but not spelled out.

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, the description adds significant behavior: agent inherits the class of the presented credential, null returns DENY_UNLICENSED_AGENT, and communication_class is either trade_information or public. This is exactly the kind of non-obvious runtime behavior an agent needs.

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

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

The description front-loads the core action and keeps the taxonomy in a compact list. It is dense but not wasteful, though the semicolon-heavy class listing is somewhat hard to parse at a glance.

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 output schema exists and annotations cover safety, the description sufficiently covers inputs, the special agent/credential case, and the returned communication classes. No critical operational detail is missing for an agent to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does this well by enumerating valid values for actor_class and explaining how credential affects resolution for the agent class. It stops short of explicitly mapping each parameter, but the semantics are recoverable.

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 names the exact operation ('Resolve') and target ('actor class and channel'), then enumerates valid actor classes and the returned communication_class. This clearly differentiates it from sibling tools like resolve_jurisdiction and gate_transaction.

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

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

The description implies the tool is for determining actor class and channel, and the class list gives useful context. However, it does not explicitly state when to use this tool versus alternatives or provide any exclusion criteria.

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, so the tool is known to be a safe read operation. The description goes beyond annotations by explaining the special mapping for UK (ISO code accepted, jurisdiction_label carries UK), how machine fields carry ISO codes, and that the result includes EU member and state/provincial/cantonal overlay. This adds valuable behavioral context without contradicting any 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, information-dense sentence that packs all essential details: purpose, examples, jurisdiction list, UK special case, and output components. No filler or redundancy; every clause earns its place. It is front-loaded with the action and examples, making it easy for an agent to grasp the tool's function quickly.

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

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

Given that an output schema exists, the description does not need to explain return values in detail, but it still hints at the output structure (machine fields, jurisdiction_label, EU member, overlays). It covers the input format and special cases, leaving nothing critical unknown for correct invocation. The only minor omission is error handling for invalid ship_to values, but that is not essential for a read-only, idempotent tool.

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

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

Schema coverage is 0% (no parameter description), so the description carries the full burden for explaining the ship_to parameter. It provides concrete examples (US-CA, CA-ON, MX, EU-DE, UK, etc.), clarifies that ISO 3166-1 codes are accepted, and details the output fields. This fully compensates for the minimal schema and gives the agent a clear understanding of valid input formats.

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 (resolve) and resource (ship-to to jurisdiction), enumerates the exact jurisdiction set (US · CA · MX · EU · UK · KR · JP · SG · CH) and includes concrete input examples. It is unambiguous and clearly distinguishes from sibling tools like resolve_actor, which deals with actor resolution rather than geographic jurisdiction.

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 clearly implies the use case: when you have a ship-to identifier and need to know the gate's jurisdiction, EU membership, and regional overlays. However, it does not explicitly mention when not to use it or name alternatives (e.g., resolve_actor). The context is clear enough that an agent would correctly infer when to call it, but explicit 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?

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds useful behavioral detail beyond annotations: only cleared statuses are returned, and each result includes an availability block with banners, pos_count, and product_urls. There is no contradiction with 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 compact and front-loaded with the core purpose. Every sentence adds meaningful information without padding or redundancy, making it easy for an agent to parse quickly.

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 7-parameter tool, the description covers the main search semantics and return behavior, and an output schema is present. The main gap is the unexplained decision_id parameter and the limit parameter, though both are optional and do not block correct basic usage.

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 effectively explains the query parameter (substance, brand, or holder), the optional banner filter, and the scoping role of jurisdiction, pathway, and actor_class. However, limit and decision_id are not described, so coverage is incomplete.

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 operation: searching for presentations that passed the gate, scoped by jurisdiction, pathway, and actor class. It also specifies the query dimensions (substance, brand, or holder) and distinguishes this from a general availability search by emphasizing cleared statuses only.

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 clear contextual guidance on when this tool is appropriate: when you need cleared presentations for a jurisdiction and want availability data. It does not explicitly name sibling alternatives or exclusions, but the scope is concrete enough that an agent can infer when to select it.

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 capture safety (readOnlyHint, idempotentHint, no destructive). The description adds the behavioral nuance of jurisdiction-specific enforcement and the fallback for non-national areas. It does not, however, disclose specifics like whether unknown formats fail hard or whether strict validation applies, nor what happens when the jurisdiction value is unsupported. 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 packs in the essential scope: what is verified, the components, and the jurisdictional context. No fluff and the critical decision factor (jurisdiction regimes) is front-loaded. It could benefit from a brief usage hint, but it is appropriately concise for the tool'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?

Given the tool has 5 parameters (3 required), no enums, an output schema (not included), and low schema coverage, the description does not fully compensate. It omits expected return values (though output schema may cover that), any error conditions (e.g., invalid jurisdiction, missing required fields), or date format for expiry. An agent might misuse jurisdiction values or misunderstand the fallback. Adequate but missing several pieces that would make it 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%, so the description must compensate. It names the parameters in the pack (GTIN, serial, lot, expiry) but provides no details on formats, constraints, or meaning beyond what the schema names. The description clarifies the role of jurisdiction (determines regime), which adds context, but lot/expiry remain loosely defined (optional, no format guidance). Baseline is low due to coverage, and description only partially fills the 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 identifies the verb ('Verify') and the resource ('a serialised pack') with its key components (GTIN + serial + lot + expiry). It specifies the regulatory jurisdictions (DSCSA, FMD, UK, KR) and falls back to 'none-national elsewhere', which fully distinguishes it from sibling tools that target other supply-chain actions.

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 a serialised pack needs to be verified against jurisdiction-specific rules, and hints at varying applicability by jurisdiction. However, it does not explicitly state when to use this tool vs alternatives (e.g., gate_transaction, resolve_jurisdiction, get_item). Lacks guidance on prerequisites, such as having a valid jurisdiction or when a simpler lookup would suffice.

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