A2A Cosmetics

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

The description goes beyond annotations by clarifying this is 'a referral, never a sale to a consumer' and by explaining where the intent goes under each decision. It does not cover authentication, audit trails, or envelope details, but the annotations already signal a state-changing operation.

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

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

The description is a single dense, front-loaded sentence carrying all routing information. It earns its content, but the parentheticals and dash make it harder to parse than necessary; splitting it into conditions would improve 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?

The output schema exists, so return values need no description, and the allow/deny behavior is explained. But A2A jargon such as 'envelope + card URL', 'market agent of the ship-to', and 'regulator's home page' is left undefined, and optional-parameter behavior is not addressed.

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 connects 'decision' to decision_id, 'counterparty card URL' to counterparty_card_url, and 'order intent' to intent_id. However, it never specifies how allow vs deny is represented in decision_id, nor whether parameters may be null or which combinations are valid.

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 concrete action ('Hand the buyer') and resource ('the right agent'), and immediately narrows the mechanism to Agent-to-Agent. The allow/deny branch logic makes the tool's function distinct from transaction or gating siblings like 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?

It explicitly states when to route to the counterparty's agent (allow decision) versus the market agent of the ship-to (deny decision). It provides clear context but does not name sibling alternatives or state explicit when-not-to-use conditions, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior; the description adds the cardinality range (two to eight) and accepted identifier types. It does not mention failure behavior, invalid identifiers, or how results are presented, but the output schema mitigates return-value concerns.

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 sentence with an active verb and essential scope constraints in parentheses. No filler, no repetition of annotation or schema data.

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?

Annotations and output schema cover safety and result shape, and the core invocation (gtins) is clear. However, the two optional parameters are undocumented in both the schema and the description, leaving ambiguity about locale and decision context.

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

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

Schema description coverage is 0%, so the description must compensate; it explains gtins as GTINs or catalogue ids with a 2–8 count, but says nothing about market or decision_id. An agent cannot tell what these optional parameters mean or when to populate them.

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 (compare), a clear resource (products, variants, shades), and a distinctive scope (side-by-side, two to eight GTINs or catalogue ids). This differentiates it from sibling single-item lookups like get_item or verify_gtin.

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 explicit when-to-use or when-not-to-use guidance is provided, and no alternative tools are named. The reader must infer from the sibling list that this is for multi-item comparison rather than single-item retrieval.

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

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

The description adds behavioral context beyond the annotations by noting that the intent carries reason_code and rule_set_version and settles via x402 on a2a-x402.ai. It does not disclose side effects, persistence, or error conditions, but the annotations already indicate a non-read-only, non-idempotent operation.

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

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

The description is a single sentence and reasonably brief, but it is dense with domain jargon such as 'gate', 'x402', and 'reason_code + rule_set_version'. It front-loads the core purpose but sacrifices clarity for compactness.

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

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

With an output schema present, return-value documentation is not required, but the description leaves required parameter semantics unexplained and does not articulate a clear invocation trigger beyond vague 'after the gate' context. An agent would struggle to construct a valid call without additional 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, but it does not explain any of the five parameters, including required fields gtin, quantity, and decision_id. It even introduces fields like reason_code and rule_set_version that are absent from the schema, which could mislead an agent about what inputs are expected.

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 action as opening an order between two agents and specifies the resource as an order intent for a cleared product after the gate. It distinguishes this from read-only siblings like get_item or get_availability, though it does not explicitly differentiate from 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 phrase 'for a cleared product after the gate' provides implied usage context, suggesting this should be invoked after clearance and in relation to a gate decision. However, it does not explicitly state when not to use the tool or mention any alternative sibling tools.

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

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

The annotations already establish safety characteristics (read-only, idempotent, non-destructive), and the description adds behavioral value by specifying the result ordering: verified first, then claimed, then listed. It also discloses the dependency on decision_id and the claim-status dimension of the records. It does not over-explain, but it goes beyond the annotations usefully.

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

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

The description is two short sentences with no filler. The core purpose and key output ordering are front-loaded, and the required input dependency is stated in the second sentence. 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?

