Loyal Spark

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

No annotations are provided, so the description carries the burden. It discloses that the tool returns calldata rather than performing the activation itself, and that it is a no-op for B20. This is important behavioral context. It doesn't cover side effects or output format, but the main behavior is transparent.

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

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

The description is one concise sentence that conveys both conditional behaviors without redundancy. Every word contributes value.

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

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

The tool is simple (one parameter, no output schema) and the description covers both program-type branches. It could be more complete by explaining the format of the returned calldata or defining B20, but the essential behavior is sufficiently described for a low-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?

The single parameter token_address has 100% schema coverage, so the schema fully documents it. The description adds meaning by implying the token address identifies whether the program is legacy ERC-20 or B20, but does not add new syntax or format details beyond the schema.

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

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

The description clearly states what the tool does: it returns unpauseUtility + enableMinting calldata for legacy ERC-20 programs and is a no-op for B20 programs. This distinguishes the behavior across program types and is more specific than simply restating the tool name.

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 explicit usage conditions: use for legacy ERC-20 programs, and explicitly states that for B20 programs it is a no-op (already active), which serves as a clear when-not-to-use. This effectively guides the agent on when to select this tool.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It explicitly states 'Read-only,' which is a key behavioral trait. However, it does not mention pagination behavior (e.g., how limit/cursor work), result format, or edge cases like empty results, which would be useful for a discovery tool. The presence of 'Read-only' is positive, but other behavioral aspects remain undisclosed.

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

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

The description is extremely concise: two short sentences plus 'Read-only.' It is front-loaded with the core purpose, then adds the key safety trait and filter options. Every sentence earns its place with no fluff or redundancy.

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

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

For a simple read-only discovery tool with 4 parameters, all described in the schema, the description covers the essential purpose, read-only nature, and filter mechanics. The lack of an output schema and annotations means the description could explain return format or pagination, but the presence of limit/cursor in the schema partially compensates. It is nearly complete but not fully comprehensive, missing explicit statement of what the tool returns.

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?