The core inputs, output type, and ordering behavior are all represented, and the presence of an output schema reduces the need to describe return shapes. The description could be more explicit about how gtin versus query are used, but overall it is sufficient for an agent to understand what the tool does and what it needs. Given the moderate parameter count and supportive annotations, this is a solidly complete description.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It explains decision_id ('of an allow decision'), market ('in a market'), and product scope ('this product or product type'), which loosely maps to gtin and query. However, it does not clarify the distinction between gtin and query or mention limit, leaving some parameter semantics to inference from names.

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—supplier records for brands and manufacturers—and clarifies the scope as a product or product type in a market. It also adds distinguishing output details (claim status and ordering) that set it apart from sibling tools like verify_gtin or get_item. Though it lacks a direct verb, the intent is immediately clear from the phrase 'Verified makers and brands for...'.

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 context: use it to fetch verified supplier records for a product or market, and it requires the decision_id from an allow decision. It includes a meaningful prerequisite but does not explicitly name alternatives or say when not to use this tool. This is clear context without formal exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description does not contradict them — 'allow or deny' is a returned verdict, not a state change. The description adds useful context beyond the annotations: the complete twelve-code decision space, the conditional input requirement ('when no record exists yet'), and the fact that the returned decision_id feeds downstream tools.

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

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

The description is front-loaded with a strong hook ('Allow or deny, with the reason and the rule') and is dense rather than padded. The twelve-code enumeration is long but justified since no parameter schema defines enums; a light restructure into per-parameter bullets would improve scanability, but no sentence is wasted.

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

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

For an 8-parameter tool with zero schema coverage, the description covers the core decision contract thoroughly — inputs, conditional requirements, and the full return envelope — and an output schema exists so return values need not be re-explained. Gaps remain: channel and credential semantics are undefined, 'when no record exists yet' provides no trigger or check procedure, and no preconditions or prerequisites for the compliance check are stated.

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 carries the parameter-documentation burden and largely delivers: it explains product as 'GTIN or catalogue id; optional', clarifies that ingredients are INCI names, and discloses that product_type, ingredients, and claims are only needed when no record exists yet. However, channel and credential receive no semantic hint, and actor_class is merely restated rather than defined.

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

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

The opening 'Allow or deny, with the reason and the rule' names a specific verb and object — a compliance-gate decision with its rationale — and the twelve enumerated reason codes make the decision space unmistakable. This is the only sibling tool that returns an allow/deny verdict, so an agent can distinguish gate_transaction from the get_*/verify_*/resolve_* retrieval tools without opening the schema.

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

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

The description implies the use case — call this when a transaction needs an allow/deny compliance decision for a product, market, and actor — but it never states when-not-to-use or names an alternative. The only conditional ('when no record exists yet') governs parameter requirements, not tool selection, so the agent gets no explicit routing guidance against siblings.

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

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

Beyond the readOnly/idempotent annotations, the description reveals that product URLs are read live at load and that store counts appear only when the retailer record carries one. It also discloses the gate_transaction dependency, giving the agent a realistic model of behavior.

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

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

A single dense sentence with no filler and a clear front-loaded summary ('In stock, and where'). The parenthetical is jargon-heavy but compact; it earns its place by describing the payload variants.

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 covers return details, and annotations cover side effects, so the description does not need to repeat those. However, the lack of explicit parameter documentation, especially market, leaves an agent to guess part of the invocation contract.

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 clarify parameters. It only clarifies decision_id (as the gate_transaction decision id). gtin is implied as the product identifier but never stated, and market is entirely unexplained.

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 exactly what the tool returns—the availability block of a product, including in-stock status and location (banners, live product URLs, store counts). It ties the call to a specific prerequisite (gate_transaction answered allow), which distinguishes it from sibling retrieval tools like get_item 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?

It clearly states when this tool is appropriate: after gate_transaction returns allow, and it names the required decision_id. It does not explicitly list alternatives or when-not conditions, but the gating condition gives concrete context for selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that results are dated and include source pages, which is useful context, but it does not describe pagination, result limits, or how filter defaults behave. It does not contradict 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, compact sentence that front-loads the key content and packs all relevant filtering and output details without redundancy. Every phrase 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 are covered, and annotations cover safety. However, parameter semantics remain partially ambiguous (e.g., exact query interpretation, date format, behavior when fields are null), and with zero schema parameter documentation, a bit more detail would make the tool safer to invoke.

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 partially compensates by mentioning 'market' (matching the market parameter), 'since a date' (matching since), and 'ingredient, brand' (implying the query parameter). This provides some meaning beyond the bare schema, though it does not specify date formats or query syntax.

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

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

The description clearly identifies the resource (enforcement events: recalls, bans, safety alerts) and the filtering dimensions (market, ingredient, brand, since date), and explicitly mentions the output includes source pages. This distinguishes it from sibling tools like get_safety_label or get_market_status, which cover safety labels and market status respectively.

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 enforcement events are needed, listing the available filters, but it does not explicitly state when to use this tool over alternatives or provide any exclusions. There is no direct comparison to siblings, so the agent must infer applicability from the resource type.

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, open-world, and non-destructive behavior. The description adds the claim that it returns status in 'every market' and includes official list sources, which provides useful scope and provenance context. However, it does not disclose error behavior, data freshness, or what happens when an ingredient 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?

The description is a single, information-dense sentence with no redundant filler. The opening phrase 'One ingredient, and its status in every market' is slightly indirect but still communicates the core purpose up front. Overall it is concise and 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?

For a one-parameter read-only tool with an output schema, the description provides adequate context about the returned data, including the scope and content of the record. It does not cover edge cases or input formats, but the simple interface and output schema mitigate the need for more detail.

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 define the single 'ingredient' parameter. It clarifies cardinality by saying 'One ingredient' but does not specify whether input should be an INCI name, common name, alias, or any exact format. This leaves ambiguity about acceptable inputs.

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

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

The description clearly identifies the resource as an ingredient record and states the output: status per market, INCI name, aliases, and per-rule-set restriction/listing details. It is specific enough to infer its purpose, but it does not explicitly differentiate from similar siblings like get_market_status or get_availability.

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 focuses entirely on what the tool returns, with no guidance on when to use this tool versus alternatives. It does not state when to select this tool, such as needing regulatory compliance data, nor does it mention any exclusion criteria or preferred sibling.

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 establish read-only, idempotent, non-destructive behavior. The description adds genuinely useful behavioral context beyond annotations: data availability is gated ('after the gate also...'), which tells the agent that the response is richer once a gate decision exists. 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 dense sentence front-loads the core operation ('one product by GTIN') followed by a concise colon-separated field list. Every phrase earns its place; 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?

The description is adequate for a simple GTIN lookup and the output schema presumably documents return values, but the unexplained 'gate' concept and silent optional parameters (market, decision_id) leave an agent uncertain about precondition requirements and richer invocations.

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 explain parameters. It covers gtin ('by GTIN') and alludes to market as a resolved field, but it never explains the market input parameter or the decision_id parameter, which are significant gaps for an agent trying to call the tool correctly.

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?

Description states a specific operation: retrieve one product by GTIN with fully resolved data, and enumerates the data categories (taxonomy, variant/form, brand, market, claim status, availability, etc.). This clearly differentiates it from sibling tools like search_cleared_items, compare_items, and get_availability.

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 'One product by GTIN, fully resolved' gives clear context for when to invoke it — a single-product canonical lookup by GTIN — with no exclusions. It does not name sibling alternatives or when-not-to-use conditions, so it stops short of a 5.

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

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

Annotations already cover the read-only, idempotent, non-destructive nature. The description adds useful behavioral context beyond that: optional claims are checked against the rules, and returned items include source pages. This gives the agent a better sense of what will happen when invoking the tool.

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

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

The description is only two sentences and front-loads the tool's purpose. The first sentence is slightly convoluted, but every clause adds meaningful information and there is no filler.

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

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

Given the rich annotations and presence of an output schema, the description is mostly complete: it explains what is returned, what the inputs represent, and how optional claims behave. Minor gaps remain around accepted market value formats and explicit routing away from sibling tools, but these are not critical.

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 parameters. It maps 'market' to the market whose label requirements are returned, and 'claims' to optional claims that are checked against the rules. It does not detail accepted formats, but the schema supplies type and array structure.

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

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