Input schema coverage is 100%, so baseline is 3. The description adds minimal semantic value beyond the schema by restating 'free-text q and/or network' as filters, but this paraphrases existing parameter descriptions. No additional meaning is provided for limit or cursor, so the description does not compensate beyond what the schema already 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 clearly states the tool's purpose: 'Discover third-party MCP servers published in Coinbase CDP's Bazaar.' It uses a specific verb ('discover') and resource ('MCP servers'), and the scope ('published in Coinbase CDP's Bazaar') distinguishes it from sibling tools like bazaar_discover_resources, which targets resources rather than servers.

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 by stating it is read-only and filtering options ('Filter by free-text q and/or network'), but it does not explicitly provide when-to-use vs alternatives or any exclusions. Sibling tools are not referenced, so the agent must infer from the name when this tool is appropriate rather than the description.

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

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

With no annotations provided, the description carries the full burden. It discloses read-only behavior and mentions filtering, which is helpful, but it does not detail pagination behavior, response structure, or any permissions or rate limits.

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

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

The description is two sentences, front-loaded with the primary purpose, and every sentence adds value. There is no redundant or unnecessary content.

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

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

The tool is simple with only four optional parameters, and the description covers purpose and filtering. However, without an output schema, the description does not explain what the response contains, and it does not explicitly distinguish from the sibling discovery tool for MCP servers.

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

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

Schema coverage is 100%, with each parameter described in the input schema. The description's mention of 'free-text q and/or network' adds no new meaning beyond the schema, so the baseline of 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 clearly states the tool discovers third-party x402-paid resources in Coinbase CDP's Bazaar, with examples like docs, data feeds, and AI inference. It is specific about the resource type but does not explicitly differentiate from the sibling bazaar_discover_mcp_servers, which is a related but distinct purpose.

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

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

The description provides clear context: it is a read-only discovery tool with filtering by free-text query and network. No explicit alternatives or exclusions are mentioned, but the usage scenario is sufficiently clear.

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

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

With no annotations provided, the description fully carries the transparency burden. It discloses the entire payment flow, the fact that it signs a TransferWithAuthorization, retries with an X-PAYMENT header, and imposes a safety cap with default and hard limits. It also reveals required scope and wallet prerequisites, giving the agent a clear picture of side effects and authorization 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 is a compact three-sentence paragraph that front-loads the primary action, then details the process, prerequisites, and safety. Every sentence adds substantive value with 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?

The description covers the essential workflow, prerequisites, and output ('returns the paid response'), which is important given no output schema. It lacks explicit failure-mode details (e.g., what happens if no compatible requirement is found or if the payment fails), but given the tool's complexity and abundant parameter documentation, it is mostly complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some context around max_usdc (safety cap) and the overall flow, but individual parameter meanings are already fully described in the schema. The description does not significantly clarify the parameters beyond what the schema provides.

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

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

The description clearly states the tool's purpose: 'Pay and call any x402-paid HTTPS endpoint' with a specific verb and resource. It enumerates the multi-step process (probe, pick requirement, sign TransferWithAuthorization, retry with X-PAYMENT header) and distinguishes itself from the sibling probe tool by emphasizing full payment and response retrieval.

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 provides clear context for when to use the tool: 'any x402-paid HTTPS endpoint' and specifies prerequisites (scope 'mint', pre-created CDP wallet) plus a safety cap. However, it does not explicitly mention when not to use it or name alternative tools like bazaar_probe_x402 for mere probing.

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

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

With no annotations provided, the description bears the full burden of disclosing behavior. It clearly states the HTTP method, the conditional behavior on HTTP 402, the return type (parsed accepts[]), the HTTPS-only restriction, and that no signing is performed. However, it does not describe what happens if the response is not HTTP 402, leaving a minor gap.

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

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

The description is two sentences, front-loaded with the core action, and every word adds value. It efficiently conveys the purpose, conditional behavior, return value, and constraints without unnecessary elaboration.

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

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

For a tool with one parameter, no output schema, and no annotations, the description covers the essential aspects: what it does, when it returns data, security constraints, and its non-signing nature. The only missing piece is the explicit behavior for non-402 responses, which is a minor gap for full 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?

The schema already provides full coverage for the single parameter (url) with a clear description. The tool description reinforces the HTTPS requirement but adds no new semantic details beyond what the schema already contains, so the baseline score of 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 clearly states the tool's function: perform a GET request on a candidate x402 URL and, if HTTP 402 is returned, parse and return the payment requirements (accepts[]). It distinguishes itself from sibling tools like bazaar_pay_and_call by emphasizing that this tool only probes and does not pay.

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 should be used to assess a URL's payment requirements before deciding whether to pay, positioning it as a precursor to payment. It also sets constraints (HTTPS only, no signing) that guide appropriate usage, but it does not explicitly mention alternatives or 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states that the tool cancels offers and is admin-only, but it does not mention permanence, side effects, reversal, or any consequences of the action. For a destructive admin operation, this is a significant gap.

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

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

The description is two sentences, front-loaded with the action, and every word contributes. It efficiently conveys the action, criteria, and access level without any fluff.

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

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

For a simple tool with one optional parameter, the description is fairly complete. It explains what it does and the filtering logic, and the schema covers the parameter. However, it does not indicate what the tool returns or any post-condition, which would be helpful but is not critical for this simple action.

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 covers the single parameter (max_age_days) with a description including a default value, so the baseline is 3. The tool description adds 'no completions' as an additional selection criterion, which is useful context beyond the schema, but it does not elaborate further on the parameter itself.

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 ('cancel') and resource ('marketplace offers'), and clearly specifies the criteria ('active for more than N days with no completions'). It distinguishes itself from sibling tools like list_marketplace_offers and create_personalized_offer by indicating a cleanup action on stale items.

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 states this is an admin-only action tool, which provides context on authorization. However, it does not explicitly mention when not to use it or point to alternatives, 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?

No annotations exist, so the description carries the burden. It discloses that the endpoint is public and requires no authentication, which is valuable. However, it does not explicitly state that it is read-only, nor does it mention error handling, rate limits, or response format. The 'check' wording implies safety but doesn't confirm it.

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 concise sentences, front-loaded with the core purpose. The second sentence adds a useful fact (public endpoint) without fluff. 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 simple two-parameter read-only tool with no output schema, the description covers the essential aspects: what it does, how to invoke it, and authentication requirements. It lacks details on output format, but this is likely acceptable for a status check tool. The absence of explicit read-only disclosure 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 coverage is 100% with clear descriptions for both 'code' and 'voucher_id'. The description's mention of 'by code or ID' aligns with the schema but adds no new semantic depth. Baseline of 3 is appropriate for high schema coverage.

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

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

The description clearly states the tool's function: 'Check voucher status by code or ID.' It uses a specific verb ('check') and resource ('voucher status'), and the two lookup methods distinguish it from sibling tools like use_voucher or create_gift_certificate.

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 use for read-only status checks but does not explicitly compare with alternatives or state when not to use it. The public endpoint note provides context but no exclusionary guidance. Usage is inferred from the clear purpose.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool verifies the fee mint on-chain, clears the obligation, and notes that unconfirmed obligations block future mints. This provides meaningful behavioral context beyond the basic action, though it does not cover edge cases like failure modes or idempotency.

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

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

Three concise sentences, each adding value: action, verification effect, and consequence. Front-loaded with the verb 'Confirm.' No redundant or filler text; appropriately sized 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?

The description covers the action, its effect, and its importance. With no output schema, it doesn't explain return values, but that is not mandatory. It could mention required permissions or failure behavior, but overall it gives sufficient context for an agent to understand when and why to invoke 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 coverage is 100%, so the baseline is 3. The description does not add parameter-level detail beyond what the schema already provides; it reinforces the meaning of obligation_id as returned by mint_loyalty_tokens or earn_points, but that is already in the schema. No additional semantic enrichment is present.

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 specifies the action: confirming that a protocol fee transaction was broadcast on Base. It distinguishes itself from mint/earn tools by focusing on the verification and obligation-clearing side, and adds context that unconfirmed obligations block future mints, making the purpose unambiguous.

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

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

The description implies when to use this tool: after a previous mint/earn, to verify the fee mint and clear the obligation. It also explains the consequence of not using it (future mints blocked), which guides usage. However, it does not explicitly name alternative tools or state when not to use it, 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains the unique code generation, customer redemption via QR/code, and on-chain minting by the merchant – meaningful lifecycle context beyond the simple 'create' action. It does not cover failure modes or permissions, but adds solid insight into how the certificate is used.

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

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

Two sentences, front-loaded with the core action and followed by relevant use cases. Every word earns its place, with no filler or redundant schema 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 description explains the business flow and use cases but omits the return value structure (e.g., certificate ID, redemption code), which is important since no output schema is provided. It also does not mention batching behavior or limits, though the schema covers these. Overall it is adequate but leaves the agent uncertain about the tool's response.

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 already provides 100% parameter descriptions, so the baseline is 3. The description adds context about the redemption code and on-chain minting but does not elaborate on parameter interactions or defaults beyond what the schema states. It meets the baseline without adding significant extra value.

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 ('gift / welcome certificate') and differentiates it from siblings by detailing the UDS-style unique 6-character redemption code and the redemption/minting flow. This clearly distinguishes it from tools like create_reward or list_gift_certificates.

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 provides clear use cases ('welcome bonuses, promo campaigns, partnership gifts') which signal when to use the tool. It does not explicitly mention alternative tools or exclusions, but the context is sufficiently clear 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?

No annotations are provided, so the description carries full burden. It reveals that the tool returns calldata rather than executing a deployment, defaults to B20 with immediate activation, and atomically grants MINT_ROLE to the merchant admin and the agent's wallet (or explicit extra_minters). These are critical behavioral traits that an agent needs to know before invoking the tool, and they go well beyond what the schema states.

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, front-loaded with the core purpose. The second sentence explains the default and alternative, and the third sentence conveys an important side-effect. Every sentence earns its place, with no redundant or filler content.

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

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

For an 11-parameter tool with no output schema and no annotations, the description covers the core deployment workflow, the B20 vs erc20 choice, and a critical mint role behavior. Still, it omits explicit guidance on what to do with the returned calldata (e.g., send as a transaction) and does not mention the erc20 follow-up in the description itself, although the schema does. The undocumented locale/preferred_style/target_audience parameters also remain unaddressed.

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

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

The description enriches meaning for key parameters: token_standard (default vs legacy), extra_minters/agent_wallet_address (MINT_ROLE atomic granting), and implies the need for name/symbol. Schema coverage is 73%, leaving locale, preferred_style, and target_audience undocumented in both schema and description. However, the description still adds substantial value beyond the schema for the most operationally important 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 opens with 'Get factory calldata to deploy a new loyalty token on Base,' providing a specific verb, resource, and platform. It clearly distinguishes from sibling tools like create_reward or create_gift_certificate by focusing on deploying a token rather than creating rewards or certificates, and it differentiates from activate_loyalty_program as a deployment-time action.

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

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

The description explicitly states the default token_standard ('b20') and how to switch to the legacy factory via 'token_standard='erc20''. It also explains the benefit of B20's atomic MINT_ROLE granting, which helps the agent decide when to use B20. However, it does not explicitly direct users to alternative tools like activate_loyalty_program for the erc20 follow-up, so exclusions are only implicit.

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

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

With no annotations provided, the description bears full responsibility for disclosing behavioral traits. It merely says 'create' without explaining side effects, irreversibility, permission requirements, or what happens upon creation. This is a significant gap for a mutating 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?

Two sentences, front-loaded with the core purpose and followed by a usage condition. No wasted words, highly efficient and scannable.

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 7 parameters, no output schema, and no annotations, the description provides purpose and usage but lacks crucial context about return values, prerequisites, or side effects. The schema covers parameter semantics well, but the description does not compensate for other missing 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 input schema covers 100% of parameters with descriptions, so the baseline is 3. The tool description adds no additional parameter meaning beyond what the schema already provides.

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

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

The description clearly states the action ('Create') and the resource ('a personalized offer for a specific customer'), explicitly distinguishing it from sibling tools like create_reward by emphasizing personalization and customer-specific targeting. It also provides concrete examples (inactive customers, high-value segments) that reinforce its unique 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 gives an explicit 'when to use' condition ('when analytics reveal engagement patterns') with examples, but lacks any 'when not to use' guidance or direct mention of alternative tools. This is clear context but falls short of the full 5-point criterion.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool creates a reward but does not mention any side effects, prerequisites (e.g., an existing loyalty program), permission requirements, or whether the operation is reversible. This is a significant gap for a mutation 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 a single, clear, front-loaded sentence with no redundant information. It earns its place by stating the core function in an efficient manner.

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 no output schema and no annotations, the description should explain return behavior, prerequisites, and relation to other loyalty program entities. It only states the basic action, leaving out important context such as whether a loyalty program must already exist or what the response contains. The tool has 4 parameters and sits in a complex set of sibling tools, so this brevity is insufficient.

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

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

Schema description coverage is 100%, with each parameter already documented (e.g., cost is 'Token cost to redeem'). The description adds no extra meaning beyond the schema; it merely restates the token-based redemption concept. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses the specific verb 'Create' with a clear resource ('reward') and a qualifying phrase ('redeemable with loyalty tokens') that distinguishes it from sibling tools like create_gift_certificate and create_personalized_offer. It precisely states the action and object.

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 indicates when to use this tool (when creating a reward), but provides no explicit guidance on when not to use it or how it differs from similar creation tools such as create_gift_certificate or create_personalized_offer. The usage context is implied rather than clarified.

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?

No annotations are provided, so the description must fully disclose behavioral traits. It states 'delete' but does not clarify whether deletion is permanent, reversible, or requires special permissions, nor does it mention side effects on related data. This is a significant gap for a destructive 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?

Two short sentences, front-loaded with the action 'Delete a report'. The second sentence is slightly redundant with the first ('no longer relevant' vs 'outdated or irrelevant'), but overall it is concise and efficiently structured.

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

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

The tool is simple with one parameter and no output schema. The description explains what and when, but omits critical context for a delete operation such as irreversibility, permissions, or post-delete effects. It is minimally adequate but leaves gaps.

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

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

Input schema covers report_id with 100% schema description coverage, already stating it is a UUID of the report to delete. The description adds no parameter-specific meaning beyond the schema, so the baseline of 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?

Description clearly states the action 'Delete a report' with a specific resource. It adds context 'no longer relevant' but does not explicitly distinguish from sibling tools like update_report_status, though 'delete' is a distinct operation.

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

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

Provides explicit usage context: 'Use to clean up outdated or irrelevant reports.' This offers clear when-to-use guidance but does not mention alternatives or exclusions, such as update_report_status for status changes instead of deletion.

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

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

With no annotations, the description fully carries the transparency burden. It discloses the fee-first call ordering, atomic submission via EIP-5792, the required follow-up confirm_mint_fee call, and the consequence that unconfirmed fee obligations block future mints. These are substantial behavioral traits that an agent needs to know.

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, dense with necessary information. It front-loads the primary action, then explains the output format and required follow-up. No redundant or filler content — every clause serves a purpose.

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

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

The description covers the essential workflow: input values, output bundle structure, submission order, atomicity requirement, confirmation step, and blocking behavior. It lacks minor contextual details like fee calculation basis or program activation prerequisites, but given the absence of output schema and annotations, it is highly 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?

The input schema already provides descriptions for all parameters (100% coverage). The description mentions 'purchase amount' and 'cashback rate' but does not add new semantic detail about parameter formats or constraints beyond what the schema states. It meets the baseline for fully covered schemas.

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 'Calculate and mint loyalty tokens based on purchase amount and program's cashback rate' — a specific verb and resource. It further distinguishes itself from the similar sibling tool 'mint_loyalty_tokens' by detailing the fee-first calls bundle, making the tool's unique behavior clear.

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

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

The description provides clear step-by-step instructions (submit bundle, then call confirm_mint_fee) but does not explicitly contrast this tool with alternatives like mint_loyalty_tokens. It implies usage context through the workflow description but lacks explicit 'when to use vs. when not to use' 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It mentions the return payload (wallet addresses, stats, balances, tier info) and implies a read operation, but does not disclose authentication needs, rate limits, export size caps, or any side effects. This is moderate transparency.

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 concise sentences: the first states the core action, the second lists return fields and use cases. Every word earns its place 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?

For a simple tool with one well-documented parameter and no output schema, the description adequately covers the main purpose, return fields, and typical uses. It could mention export format or limits, but it remains sufficient for an agent to understand the tool's scope.

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

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

Schema coverage is 100% with 'Token address of the loyalty program' fully describing the sole parameter. The description's phrase 'for a specific loyalty program' adds no further meaning beyond the schema, so it adds minimal value.

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

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

The description clearly states the tool's function with a specific verb 'Export' and resource 'customer data for a specific loyalty program', and enumerates the returned data types. This distinguishes it from sibling tools like create_loyalty_program or get_program_analytics.

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 provides usage context with 'Use for analytics, segmentation, and personalized offers,' giving clear intended scenarios. However, it does not explicitly mention when not to use it or suggest alternative tools, so it stops short of full 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?

With no annotations, the description must disclose side effects and output nature. It mentions 'non-binding examples' and that agents must make their own choices, suggesting a non-mutating planning tool, but it does not explicitly state whether any state is changed or what the return structure looks like.

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

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

The description is two sentences, front-loaded with the core purpose and a clarifying constraint. Every word earns its place; no fluff.

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

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

Given six optional parameters and no output schema or annotations, the description is too terse to fully guide an agent. It lacks information on how the parameters are used, the format of the generated catalog, and the expected scope of the output.

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

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

The input schema has six parameters with no descriptions, and the description does not explain their meaning or how they influence the generated output. Parameter semantics are entirely absent beyond the parameter 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 clearly positions the tool as a workflow planner that outputs a field catalog, required parameters, next actions, and examples. The name 'generate_program_defaults' reinforces the purpose, and it distinguishes from siblings like create_loyalty_program by focusing on planning rather than execution.

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 in a planning workflow but does not explicitly state when to use it or mention alternative tools. The note about external agents choosing their own name/symbol/economics provides a hint but no direct guidance on prerequisites or context.

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

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

With no annotations provided, the description carries the full burden. The verb 'Get' implies a read-only operation and the phrase 'authenticated agent' signals an authentication requirement, but it does not disclose error conditions, side effects, or output behavior. A more explicit read-only/authentication statement would improve transparency.

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 conveys all essential information without superfluous words. 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 simple, parameterless read-only tool, the description is largely complete. It does not explain the output structure, but no output schema exists, and 'profile' is reasonably self-explanatory given common usage. Minor gaps remain around expected response fields.

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

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

The tool has zero parameters, so the input schema fully covers the parameter surface. The description adds no parameter-specific meaning, but none is needed; baseline for 0-parameter tools is 4.

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 'Get' and names the precise resource 'authenticated agent's profile', which distinguishes it from all sibling tools focused on loyalty, marketplace, or reports. Adding 'authenticated' clarifies the otherwise ambiguous 'my' from the tool name.

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 tool is for retrieving one's own profile, and no sibling tool serves a similar purpose. It does not explicitly state when not to use it, but the context is unambiguous due to the unique 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?

With no annotations, the description carries the full burden. 'Get info' strongly implies a read-only, non-destructive operation, which is a useful implicit disclosure. However, it does not explicitly state side-effect safety, permission requirements, or return behavior. For a zero-parameter getter, this is minimally transparent but not fully explicit.

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, extremely concise and front-loaded. Every word adds value, and there is no redundant or vague filler. 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?

Given the tool's simplicity (zero parameters, no output schema, no annotations), the description covers the essential invocation context: it tells the agent what the tool does and that it requires no inputs. It lacks details about the return structure or when to use it, but for a basic platform info getter, it is sufficiently complete for selection and 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 tool has zero parameters, so the schema covers everything with 100% coverage. The description adds no parameter information, but none is needed. Baseline for zero parameters is 4, and there is no deficiency to penalize.

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

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

The description clearly states the tool's function: 'Get info about Loyal Spark protocol on Base L2' uses a specific verb ('Get') and a clear resource ('info about Loyal Spark protocol on Base L2'). It distinguishes from siblings like get_platform_stats and get_my_profile, though 'info' is broader than these more specific sibling names.

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 any exclusions or preferred contexts, nor does it reference any sibling tools such as get_platform_stats or get_program_analytics. This is a clear gap for a tool with many related 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the admin-only requirement, which is a meaningful auth-related trait. However, it does not mention that the tool is read-only (implied by 'get'), the return format, or any rate limits, leaving some ambiguity for a stats 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 two short sentences with no fluff. It front-loads the primary action and resource, then gives the access constraint. 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?

Given the tool's simplicity (zero parameters, no output schema, no annotations), the description covers the essentials: what it returns (global statistics) and who can call it (admin-only). It lacks detail on the exact statistics or response structure, but for a no-arg getter, this is sufficient for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters and the input schema is empty with 100% coverage, so the baseline is 4. The description adds no parameter information, but none is needed since there are no parameters to document.

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 the specific verb 'Get' and identifies the resource as 'global platform statistics' with scope 'across all merchants', clearly distinguishing this tool from siblings like get_program_analytics and get_platform_info. It also notes the admin-only access, adding a precise constraint.

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 that the tool is admin-only, giving a clear access condition for when it should be used. It implies global scope ('across all merchants') rather than program-specific, but does not explicitly name alternative tools for comparison or 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?

With no annotations, the description carries the full burden. It does not disclose whether the tool is read-only, requires authentication, returns a report, or has any side effects. Minimal behavioral transparency.

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

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

A single, front-loaded sentence with no redundant filler. It states the action and the resource efficiently.

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

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

Despite the simple schema, the absence of an output schema and any details about what analytics are returned makes the description inadequate. It would benefit from mentioning typical metrics, time ranges, or the return format.

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

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

The tool has zero parameters, so there is nothing to explain. The description adds no param semantics, but the baseline for 0-param tools is 4, and the schema already covers this trivially.

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 clear verb ('Get') and resource ('analytics for your loyalty programs'), which distinguishes it from siblings like get_platform_stats or get_program_workflow_status. However, it doesn't specify what kind of analytics, so it's not maximally precise.

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

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

No guidance is provided about when to use this tool versus alternatives. The description only states what it does, not when to prefer it over other analytics or program 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only describes the output structure and an ambiguous parenthetical about parameter values, with no mention of side effects, permissions, safety, or failure modes. This is a significant gap for a read-only status 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 concise (one sentence) and front-loaded with the main purpose. It lists the key output elements, but the parenthetical is confusing and could be rephrased for clarity, preventing a 5.

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 no output schema and no annotations, the description must be more thorough. It lists output components but omits how token_address affects results, what 'current_step' specifically refers to, and whether the tool has side effects. This leaves significant gaps for an agent deciding to use and interpret the tool.

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

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

The input schema has 100% description coverage for the single optional parameter 'token_address'. The description adds no extra meaning about this parameter and even confuses with the 'parameter values' parenthetical. Baseline 3 applies because schema already documents the 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 uses a specific verb ('Explain') and identifies the resource ('next merchant action' in a program workflow). It lists the output components (current_step, required fields, ordered next_actions), giving a clear sense of what the tool does. However, it doesn't explicitly tie to 'program' from the name, and the parenthetical '(you provide all parameter values)' is ambiguous, slightly weakening 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 implies when to use the tool (when you need to understand the next merchant action in a workflow) but provides no explicit guidance on when not to use it or mention alternatives. It's adequate but does not differentiate from sibling tools like update_program_status or get_program_analytics.

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?

There are no annotations, so the description carries the full burden of disclosing behavioral traits. It only states what the tool returns, but does not explicitly confirm it is read-only, nor does it describe error handling or what happens if the customer or token does not exist. The word 'Get' implies non-mutation, but without annotations this is not sufficiently explicit.

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

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

The description is a single, concise sentence that starts with the verb 'Get' and immediately conveys the purpose. There is no filler or repetition, making it optimally sized and front-loaded.

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

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

This is a simple tool with two clearly described parameters and no output schema, so the description's claim of returning 'balance and tier info' is minimally adequate. However, it lacks details on the response structure (e.g., what fields constitute 'tier info'), potential errors, and typical use cases, leaving gaps for a complete understanding.

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

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

The input schema already provides descriptions for both parameters (token contract address, customer wallet) with 100% coverage. The tool description adds no additional meaning beyond the schema. Given the baseline of 3 for high schema coverage, this score 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 clearly states the action ('Get'), the resource ('loyalty token balance and tier info'), and the target ('for a customer'). It distinguishes itself from sibling tools like mint_loyalty_tokens or transfer_loyalty_tokens by being a read-only query, and the explicit mention of 'balance and tier info' makes it specific.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that get_my_profile might be used for the caller's own balance, or that this tool is for querying a specific customer's balance given a token address. No prerequisites or exclusions are stated, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description must carry the burden. 'List' implies a read-only operation, and the description adds that results include status and redemption info. However, it does not disclose pagination behavior, sorting, authentication needs, or any potential side effects.

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, well-structured sentence that directly states the tool's purpose and key output characteristics. Every word earns its place 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?

For a simple list tool with three optional parameters, the description is fairly complete: it names the resource and output highlights. However, no output schema exists and pagination/return format details are absent, leaving minor gaps for an agent needing precise response expectations.

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

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

Schema description coverage is 100%, and each parameter (limit, status, token_address) already has a clear description. The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline of 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 uses a specific verb ('List') and resource ('gift certificates issued by the agent's merchant'), clearly distinguishing it from siblings like create_gift_certificate or revoke_gift_certificate. The scope ('by the agent's merchant') adds precision.

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 for retrieving gift certificates in a merchant context but does not explicitly state when to prefer this over other list tools (e.g., list_rewards, list_loyalty_programs) or provide exclusions. Context is present but no direct alternative 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It adds the ownership scoping but does not mention whether expired programs are excluded by default, any permission requirements, side effects, or return format. The verb 'list' implies read-only, but this is not explicitly stated, and the description offers little beyond the tool name.

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, containing only essential information about the action and scope. There is no unnecessary detail 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?

Given the tool's simplicity (one optional parameter) and the schema's clear documentation of the 'include_expired' parameter, the description provides sufficient context for a basic list operation. The ownership scope is stated, and the parameter description implies the default filtering behavior. While an output schema is absent, it is not necessary for a simple list endpoint.

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 100% coverage for the single parameter 'include_expired' with a clear description, so the schema fully documents parameter semantics. The tool description does not add further meaning about parameters, but the baseline is 3 when schema coverage is high.

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 lists loyalty programs and specifies the scope 'owned by the agent's merchant', distinguishing it from sibling tools like 'create_loyalty_program' or 'list_gift_certificates'. The verb 'list' and resource are specific and unambiguous.

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

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

The description implies use for viewing the merchant's own loyalty programs, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It relies on the tool's name and context rather than providing explicit 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?

No annotations are provided, so the description carries the burden for behavioral disclosure. It states that only 'active' offers are listed, adding some context, but does not mention pagination, ordering, or that the status parameter can override the active filter.

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 states the action and resource with no unnecessary words.

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 listing tool with two optional parameters and no output schema, the description covers the core purpose. However, the absence of usage guidance and behavioral details (like pagination) keeps it from a perfect score.

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

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

Schema description coverage is 100% — both limit and status have descriptive text. The description adds no additional parameter information, so the baseline of 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 uses a specific verb ('List') and identifies the resource ('active token trading offers on the marketplace'), distinguishing it from related sibling tools like cancel_stale_offers or create_personalized_offer.

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 purpose implies the tool should be used to list active offers, but there is no explicit guidance on when to use it versus alternatives, nor any exclusions or 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds context by stating that the tool lists the user's own reports, shows statuses, and helps identify attention items. However, it does not mention authentication requirements, side effects (likely none), or output format details. The read-only nature is implied by 'List' but not explicitly confirmed.

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 the first sentence delivering the primary purpose ('List your previously submitted reports') and the second adding valuable use-case context. There is no redundant wording or filler.

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

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

Given the tool's simplicity (2 optional params, no output schema), the description adequately covers core purpose, scope ('your previously submitted reports'), and the utility of status checks. It could be more explicit about return structure or pagination, but for a basic list tool, it is sufficiently 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?

The input schema provides full coverage for both parameters: 'limit' (with range/default) and 'status' (with allowed values). The description adds slight extra context by restating the status values ('new/reviewed/done'), but it does not provide additional syntax or format details beyond the schema. Thus, 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 verb+resource+scope explicitly: 'List your previously submitted reports.' This clearly distinguishes it from sibling list tools like list_rewards and list_gift_certificates by focusing on the user's own reports. Mentioning statuses ('new/reviewed/done') reinforces the tool's specific purpose.

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

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

The description provides clear usage context: 'Allows reviewing past reports, checking status, and identifying what still needs attention.' This implies when to use the tool—when you need to review your own reports and their statuses. However, it does not explicitly mention alternatives or exclusions, such as 'for deleting, use delete_report,' although the sibling list makes it inferable.

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

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

With no annotations, the description carries the full burden. It discloses that the output includes redemption metrics (vouchers issued, redeemed, last-30-day counts), which informs the agent about the return content. The read-only nature is implied by 'List' but not explicitly stated, and no side effects are mentioned.

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 tight sentences: the main action is front-loaded, and the second sentence adds essential return-value detail. No filler or repetition; 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 simple one-parameter list operation with no output schema, the description fully covers what it does and what to expect (rewards with redemption metrics). It is complete enough for an agent to invoke correctly 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?

Schema coverage is 100% and the schema already describes token_address as 'Token contract address (0x...)'. The description repeats the parameter name and adds the context 'for a loyalty program,' but it does not add further format, constraints, or examples, so it adds marginal value beyond the schema.

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

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

The description begins with 'List rewards' — a specific verb and resource — and adds the scope 'by token_address.' This clearly distinguishes it from siblings like list_loyalty_programs (lists programs) and create_reward (creates rewards), so the purpose is unambiguous.

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

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

The phrase 'for a loyalty program by token_address' gives clear context on when to use it — when you have a token address and need the rewards for that program. However, it does not explicitly name alternatives or state when not to use it, 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?

No annotations are provided, so the description carries full burden. It discloses the core behavior: status change and hash storage. However, it does not mention failure modes, idempotency, or whether the operation is reversible, which are relevant for a state-changing tool. The status transition is useful, but additional behavioral context would improve transparency.

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 a clear conditional clause, actions, and state transition. Every word earns its place. It is front-loaded with the trigger context and ends with the specific result. No verbosity or redundancy.

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

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

For a simple state-update tool, the description covers what, when, and how. It implicitly references the pending_mint status prerequisite and the storage action. Lacking are details on return values or error handling, but the output schema is absent, so such details would be valuable. Still, the core semantics are complete enough for an agent to invoke 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 100%, so both parameters already have clear descriptions. The tool description adds the conceptual link between the parameters and the workflow (mint transaction, claimed certificate), but this does not significantly exceed what the schema already provides. 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 clearly states the action: 'mark it as minted' with the specific status transition 'pending_mint → redeemed' and storing the mint tx hash. This distinguishes it from sibling tools like create_gift_certificate or revoke_gift_certificate by naming the exact operation and state change.

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

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

The description provides a clear trigger condition: 'After the merchant submits the on-chain mint transaction for a claimed gift certificate'. This tells the agent when to use it. It does not explicitly mention when not to use it or alternatives, but the context is strong enough for correct 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?

With no annotations provided, the description fully discloses key behavioral traits: fee-first ordering, fee charged in merchant's loyalty tokens (not USDC), the need to confirm via a follow-up call, and blocking behavior for unconfirmed fees. This goes beyond minimal and gives the agent a clear picture of side effects and dependencies.

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 dense but every sentence adds value: purpose, fee order, fee currency, submission method, follow-up requirement, and blocking condition. No fluff; the structure flows logically from what the tool does to how to use it. The length is justified by 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?

The tool has a complex workflow with no output schema and no annotations, yet the description covers the critical context: what is returned (a calls[] bundle), how to execute it (EIP-5792), what to do next (confirm_mint_fee), and downstream effects (blocked mints). This is complete for an agent to invoke the tool correctly.

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

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

The input schema already describes all three parameters with 100% coverage. The description adds context about the fee being in merchant tokens but does not elaborate on parameter formats or constraints beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's function: 'Record mint intent and get a fee-first calls[] bundle.' It specifies the resource (loyalty tokens) and the exact behavior (fee mint before recipient mint), distinguishing it from siblings like confirm_mint_fee and transfer_loyalty_tokens.

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

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

The description provides a clear usage workflow: submit the calls in order, optionally via EIP-5792, then call confirm_mint_fee with the fee tx hash. It also warns that unconfirmed fee obligations block future mints. It does not explicitly name alternatives to avoid, but the context is strong enough for an agent to know when to use this tool.

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?

No annotations are provided, so the description carries the full burden. It discloses the primary side effect (creating a voucher) and a key prerequisite (verified transaction hash). However, it does not describe failure modes, idempotency, authentication requirements, or what happens if the hash is invalid. The description provides some behavioral context but is not comprehensive.

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, front-loaded with the verb, and contains no unnecessary words. It efficiently communicates the action, prerequisite, and outcome.

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

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

For a tool with only three parameters, all well-documented in the schema, the description provides enough context for an agent to decide when and how to invoke it. It clearly states the outcome (voucher creation). The lack of an output schema and absence of return-value description are minor gaps, but overall the description is sufficient 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 input schema descriptions already cover all three parameters with 100% coverage (reward_id, customer_address, transaction_hash). The description reinforces the transaction_hash as 'verified' and the customer_address as the customer who transferred tokens, but it adds only marginal meaning beyond the schema. The baseline of 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 uses a specific verb ('Redeem') and clearly identifies the resource ('reward') and the required input ('verified token transfer transaction hash'). It also states the outcome ('Creates a voucher for the customer'), which distinguishes it from sibling tools like use_voucher, check_voucher_status, and create_reward.

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 clear context: the agent should use this tool when a token transfer has occurred and a reward needs to be redeemed, resulting in a voucher. However, it does not explicitly state when not to use it or mention alternatives such as update_reward_status or use_voucher, 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?

No annotations are provided, so the description carries the burden of disclosure. It does reveal a key behavioral trait: the active/inactive status depends on token standard. However, it does not disclose other side effects like idempotency, failure modes, or required prior steps (beyond 'deployed'), leaving some transparency gaps.

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 clear sentences. The first sentence front-loads the action and resource; the second adds a critical conditional behavior. No wasted words, and it is easy to parse.

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 covers the main purpose and a key behavioral distinction, but with 7 parameters and no output schema or annotations, more context could be useful—such as how this differs from create_loyalty_program, behavior on duplicate token addresses, or what the tool returns. It is adequate 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 coverage is 100%, giving a baseline of 3. The description adds semantic meaning to the token_standard parameter by explaining that B20 tokens become active and legacy ERC-20 become inactive, which helps agents map the parameter to real-world behavior. This extra context justifies a score above baseline.

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

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

The description clearly states the tool's function: registering a deployed token as a loyalty program in the database. It distinguishes from siblings like create_loyalty_program by specifying 'deployed token' and adds behavioral nuance (B20 active, ERC-20 inactive), 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 implies usage when a token is deployed and needs to be registered, and the B20/ERC-20 distinction gives conditional behavior. However, it does not explicitly mention when to use this tool versus alternatives like create_loyalty_program or activate_loyalty_program, nor does it provide 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the state change, the permission requirement, and the restriction on redeemed/minted certificates. It could further note irreversibility or side effects, but the essential behaviors are transparent.

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

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

The description is three sentences long, each adding a distinct piece of information: action, permission, and constraint. There is no fluff or repetition; it is efficiently structured and front-loaded with the main action.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers all key aspects: what it does, who can invoke it, and when it cannot be applied. It does not describe error handling or return values, but these are not essential for this straightforward operation.

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 already documents certificate_id with provenance ('from create_gift_certificate / list_gift_certificates'), giving 100% coverage. The description adds meaningful parameter-related context by specifying that the certificate must be active, which helps the agent select a valid ID and avoid errors.

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

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

The description clearly states the action ('Revoke'), the resource ('gift certificate'), and the specific status transition ('active → revoked'). It is distinguishable from sibling tools like create_gift_certificate and list_gift_certificates, and the inclusion of eligibility criteria reinforces its unique 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?

It explicitly states who can use it ('Only the issuing merchant') and when it cannot be used ('Already-redeemed/minted certificates cannot be revoked'). This provides clear guidance on appropriate invocation, even without naming a specific alternative tool.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states the report 'will appear in the merchant's Agent Reports dashboard,' establishing the audience and expected outcome. It does not mention permissions, reversibility, or response behavior, but the stated side effect is sufficient for a submission 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 two sentences, front-loaded with the primary action, and every clause adds value. There is no filler or repetition of schema content.

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

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

The tool is simple, the schema covers all parameters thoroughly, and the description covers purpose, usage context, and the resulting dashboard behavior. There is no output schema and return values are not described, but for a send-report action this is not a critical omission.

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?

All six parameters have descriptions in the schema, so the description adds little beyond examples of report types. It does not elaborate on priority or action_items beyond the schema, so the baseline 3 is appropriate given 100% schema coverage.

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

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

The description uses a specific verb and resource: 'Send a report to the developer/owner.' It lists concrete use cases (SEO audits, growth ideas, data reports, etc.) and names the destination dashboard, clearly distinguishing it from sibling tools like list_my_reports, delete_report, and update_report_status.

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 provides explicit guidance on when to use the tool via 'Use this to submit...' and enumerates relevant report categories. However, it does not explicitly state when not to use it or name alternatives, so it does not quite reach 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?

There are no annotations, so the description bears the full burden of behavioral disclosure. It does disclose the key non-obvious behavior that the tool only returns calldata rather than executing the transfer ('Get calldata to transfer'), which is useful. However, it omits details such as whether the caller must hold tokens, whether approval is needed, or what the calldata format looks like.

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

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

The description is a single, well-structured sentence that is entirely front-loaded. It states the action and the object without any filler or redundant information, making it efficient and easy to parse.

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

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

For a tool with no annotations, no output schema, and only three straightforward parameters, the description provides the core purpose and the fact that it returns calldata. However, it lacks any context about the return value's structure, potential errors, or how the calldata should be used in an actual transaction, leaving some gaps for an agent.

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

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

The input schema covers all three parameters (to, amount, token_address) with descriptions, achieving 100% coverage. The description adds no additional parameter semantics beyond the schema, so it meets the baseline but does not exceed it.

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

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

The description clearly states the tool's function: 'Get calldata to transfer loyalty tokens between wallets.' It uses a specific verb ('Get calldata') and identifies the resource (loyalty tokens) and the action (transfer between wallets), distinguishing it from sibling tools like mint_loyalty_tokens and redeem_reward.

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 any exclusion criteria, prerequisites, or suggest when to prefer transfer_loyalty_tokens over mint_loyalty_tokens or other token-related tools. The agent is left to infer usage from the tool name alone.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that the tool updates the default values, but it does not mention side effects, permission requirements, or whether existing transactions are affected. The dashboard slider analogy adds some context, but important behavioral traits remain unspecified.

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 short sentence that conveys the purpose and a useful analogy. No fluff; 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 relatively simple config-update tool with a complete schema and no output schema, the description provides enough to understand the operation. It lacks explicit usage exclusions and some behavioral details, which are minor gaps 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 input schema already describes all three parameters with high coverage (100%), so the description doesn't need to repeat them. The description mentions the two optional parameters by name but adds no new semantic detail beyond the schema's existing descriptions of 'default' values.

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 'Update default cashback_rate and/or points_per_dollar' with a specific verb and resource, and the parenthetical 'same as merchant dashboard sliders' adds user context. This distinguishes it from sibling tools like update_program_status and create_loyalty_program.

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 clear context that this tool modifies program config defaults, and the 'same as merchant dashboard sliders' analogy helps understand the intended use case. However, it does not explicitly contrast with alternatives like update_program_status, so it lacks explicit when/when-not guidance.

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

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

No annotations are provided, so the description alone must disclose behaviors. It only states the action ('update program status') without detailing side effects, permissions, reversibility, or return values. The 'after onchain activation/pause' hint adds some context but doesn't cover the mutation's implications.

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 action. No wasted words, and it communicates the essential purpose clearly.

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 simplicity of the tool (2 params, full schema coverage, no output schema), the description is minimally viable. However, it lacks usage guidance and behavioral disclosure, making it less complete compared to similar tools with richer 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 100%, with both parameters documented (status and token_address). The description adds no additional parameter meaning beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states the verb (update), resource (program status), and context (after onchain activation/pause). It distinguishes from sibling tools like update_program_config by specifying it updates status in the database, not configuration.

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 onchain activation/pause' provides clear context for when to use this tool. However, it does not explicitly mention alternatives or when not to use it, so it lacks explicit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It confirms this is a mutation operation and explains the semantics of the two statuses, but it does not mention permissions, side effects, or whether the operation is reversible. This is adequate but leaves gaps.

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 concise sentences, front-loaded with the core action and immediately useful distinction between statuses. Every word earns its place 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?

For a simple 2-parameter update with no output schema, the description sufficiently covers the purpose and the meaning of the statuses. It could mention return behavior or error conditions, but given the tool's simplicity, those are minor omissions.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value beyond the schema by explaining when to use each status value ('done' vs 'reviewed'), which is more meaningful than the schema's simple 'New status: reviewed or done'.

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

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

The description clearly states the action ('update'), the resource ('report status'), and the exact allowed values ('reviewed' or 'done'). It distinguishes itself from sibling tools like update_program_status and update_reward_status by specifically targeting report status.

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 explicit guidance on when to choose each status: 'done' for completed action items and 'reviewed' to acknowledge a report. While it doesn't discuss alternative tools or exclusion criteria, the context for using this tool's statuses is clear.

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?

No annotations are provided, and the description does not disclose behavioral traits beyond the basic action. It is a mutation tool (activate/deactivate) with no mention of side effects, reversibility, permissions, or consequences for active rewards. This is a significant gap given the absence of annotation support.

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 that are front-loaded with the verb and object. Every word earns its place; there is no fluff or redundancy.

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

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

For a simple two-parameter mutation tool with full schema coverage, the description provides sufficient context: what it does, when to use it, and the parameters are self-documented. It lacks any note on return values or error conditions, but given the simplicity and lack of output schema, the description is reasonably 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?

The schema describes both parameters with 100% coverage, including 'true to activate, false to deactivate' for is_active. The description adds little beyond the schema, as 'activate or deactivate' mirrors the schema's boolean meaning. Baseline 3 is appropriate since the schema carries the semantic load.

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 'Activate or deactivate a reward in the catalog' with a specific verb and resource, and it distinguishes from sibling tools like create_reward, list_rewards, and redeem_reward by focusing on availability toggling. The phrase 'based on analytics' further clarifies the intended use case.

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 clear context on when to use the tool ('Use to manage reward availability based on analytics') but does not explicitly mention when not to use it or name alternative tools. This falls short of being explicit about exclusions but is still clear in its intended application.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It does disclose that this is a merchant-only mutation and describes the redemption scenario. However, it does not mention idempotency, behavior if the voucher is already used, reversibility, or error conditions. For a state-changing operation, this is a moderate level of transparency but far from complete.

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

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

The description is extremely concise and front-loaded: a short main clause followed by a clarifying parenthetical and a restriction. Both sentences earn their place 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?

For a simple tool with two params and no output schema, the description covers purpose, usage context, and authorization restriction. It does not mention potential prerequisite checks (e.g., verifying status before marking) or failure semantics, but given the tool's simplicity and the lack of annotations, it is still reasonably complete.

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

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

Schema description coverage is 100%: both voucher_id and voucher_code have clear descriptive text including the alternation between them and the format of the code. The description adds no additional parameter meaning, so baseline 3 is appropriate.

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

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

The description clearly states the action 'Mark a voucher as used' with the context 'redeemed by customer at merchant'. This specific verb+resource distinguishes it from sibling tools like check_voucher_status (read-only status check) and redeem_reward (rewards, not vouchers). The 'Merchant-only operation' qualifier adds further clarity on the intended actor.

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

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

The description indicates when to use the tool (at the point of customer redemption at a merchant) and adds a restriction ('Merchant-only operation'). However, it does not explicitly name alternatives or exclusions, such as using check_voucher_status for querying status before marking as used. The context implies the scenario but lacks explicit when-not guidance.

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