The description states a clear resource: the label requirements and claims rules for a market, each with its source page. This is more specific than a vague 'get label and claims' and includes enough detail about the cosmetic classification context to partially distinguish it from related 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 the tool should be used: to retrieve market-specific label requirements and claims rules, and optionally check claims against those rules. However, it does not explicitly mention alternatives or say when not to use this tool, such as when a safety label or notification requirement is needed.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds the classification categories and output context, but with an output schema present this is limited extra transparency, and it does not disclose auth, rate limits, or other side-effect behavior.

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

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

The description is a single compact sentence that front-loads the core question and packs the classification options and key output details into minimal words. There is no fluff 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?

For a simple two-string-parameter lookup with a read-only/idempotent annotation set and an output schema, the description is mostly sufficient to understand the domain and result semantics. The lack of usage guidance and explicit sibling differentiation weakens completeness, but the low complexity keeps it adequate.

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 define product_type and market itself; it does name both and gives domain categories. However, it does not specify accepted input formats or exact enumeration values for the two string parameters, leaving some guesswork for the agent.

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 frames the tool as a market-specific regulatory classification lookup, listing possible outcomes (cosmetic, drug, special class, not permitted) and mentioning the rule-set version and regulator's page. This distinguishes it from price/availability/ingredient siblings, though it lacks a direct imperative verb such as 'returns' or 'determines,' so it stops short of a 5.

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

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

No guidance is given on when to use this tool rather than a sibling, nor are any exclusions or alternatives named. The market/regulatory context is implicit but the description never explicitly routes an agent among the many related regulatory tools.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description's job is lighter. It adds useful behavioral detail: the returned data includes the notification scheme, responsible-person requirement, conditional extra step, and source page. 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 one compact sentence that front-loads the core purpose and then lists the exact returned components. Every clause adds informational value with no redundancy.

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

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

Given the output schema exists and the annotations cover safety, the description is largely complete. It explains the market scope, the conditional product-type behavior, and the source-page attribution. It could be slightly fuller about the behavior when product_type is omitted, but that is a minor 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 description must compensate for the two parameters. It does communicate that 'market' is the jurisdiction and that 'product_type' is relevant for determining the extra step for special classes. However, it does not specify acceptable values, formats, or the exact meaning of omitting product_type.

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 what the tool returns: pre-sale notification requirements for a market, with three specific components and source pages. This is distinct from sibling tools like get_market_status or get_label_and_claims, which address different regulatory or product aspects.

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 'before sale in a market' provides a clear usage context: use this tool when you need to know what must be filed prior to selling in a given market. It does not name explicit alternatives or exclusions, but the context is strong enough to route an agent correctly.

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

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

The annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context about the dependency on gate_transaction and the source of the price, but it does not explain behavior when the decision is not 'allow', when no offers exist, or how market affects the result.

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

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

The description is short and mostly front-loaded, but the final sentence 'Tiers buy services, never rank' is opaque and unexplained, making it a confusing inclusion. The structure is not as clean as it could 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 description provides the core precondition and price source, and an output schema exists, but it omits clarification for gtin and market and does not state what happens in edge cases. It is adequate for a straightforward read, but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate; it meaningfully explains decision_id as the gate_transaction decision, but it does not explain gtin or market. The parameter names may be conventional, but the description leaves important invocation semantics 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 clearly identifies the tool as returning a price for a buyer, with the price basis coming from supplier offers and conditioned on a gate_transaction decision. It is specific enough to be distinguished from generic price tools, though the phrase 'Tiers buy services, never rank' is cryptic and adds little clarity.

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 states the key precondition: use this tool once gate_transaction has answered allow with a decision_id. It does not name alternatives or state when not to use it, but it does convey a clear sequencing requirement.

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 the operation read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds value by explaining that the returned documents are URLs with read dates and by enumerating the document categories, which is useful 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 short and front-loaded with the main document types, but it is awkwardly worded and partially redundant: the initial list overlaps with the parenthetical list. It could be tightened and made clearer without adding length.

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

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

The output schema exists and annotations cover read-only behavior, but key invocation context is still missing, especially the meaning of decision_id and how gtin and market scope the document set. For a low-parameter tool, this is close to viable but not complete enough for reliable 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 needed to explain gtin, market, and decision_id, but it only restates that decision_id is required. It does not define what decision_id represents or clarify how gtin and market affect which documents are returned.

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 as documents on a product record and enumerates concrete document types such as safety assessment, certificate of analysis, and safety data sheet, along with URL and read date. It clearly distinguishes this as a document retrieval tool, though it does not explicitly name sibling alternatives or use an explicit verb like 'retrieves'.

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 on when to use this tool versus siblings like get_safety_label or get_item, and it does not mention any exclusions or alternative tools. The only usage-related signal is that decision_id is required, which is a call prerequisite rather than contextual 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that results include source pages and the regulator's safety-alert scheme, which is useful context. It does not disclose pagination, filtering behavior, or what happens when product_type is null, but the annotations lower the burden.

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 content (warnings and age limits) and then adds the regulatory scheme and source pages. It is concise and readable, though the phrasing 'the warning statements the market requires' is slightly awkward 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 an output schema, so return values are documented elsewhere. The description covers the main content and source attribution, but it does not explain how product_type filters results or whether market alone returns all product types. Given the sibling get_label_and_claims, more explicit differentiation would improve completeness.

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 that product_type refers to product categories like sunscreen, hair dye, aerosols, and children's products, and that market is the jurisdiction. However, it does not clarify the format of market (e.g., country code vs name) or the exact effect of omitting product_type, leaving some ambiguity.

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 (safety label) and what it returns: warning statements and age limits for a product type, plus the regulator's safety-alert scheme with source pages. It is clear enough to distinguish from generic get_item or get_label_and_claims, though it does not explicitly name a sibling alternative.

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

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

The description implies the tool is for retrieving market-required warnings and age limits, and the input schema shows market is required and product_type is optional. However, it does not explicitly state when to use this over get_label_and_claims or get_notification_requirements, nor does it mention any exclusions or prerequisites.

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

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

Annotations already indicate a non-readonly, non-idempotent write, and the description's 'Write a line' is consistent with that. It adds the useful detail that the line id is returned, but it does not disclose side effects, append-only behavior, or whether duplicates are created on repeated calls. 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 front-loads the core behavior, includes the relevant record types, and mentions the return value. Every element earns its place with no filler or repetition of the tool name.

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

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

For a simple three-parameter tool with an output schema, the description conveys the core purpose and return value. However, it leaves the required fields under-specified and provides no guidance about valid values for 'kind' or what 'reference_id' should reference, so the agent is not fully equipped to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it only partially does. It implies that 'kind' relates to gate decisions, order intents, or handoffs, yet it never maps those to the parameter, and it gives no meaning or format for 'reference_id' or the optional 'note'.

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 resource ('audit record'), and clarifies the scope by naming the three record types: gate decision, order intent, and handoff. It is clear enough, but it does not explicitly differentiate itself from the sibling action tools such as create_order_intent or 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 when to use the tool by listing the three event types it logs, but it never states explicit conditions, exclusions, or alternatives. An agent must infer that this is for audit logging rather than for performing the underlying gate/order/handoff actions.

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

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

Annotations already indicate the tool is read-only and idempotent. The description adds valuable behavioral details beyond annotations, including the special DENY_UNLICENSED_AGENT outcome, agent credential inheritance, and the communication_class return value. These details are not redundant with the structured data.

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 three concise sentences with no wasted words. The core question is front-loaded, followed by actor semantics and the return type. Every clause contributes meaningful information.

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

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

Given the annotations, an output schema, and the description's coverage of actor classes, special cases, and return values, the definition is largely complete for an agent to invoke the tool correctly. The only notable gap is the lack of explicit sibling tool differentiation for selection context, which is more of a usage-guideline concern.

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 of explaining parameters. It gives concrete meaning to actor_class by listing brand, manufacturer, retailer, distributor, auditor, and agent, and explains how credential influences agent resolution. The credential parameter itself is explained indirectly through agent inheritance, though its exact format is not elaborated.

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: identifying the actor making the request ('Who is asking?') and enumerating the supported actor classes. It includes the return type, communication_class, which adds clarity. However, it does not explicitly distinguish this tool from sibling tools like resolve_jurisdiction or 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 provides useful context about valid actors and special cases, such as agents inheriting credential class and 'none returns DENY_UNLICENSED_AGENT.' It also states that the consumer is never the counterparty, which is a meaningful constraint. However, it gives no explicit guidance on when to use this tool versus alternatives or when not to call 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 declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context: the 18-markets-to-13-rule-sets mapping (six EU markets share one rule set) and the UK-label/GB-machine-code quirk. This goes beyond annotations and helps the agent interpret output nuances without contradicting them.

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 three sentences with the core action front-loaded after a brief rhetorical question. The UK/ISO note is a useful, non-redundant addition. The opening question is somewhat cosmetic but does not detract from clarity.

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 single-parameter, read-only resolver with an output schema provided, the description covers the mapping semantics and an important edge case (UK vs GB). It does not explicitly state when to invoke it or how invalid inputs are handled, but given the low complexity and existing annotations, these are not critical gaps.

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

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

Schema description coverage is 0%, so the description carries the burden for explaining the single ship_to parameter. It provides six concrete example formats ('US', 'US-CA', 'UK', 'FR', 'EU-DE', 'JP'), which give a solid sense of accepted values, but it does not fully specify the allowed format, enumerate all markets, or describe invalid-input behavior. This is adequate but not exhaustive.

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 resolves a ship-to value into one of 18 markets and its associated rule set, with concrete examples. This is a specific verb-plus-resource statement that inherently distinguishes it from sibling resolve_actor, though it does not explicitly name any alternative.

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

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

The description implies when to use the tool—whenever a ship-to needs mapping to a market/rule set—but provides no explicit when-not-to-use instructions or comparisons to sibling tools such as get_market_status or resolve_actor. The context is clear, but exclusions and alternatives 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 declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds meaningful behavioral context: 'Only validated rows are served' and each item includes claim/market status, which are not derivable from the annotations and inform the agent's expectations.

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

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

The description is two sentences with no waste. The core action and scope are front-loaded, and the second sentence adds essential data behavior without redundancy.

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

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

With an output schema present, return values are covered. However, the description omits several parameter semantics (decision_id, limit, product_type clarification), leaving an incomplete picture for an agent trying to invoke the tool correctly across all parameters.

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 query (by product name, brand, product type, or lane) and lane (optional with allowed values), but leaves decision_id and limit unexplored, and product_type's relationship to query is ambiguous. This is only partial compensation.

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 ('Find') and resource ('products cleared for this market'), and further clarifies it as 'validated product records in a market' with defined query dimensions. This clearly distinguishes it from siblings like get_item (single-item retrieval) and compare_items (comparison).

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 implicitly conveys when to use it (to find validated/cleared products in a market) and how to query, but it does not explicitly state when not to use it or name alternative tools. No exclusion or routing guidance 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the bar is lower. The description adds meaningful behavior beyond that: it states the validation logic (check-digit, GS1 prefix) and what the response surfaces (validated records, brand, claim status).

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 with the core question, and contains no filler. Every phrase contributes information about what the tool checks or 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?

With an output schema present and annotations covering safety and idempotency, the description gives enough context for a single-parameter lookup: what to pass, what validation is performed, and what data comes back. No critical gaps remain.

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% and there is only one required parameter, so the description must carry the meaning. It does: the parameter is a GTIN, and the description explains that it will be validated by check digit and GS1 prefix. It stops short of specifying exact GTIN format or leading-zero handling, but for a single obvious identifier this is adequate.

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

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

The opening question frames the tool's purpose clearly: verifying whether a GTIN is real and whom it belongs to. The description names the concrete checks (check-digit validation, GS1 prefix) and the returned context (records, brand, claim status), which distinguishes it from the lookup/get siblings.

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

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

The description implies the use case—when you need to validate a GTIN and find associated records—but it never explicitly says 'use this when...' or contrasts it with siblings like get_item, get_label_and_claims, or find_verified_supplier. There is no exclusion guidance, so it remains at the mid range.

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